! \class OperandWrapper * \brief The exception class used by operand wrappers. */

\class BinaryEntry ! \brief Entry of the oracle table for binary operators synthesis. */

! \class MemoryAccess * \brief The exception class used by memory access. */

! \class Instruction * \brief The exception class used by an instruction. */

! \class Ast * \brief The exception class used by all AST nodes. */

\class UnaryEntry ! \brief Entry of the oracle table for unary operators synthesis. */

! \class Semantics * \brief The exception class used by all semantics. */

! \class AstLifting * \brief The exception class used by all AST lifting (e.g `z3 <-> triton`). */

! \class Immediate * \brief This class is used to represent an immediate. */

! \class Architecture * \brief The exception class used by architectures. */

! \class SymbolicEngine * \brief The exception class used by the symbolic engine. */

! \class Exception * \brief The root class of all exceptions. */

! \class Cpu * \brief The exception class used by all CPUs. */

! \class Disassembly * \brief The exception class used by the disassembler. */

! \class SolverEngine * \brief The exception class used by the solver engine. */

! \class Register * \brief This class is used when an instruction has a register operand. */

! \class API * \brief This is used as C++ API. */

! \class Bindings * \brief The exception class used by bindings. */

! \class Engines * \brief The exception class used by all engines. */

\class Callbacks ! \brief The callbacks class */

! \class AstRepresentation * \brief The exception class used by all AST node representations. */

\class ConstantEntry ! \brief Entry of the oracle table for constant synthesis. */

! \class IrBuilder * \brief The IR builder. */

! \class ArmOperandProperties * \brief The exception class used by shift mode. */

! \class Callbacks * \brief The exception class used by python callbacks. */

! \class TaintEngine * \brief The exception class used by the taint engine. */

! \class BitsVector * \brief This class is used to deal with registers and memory as bits vector. */

! \class PathConstraint * \brief The exception class used by path constraints. */

! \class PathManager * \brief The exception class used by the path manager. */

! \class SolverModel * \brief The exception class used by solver models. */

! \class SynthesizerEngine * \brief The exception class used by the synthesizer engine. */

\class TritonToBitwuzla ! \brief Converts a Triton's AST to Bitwuzla's AST. */

! \class LiftingEngine * \brief The exception class used by the lifting engine. */

\class LiftingToSMT ! \brief The lifting to SMT class. */

! \class SymbolicSimplification * \brief The exception class used by symbolic simplifications. */

\class AArch64Cpu ! \brief This class is used to describe the ARM (64-bits) spec. */

! \class AArch64OperandProperties * \brief The exception class used by shift mode. */

! \class AArch64Semantics \brief The AArch64 ISA semantics. */

\class AArch64Specifications ! \brief The AArch64Specifications class defines specifications about the AArch64 CPU */

! \class API * \brief The exception class used by the Triton's API. */

! \class Architecture * \brief The abstract architecture class. */

\class Arm32Cpu ! \brief This class is used to describe the ARM (32-bits) spec. */

! \class Arm32Semantics \brief The Arm32 ISA semantics. */

\class Arm32Specifications ! \brief The Arm32Specifications class defines specifications about the Arm32 CPU */

! \class ArmOperandProperties * \brief This class is used to represent specific properties of an Arm operand. */

`(assert <expr>)` node

\class AstContext ! \brief AST Context - Used as AST builder. */

Python representation.

Pseudo code of SMT AST.

! * \interface AstRepresentationInterface * \brief The AST representation interface. */

SMT representation.

BaseClass to test the simulation.

! \class BitsVector * \brief The exception class used by bitvectors. */

\class BitwuzlaSolver ! \brief Solver engine using Bitwuzla. */

`(bswap <expr>)` node

`(_ bv<value> <size>)` node

`(bvadd <expr1> <expr2>)` node

`(bvand <expr1> <expr2>)` node

`(bvashr <expr1> <expr2>)` node

`(bvlshr <expr1> <expr2>)` node

`(bvmul <expr1> <expr2>)` node

`(bvnand <expr1> <expr2>)` node

`(bvneg <expr>)` node

`(bvnor <expr1> <expr2>)` node

`(bvnot <expr>)` node

`(bvor <expr1> <expr2>)` node

`((_ rotate_left rot) <expr>)` node

`((_ rotate_right rot) <expr>)` node

`(bvsdiv <expr1> <expr2>)` node

`(bvsge <expr1> <expr2>)` node

`(bvsgt <expr1> <expr2>)` node

`(bvshl <expr1> <expr2>)` node

`(bvsle <expr1> <expr2>)` node

`(bvslt <expr1> <expr2>)` node

`(bvsmod <expr1> <expr2>)` node

`(bvsrem <expr1> <expr2>)` node

`(bvsub <expr1> <expr2>)` node

`(bvudiv <expr1> <expr2>)` node

`(bvuge <expr1> <expr2>)` node

`(bvugt <expr1> <expr2>)` node

`(bvule <expr1> <expr2>)` node

`(bvult <expr1> <expr2>)` node

`(bvurem <expr1> <expr2>)` node

`(bvxnor <expr1> <expr2>)` node

`(bvxor <expr1> <expr2>)` node

! \class Callbacks * \brief The exception class used by callbacks. */

`[<expr1> <expr2> <expr3> ...]` node

`(concat <expr1> <expr2> ...)` node

Used for a Register constructor.