Construct a new (empty) MemoryMap. */

! Return true if the mnemonic of the current instruction is equal to * Mnemonic. * * @param[in] mnemonic A null terminated instruction mnem

* if candidateSC is the Scratch register, load the real value of the scratch * register from the datablock to the reg * else, move the value fro

* if candidateSC is the Scratch register, move the value hold by reg in the * datablock * else, move the value in candidateSC */

! Return the logical inverse of condition. * * @param[in] condition Condition to evaluate. */

! Allocate a new offset variable with its offset value. * * @param[in] offset The offset value */

! Return true if the instruction opcode is equal to op. * * @param[in] op LLVM instruction opcode ID. */

! Represent an operand instruction identified by its index in the LLVM * MCInst representation of the instruction. * * @param[in] idx The op

! Return true if the operand is the expected register */

! Return true if one of the PatchCondition of the list conditions return * true (lazy evaluation). * * @param[in] conditions List of conditio

* QBDI library name

* Windows QBDI preload specific excetion handler * It must be uninstalled once used one time * The handler catches the first INT1 exception */

! Read a temporary value in the data block at the specified offset. * * @param[in] temp A temporary to store the shadow value. * @param[

! Create a new register variable. * * @param[in] id The id of the register to represent. */

! Create a new register variable. * * @param[in] id The llvm id of the register to represent. */

* Set DataBlock approximative address in reg */

! Remove the first occurence of reg in the operands of the instruction. * * @param[in] reg Register to remove from the operand list. */

! Set the opcode of the instruction. * * @param[in] opcode New opcode to set as the instruction opcode. */

! A patchGenerator for STM instruction that used PC * * Only one Temp can be used for all PatchGenerator that used the same * TempManager.

! Save a register in the data block at the specified offset. This can be * used to save register values in the context part of the data block. *

! Save the value of the temporary register in the datablock. * This can be used when an instruction can change the value of the register * used

! This patch allows to jump over PatchGenerator when an instruction has a * condition and the condition isn't reach at runtime. * If a tag (!= U

Set reg to the address of the Datablock */

! * * @param[in] temp Any unused temporary, overwritten by this generator. */

! Set the opcode of the instruction. * * @param[in] opcode New opcode to set as the instruction opcode. */

! Set the operand opn of the instruction as the Temp temp. * * @param[in] opn Operand index in the LLVM MCInst representation. * @param[in]

! Allocate a new shadow variable in the data block with the corresponding * tag. * * @param[in] tag The tag of the new shadow variable. *

! Simulate the effects of a call to the address stored in a temporary. The * target address overwrites the stored value of RIP in the context part

! Simulate the effects of the link operation performed by BL and BLX * instructions: the address of the next instruction is copied into the LR *

! Simulate the effects of a return instruction. First the return address is * popped from the stack into a temporary, then an optional stack deallo

! Substitute every reference to reg in the operands of the instruction with * temp. * * @param[in] reg Register which will be substituted.

! A patchGenerator for thumb2 BXAUT instruction to perform AUTG operation */

! A patchGenerator for thumb2 LDM instruction * * Only one Temp can be used for all PatchGenerator that used the same * TempManager. */

! A patchGenerator for thumb2 STM instruction * * Only one Temp can be used for all PatchGenerator that used the same * TempManager. */

! A patchGenerator for thumb2 TBB/TBH instruction * * Only one Temp can be used for all PatchGenerator that used the same * TempManager. *

! A patchGenerator for thumb POP (with PC) instruction * * Only one Temp can be used for all PatchGenerator that used the same * TempManager.

! Generate a label where the prologue can jump */

! Represent a temporary register variable idenified by a unique ID. Inside a * patch rules or a instrumentation rules, Temp with identical ids poin

! Return true. */

! Return true if the instruction uses reg as one of its operand. * * @param[in] reg The register to compare with. */

delete const move constructor and const move assignment operator

! Obtain the value of the operand op and copy it's value to the Datablock * Only Register operand is supported * * @param[in] op The ope

! Obtain the value of the operand op and copy it's value to the Datablock * Only Register operand is supported * * @param[in] op The ope

! Write PC in the DataBlock. Manage to add or remove the LSB when the * depending of the instruction behavior and the CPU behavior selected. *

! Write a temporary value in the data block at the specified offset. This * can be used to overwrite register values in the context part of the dat

! Write a temporary value in the data block at the specified offset if the * condition of the instruction is reached. This can be used to overwrite