LEVEL_CORE Namespace Reference


Typedefs

typedef EXT * EXTLIST
typedef size_t(* INS_BYTES_FETCHER )(VOID *buf, const VOID *insAddr, size_t size, EXCEPTION_INFO *pExceptInfo)
typedef INDEX< 202 > PREG
typedef ADDR< 200 > REGVALUE
typedef vector< ADDRINT > INS_REUSER_ID_VEC
typedef ADDRINT INS_REUSER_HANDLE
typedef ADDRINT INS_REUSER_STORE_HANDLE
typedef REGISTER_SET< REG_FirstInRegset,
REG_LastInRegset
REGSET
typedef REGISTER_SET< REG_FirstInRegsetPhyContext,
REG_LastInRegsetPhyContext
REGSET_CONTEXT
typedef FAST_REGISTER_SET<
REG_FirstInRegset, REG_LastInRegset
FAST_REGSET

Enumerations

enum  BBL_TYPE {
  BBL_TYPE_INVALID,
  BBL_TYPE_UBREAK,
  BBL_TYPE_CBREAK,
  BBL_TYPE_STOP,
  BBL_TYPE_UCALL_UNKNOWN,
  BBL_TYPE_UCALL_FUN,
  BBL_TYPE_UCALL_OS,
  BBL_TYPE_CCALL_OS,
  BBL_TYPE_CCALL_UNKNOWN,
  BBL_TYPE_CCALL_FUN,
  BBL_TYPE_NORMAL,
  BBL_TYPE_CBRANCH,
  BBL_TYPE_UBRANCH,
  BBL_TYPE_COUNTED,
  BBL_TYPE_SWPIPELINED,
  BBL_TYPE_CHECK,
  BBL_TYPE_PREFETCH,
  BBL_TYPE_UJUMP,
  BBL_TYPE_UJUMP_DYNLINK,
  BBL_TYPE_UJUMP_THUNK,
  BBL_TYPE_UJUMP_TRAMPOLINE,
  BBL_TYPE_UBRANCH_TRAMPOLINE,
  BBL_TYPE_CJUMP,
  BBL_TYPE_CJUMP_SWITCH,
  BBL_TYPE_STUB,
  BBL_TYPE_URETURN,
  BBL_TYPE_CRETURN,
  BBL_TYPE_DATA,
  BBL_TYPE_DATA_IADDR,
  BBL_TYPE_DATA_ARGBLOCK,
  BBL_TYPE_DATA_SWITCH1,
  BBL_TYPE_DATA_UNWIND,
  BBL_TYPE_DATA_LAST,
  BBL_TYPE_CONTAINER,
  BBL_TYPE_UNKNOWN,
  BBL_TYPE_VMSVC,
  BBL_TYPE_IBRANCH_LOOKUP,
  BBL_TYPE_EMU_FT,
  BBL_TYPE_UCALL_NATIVE_TARGET,
  BBL_TYPE_LAST
}
enum  BBL_STATE {
  BBL_STATE_INVALID,
  BBL_STATE_LAST
}
enum  CALLING_STANDARD {
  CALLING_STANDARD_INVALID,
  CALLING_STANDARD_IA32_CDECL,
  CALLING_STANDARD_IA32_REGPARM,
  CALLING_STANDARD_IA32E_WINDOWS,
  CALLING_STANDARD_IA32E_UNIX,
  CALLING_STANDARD_IA32_FASTCALL_WINDOWS,
  CALLING_STANDARD_IA32_STDCALL_WINDOWS,
  CALLING_STANDARD_IA32E_ART,
  CALLING_STANDARD_IA32_ART
}
enum  FUNCTION_TYPE {
  FUNCTION_TYPE_INVALID,
  FUNCTION_TYPE_ALL_LONG
}
enum  CHUNK_STATE {
  CHUNK_STATE_INVALID,
  CHUNK_STATE_LAST
}
enum  CHUNK_TYPE {
  CHUNK_TYPE_INVALID,
  CHUNK_TYPE_DATA,
  CHUNK_TYPE_CODE,
  CHUNK_TYPE_THUMB,
  CHUNK_TYPE_LAST
}
enum  EDG_TYPE {
  EDG_TYPE_INVALID,
  EDG_TYPE_RETURN,
  EDG_TYPE_CALL,
  EDG_TYPE_LINK,
  EDG_TYPE_COMP,
  EDG_TYPE_FALSE,
  EDG_TYPE_BRANCH,
  EDG_TYPE_SWITCH,
  EDG_TYPE_PREFETCH,
  EDG_TYPE_EXCEPTION,
  EDG_TYPE_NORMAL,
  EDG_TYPE_IBRANCH,
  EDG_TYPE_LAST
}
enum  EDG_STATE {
  EDG_STATE_INVALID,
  EDG_STATE_LAST
}
enum  EXT_ATTR_MODE {
  EXT_ATTR_MODE_INVALID,
  EXT_ATTR_MODE_SINGLE,
  EXT_ATTR_MODE_MULTIPLE
}
enum  IMG_TYPE {
  IMG_TYPE_INVALID,
  IMG_TYPE_STATIC,
  IMG_TYPE_SHARED,
  IMG_TYPE_SHAREDLIB,
  IMG_TYPE_RELOCATABLE,
  IMG_TYPE_DYNAMIC_CODE,
  IMG_TYPE_API_CREATED,
  IMG_TYPE_LAST
}
enum  IMG_STATE {
  IMG_STATE_INVALID,
  IMG_STATE_LAST
}
enum  IMG_BUILDER {
  IMG_BUILDER_INVALID,
  IMG_BUILDER_UNKNOWN,
  IMG_BUILDER_GNU3,
  IMG_BUILDER_ELECTRON_OLD,
  IMG_BUILDER_ELECTRON,
  IMG_BUILDER_LAST = IMG_BUILDER_ELECTRON
}
enum  MEMORY_TYPE {
  MEMORY_TYPE_READ,
  MEMORY_TYPE_WRITE,
  MEMORY_TYPE_READ2
}
enum  SYSCALL_STANDARD {
  SYSCALL_STANDARD_INVALID,
  SYSCALL_STANDARD_IA32_LINUX,
  SYSCALL_STANDARD_IA32_LINUX_SYSENTER,
  SYSCALL_STANDARD_IA32E_LINUX,
  SYSCALL_STANDARD_IA32_MAC,
  SYSCALL_STANDARD_IA32E_MAC,
  SYSCALL_STANDARD_IA32_WINDOWS_FAST,
  SYSCALL_STANDARD_IA32E_WINDOWS_FAST,
  SYSCALL_STANDARD_IA32_WINDOWS_ALT,
  SYSCALL_STANDARD_WOW64,
  SYSCALL_STANDARD_WINDOWS_INT
}
enum  REL_TYPE {
  REL_TYPE_INVALID,
  REL_TYPE_CHUNK_ABS32,
  REL_TYPE_CHUNK_ABS64,
  REL_TYPE_INS_PCREL,
  REL_TYPE_INS_IA32IMM
}
enum  RTN_TYPE {
  RTN_TYPE_INVALID,
  RTN_TYPE_CLONE,
  RTN_TYPE_STUB,
  RTN_TYPE_LINKER_TRAMPOLINE,
  RTN_TYPE_REGULAR,
  RTN_TYPE_LAST
}
enum  RTN_STATE {
  RTN_STATE_INVALID,
  RTN_STATE_LAST
}
enum  SACT_TYPE {
  SACT_INVALID,
  SACT_MAX_OUTPUTS,
  SACT_TARGET_INDIRECT_REG,
  SACT_CHAIN_LENGTH,
  SACT_IBLT,
  SACT_CLEAR_IBRANCH,
  SACT_NATIVE_CALL_TARGET,
  SACT_ACALL,
  SACT_AC_ON,
  SACT_ALIGN_REPLACEMENT,
  SACT_IS_BEFORE_CALL,
  SACT_VERSION,
  SACT_TARGET_VERSION,
  SACT_PUSH_CALLSITE,
  SACT_POP_CALLSITE,
  SACT_INSTRUMENTATION_ADDR
}
enum  SEGMENT_TYPE {
  SEGMENT_TYPE_INVALID,
  SEGMENT_TYPE_TEXT,
  SEGMENT_TYPE_DATA,
  SEGMENT_TYPE_BSS,
  SEGMENT_TYPE_STACK,
  SEGMENT_TYPE_THREAD,
  SEGMENT_TYPE_COMMENT,
  SEGMENT_TYPE_LAST
}
enum  SEC_STATE {
  SEC_STATE_INVALID,
  SEC_STATE_RAW_I,
  SEC_STATE_CHUNKED_I,
  SEC_STATE_DISASSEMBLED,
  SEC_STATE_CHUNKED_O,
  SEC_STATE_COOKED,
  SEC_STATE_RAW_O,
  SEC_STATE_LAST
}
enum  SEC_TYPE {
  SEC_TYPE_INVALID,
  SEC_TYPE_UNUSED,
  SEC_TYPE_REGREL,
  SEC_TYPE_DYNREL,
  SEC_TYPE_EXEC,
  SEC_TYPE_DATA,
  SEC_TYPE_DYNAMIC,
  SEC_TYPE_OPD,
  SEC_TYPE_GOT,
  SEC_TYPE_STACK,
  SEC_TYPE_PLTOFF,
  SEC_TYPE_HASH,
  SEC_TYPE_LSDA,
  SEC_TYPE_UNWIND,
  SEC_TYPE_UNWINDINFO,
  SEC_TYPE_REGSYM,
  SEC_TYPE_DYNSYM,
  SEC_TYPE_DEBUG,
  SEC_TYPE_BSS,
  SEC_TYPE_SYMSTR,
  SEC_TYPE_DYNSTR,
  SEC_TYPE_SECSTR,
  SEC_TYPE_COMMENT,
  SEC_TYPE_LOOS,
  SEC_TYPE_USER,
  SEC_TYPE_PROC,
  SEC_TYPE_LAST
}
enum  SYM_STATE {
  SYM_STATE_INVALID,
  SYM_STATE_RAW,
  SYM_STATE_LINKED,
  SYM_STATE_LAST
}
enum  SYM_IFUNC_TYPE {
  SYM_TYPE_NO_IFUNC = 0,
  SYM_TYPE_IFUNC_RESOLVER,
  SYM_TYPE_IFUNC_IMPL,
  SYM_TYPE_IFUNC_IMPL_ARTIFICIAL
}
enum  VAL_TYPE {
  VAL_TYPE_INVALID,
  VAL_TYPE_NONE,
  VAL_TYPE_INS,
  VAL_TYPE_BBL,
  VAL_TYPE_EDG,
  VAL_TYPE_REL,
  VAL_TYPE_RTN,
  VAL_TYPE_SEC,
  VAL_TYPE_SYM,
  VAL_TYPE_FILE,
  VAL_TYPE_META,
  VAL_TYPE_DATA,
  VAL_TYPE_IADDR,
  VAL_TYPE_GOT,
  VAL_TYPE_OPD,
  VAL_TYPE_LDEF,
  VAL_TYPE_CHUNK,
  VAL_TYPE_PLTOFF,
  VAL_TYPE_FLT64,
  VAL_TYPE_UINT64,
  VAL_TYPE_UINT32,
  VAL_TYPE_TWO_UINT32,
  VAL_TYPE_INT32,
  VAL_TYPE_SECOFF,
  VAL_TYPE_SYMOFF,
  VAL_TYPE_CHUNKOFF,
  VAL_TYPE_ZERO,
  VAL_TYPE_TRANSPARENT,
  VAL_TYPE_GP,
  VAL_TYPE_STRING,
  VAL_TYPE_REGUSE,
  VAL_TYPE_REG_INT32,
  VAL_TYPE_VERSIONCASE,
  VAL_TYPE_REGALLOCHINT,
  VAL_TYPE_SACT,
  VAL_TYPE_IADDR_INT32,
  VAL_TYPE_CONST_PTR,
  VAL_TYPE_PTR,
  VAL_TYPE_AFUNPTR,
  VAL_TYPE_LAST
}
enum  FLAGS {
  FLAGS_NONE = 0x00000000,
  FLAGS_CF = 0x00000001,
  FLAGS_PF = 0x00000004,
  FLAGS_AF = 0x00000010,
  FLAGS_ZF = 0x00000040,
  FLAGS_SF = 0x00000080,
  FLAGS_DF = 0x00000400,
  FLAGS_OF = 0x00000800,
  FLAGS_STATUS = FLAGS_CF|FLAGS_PF|FLAGS_AF|FLAGS_ZF|FLAGS_SF|FLAGS_OF,
  FLAGS_STATUS_ALL_BUT_ZF = FLAGS_CF|FLAGS_PF|FLAGS_AF|FLAGS_SF|FLAGS_OF,
  FLAGS_RF = (1<<16),
  FLAGS_AC = (1<<18),
  FLAGS_ID = (1<<21),
  FLAGS_ALL = 0xffffffff,
  FLAGS_LAST = FLAGS_ALL
}
enum  XED_OPERAND_NUMBER {
  XED_OPERAND_NUMBER_0 = 0,
  XED_OPERAND_NUMBER_1 = 1,
  XED_OPERAND_NUMBER_2 = 2,
  XED_OPERAND_NUMBER_3 = 3
}
enum  INS_REUSER_TYPE {
  INS_REUSER_TYPE_FIRST,
  INS_REUSER_TYPE_MM_INSERT_OP = INS_REUSER_TYPE_FIRST,
  INS_REUSER_TYPE_MM_EXTRACT_OP,
  INS_REUSER_TYPE_LOAD_MEM_OP,
  INS_REUSER_TYPE_STORE_MEM_OP,
  INS_REUSER_TYPE_REG_REG_OP,
  INS_REUSER_TYPE_REG_IMM_OP,
  INS_REUSER_TYPE_REG_OP,
  INS_REUSER_TYPE_SDISP_OP,
  INS_REUSER_TYPE_IMM_OP,
  INS_REUSER_TYPE_NO_REG_OP,
  INS_REUSER_TYPE_VZEROUPPER,
  INS_REUSER_TYPE_MEM_IMM_OP,
  INS_REUSER_TYPE_CHANGE_TO_IMM_OP,
  INS_REUSER_TYPE_SIZED_NOP,
  INS_REUSER_TYPE_MM_LOAD,
  INS_REUSER_TYPE_MM_STORE,
  INS_REUSER_TYPE_MM_REG_REG_OP,
  INS_REUSER_TYPE_YMM_REG_OP,
  INS_REUSER_TYPE_YMM_REG_REG_REG_OP,
  INS_REUSER_TYPE_RET_IMM,
  INS_REUSER_TYPE_WIDTH_REG_IMM_OP,
  INS_REUSER_TYPE_REG_WORD_REG_BYTE_OP,
  INS_REUSER_TYPE_REG_WIDTH_REG_OP,
  INS_REUSER_TYPE_LAST
}
enum  SYSCALL_TYPE {
  SYSCALL_TYPE_NONE = 0,
  SYSCALL_TYPE_SYSCALL = 1,
  OS_SYSCALL_TYPE_SYSENTER = 2,
  SYSCALL_TYPE_FARCALL = 3,
  OS_SYSCALL_TYPE_INT80 = 4,
  OS_SYSCALL_TYPE_INT81 = 5,
  OS_SYSCALL_TYPE_INT82 = 6,
  OS_SYSCALL_TYPE_INT83 = 7
}

Functions

ARRAYBASE AppArrayBase ("app pool", 1024)
STRIPE< APP_STRUCT_BASE > AppStripeBase ("app stripe base","core",&AppArrayBase)
INT32 APP_no (APP x)
APP APP_INVALID ()
BOOL APP_valid (APP x)
BOOL APP_allocated (APP x)
string str (APP app)
VOID APP_allocated_set (APP x, BOOL y)
VOID APP_next_set (APP x, APP y)
VOID APP_prev_set (APP x, APP y)
IMG APP_img_head (APP x)
VOID APP_img_head_set (APP x, IMG y)
IMG APP_img_tail (APP x)
VOID APP_img_tail_set (APP x, IMG y)
ADDRINT * APP_misc_addr (APP x)
VOID APP_GarbageCollect ()
APP APP_Alloc ()
VOID APP_Free (APP app)
ARRAYBASE BblArrayBase ("bbl pool", 1024 *1024)
STRIPE< BBL_STRUCT_BASE > BblStripeBase ("bbl stripe base","core",&BblArrayBase)
STRIPE< BBL_STRUCT_MAP > BblStripeMap ("bbl stripe map ","map",&BblArrayBase)
BBL BBL_INVALID ()
BOOL BBL_valid (BBL x)
INT32 BBL_no (BBL x)
BOOL BBL_allocated (BBL x)
BOOL BBL_original (BBL x)
BOOL BBL_mark (BBL x)
VOID BBL_mark_set (BBL x, BOOL y)
BOOL BBL_mark2 (BBL x)
VOID BBL_mark2_set (BBL x, BOOL y)
BOOL BBL_has_fallthru (BBL x)
VOID BBL_has_fallthru_set (BBL x, BOOL y)
BOOL BBL_hot (BBL x)
VOID BBL_hot_set (BBL x, BOOL y)
BOOL BBL_is_instrumentable (BBL x)
VOID BBL_is_instrumentable_set (BBL x, BOOL y)
BBL_TYPE BBL_type (BBL x)
RTN BBL_rtn (BBL x)
VOID BBL_rtn_set (BBL x, RTN y)
BBL BBL_next (BBL x)
BBL BBL_prev (BBL x)
INS BBL_ins_head (BBL x)
VOID BBL_ins_head_set (BBL x, INS y)
INS BBL_ins_tail (BBL x)
VOID BBL_ins_tail_set (BBL x, INS y)
EDG BBL_edg_pred (BBL x)
VOID BBL_edg_pred_set (BBL x, EDG y)
EDG BBL_edg_succ (BBL x)
VOID BBL_edg_succ_set (BBL x, EDG y)
EXT BBL_ext (BBL x)
BOOL BBL_IsData (BBL bbl)
VOID BBL_pos_set (BBL x, ADDRINT y)
ADDRINT BBL_pos (BBL x)
VOID BBL_type_set (BBL x, BBL_TYPE y)
BOOL BBL_persistent (BBL x)
VOID BBL_persistent_set (BBL x)
LOCALINLINE VOID BBL_allocated_set (BBL x, BOOL y)
LOCALINLINE VOID BBL_original_set (BBL x, BOOL y)
LOCALINLINE VOID BBL_next_set (BBL x, BBL y)
LOCALINLINE VOID BBL_prev_set (BBL x, BBL y)
VOID BBL_GarbageCollect ()
BOOL BBL_MarkBblStarts (BBL containerBbl)
BBL BBL_Alloc ()
VOID BBL_Free (BBL bbl)
VOID BBL_InsertBefore (BBL bbl, BBL before, RTN parent)
VOID BBL_Append (BBL bbl, RTN parent)
VOID BBL_InsertAfter (BBL bbl, BBL after, RTN parent)
VOID BBL_Prepend (BBL bbl, RTN parent)
VOID BBL_Unlink (BBL bbl)
VOID BBL_MoveInsToBefore (const BBL src, const BBL dst, INS before)
VOID BBL_MoveInsToAfter (const BBL src, const BBL dst, INS after)
BBL BBL_Clone (BBL bbl)
VOID BBL_InitOriginal (BBL bbl)
LOCALFUN UINT32 BBL_NumAttrRegsym (BBL bbl)
LOCALFUN UINT32 BBL_NumAttrDynsym (BBL bbl)
UINT32 BBL_NumAttrCrosslink (BBL bbl)
VOID BBL_MoveAllAttributes (BBL fromBbl, BBL toBbl)
UINT32 BBL_NumIns (BBL bbl)
UINT32 BBL_ByteSize (BBL bbl)
LOCALVAR const ATTRIBUTE ATTR_bbl_entry_point ("entry","cfg","entry_point", EXT_ATTR_MODE_SINGLE, VAL_TYPE_NONE, FALSE, FALSE,"is image entry poiny")
BOOL BBL_IsImageEntryPoint (BBL bbl)
VOID BBL_SetImageEntryPoint (BBL bbl)
BOOL BBL_ContainsCall (BBL bbl)
BOOL BBL_ContainsUnconditionalCall (BBL bbl)
BOOL BBL_ContainsConditionalCall (BBL bbl)
BOOL BBL_ContainsIndirectCall (BBL bbl)
BOOL BBL_ContainsDirectCall (BBL bbl)
BOOL BBL_ContainsConditionalControlTransfer (BBL bbl)
BOOL BBL_ContainsDirectControlTransfer (BBL bbl)
BOOL BBL_ContainsIndirectControlTransfer (BBL bbl)
BOOL BBL_IsReturnSite (BBL bbl)
BOOL BBL_HasUnmodeledSuccEdges (BBL bbl)
BOOL BBL_ContainsUnresolvedIndirectJump (BBL bbl)
BOOL BBL_ContainsReturn (BBL bbl)
LOCALFUN BOOL CHUNK_IsSwitchTable (CHUNK chunk)
BOOL BBL_HasUnmodeledPredEdges (BBL bbl, BOOL switch_ok)
BBL BBL_UniquePredecessor (BBL bbl)
BOOL BBL_CanBeEntryPoint (BBL bbl, BOOL switch_ok)
VOID BBL_TypeSet (BBL bbl, BBL_TYPE type)
string BBL_StringShort (BBL_TYPE type)
string str (BBL bbl)
string BBL_str (BBL bbl)
LOCALVAR const ATTRIBUTE ATTR_bbl_chunk ("chunk","bbl","bbl_chunk", EXT_ATTR_MODE_SINGLE, VAL_TYPE_CHUNK, B_CROSSLINK, FALSE,"chunk crosslinked with a type data bbl")
CHUNK BBL_DataChunk (BBL bbl)
VOID BBL_DataLinkWithChunk (BBL bbl, CHUNK chunk)
VOID BBL_DataUnlinkChunk (BBL bbl)
string BBL_StringLong (BBL bbl)
LOCALFUN string BBL_dotName (BBL bbl)
LOCALFUN string BBL_dotEdge (BBL bbl, EDG edg)
string BBL_generateDotCFG (BBL bbl)
OADDR BBL_GetOaddr (BBL target)
string BBL_StringLongFancy (BBL bbl)
VOID BBL_DeleteIns (BBL bbl)
VOID BBL_FreeSuccEdges (BBL bbl)
VOID BBL_FreePredEdges (BBL bbl)
VOID BBL_FreeContents (BBL bbl)
VOID BBL_UnlinkFreeCode (BBL bbl)
VOID BBL_UnlinkFreeData (BBL bbl)
BBL BBL_SplitAtIns (BBL firstBbl, INS splitIns)
VOID BBL_CheckFree ()
UINT32 CallingStd_DefaultArgSize (CALLING_STANDARD cstype)
BOOL CallingStd_IsArt (CALLING_STANDARD cstype)
string CallingStd_String (CALLING_STANDARD cstype)
BOOL INS_startbbl (INS x)
LOCALINLINE VOID INS_startbbl_set (INS x, BOOL y)
LOCALINLINE VOID INS_startrtn_set (INS x, BOOL y)
VOID INS_MarkBblStart (INS ins)
VOID INS_MarkRtnStart (INS ins)
LOCALFUN VOID SEC_MarkPcRelativeControlFlow (SEC sec)
VOID IMG_MarkPcRelativeControlFlow (IMG img)
UINT32 RTN_VerifyFallthroughs (RTN rtn)
VOID IMG_VerifyFallthroughs (IMG img)
VOID RTN_TypifyBblsAndCreateEdgs (RTN rtn)
VOID IMG_TypifyBblsAndCreateEdgs (IMG img)
VOID BBL_AddLinkEdge (BBL bbl, INS call)
BOOL BBL_IsCycle (BBL bbl)
BBL_TYPE BBL_TYPE_Unconditionalize (BBL_TYPE type)
LOCALVAR KNOB_COMMENT KnobCheckFamily ("supported:check","Self-checking done inside Pin")
BOOL CheckFree ()
VOID CheckAll ()
ARRAYBASE ChunkArrayBase ("chunk pool", 128 *1024)
STRIPE< CHUNK_STRUCT_BASE > ChunkStripeBase ("chunk stripe base","core",&ChunkArrayBase)
CHUNK CHUNK_INVALID ()
BOOL CHUNK_valid (CHUNK x)
INT32 CHUNK_no (CHUNK x)
BOOL CHUNK_allocated (CHUNK x)
BOOL CHUNK_original (CHUNK x)
CHUNK_TYPE CHUNK_type (CHUNK x)
VOID CHUNK_type_set (CHUNK x, CHUNK_TYPE y)
CHUNK_STATE CHUNK_state (CHUNK x)
VOID CHUNK_state_set (CHUNK x, CHUNK_STATE y)
SEC CHUNK_sec (CHUNK x)
VOID CHUNK_sec_set (CHUNK x, SEC y)
BBL CHUNK_bbl (CHUNK x)
VOID CHUNK_bbl_set (CHUNK x, BBL y)
CHUNK CHUNK_next (CHUNK x)
CHUNK CHUNK_prev (CHUNK x)
UINT32 CHUNK_alignment (CHUNK x)
VOID CHUNK_alignment_set (CHUNK x, UINT32 y)
const VOID * CHUNK_data_i (CHUNK x)
VOID * CHUNK_data_o (CHUNK x)
REL CHUNK_rel_head (CHUNK x)
VOID CHUNK_rel_head_set (CHUNK x, REL y)
REL CHUNK_rel_tail (CHUNK x)
VOID CHUNK_rel_tail_set (CHUNK x, REL y)
USIZE CHUNK_size_i (CHUNK x)
USIZE CHUNK_size_o (CHUNK x)
IADDR CHUNK_vaddr_i (CHUNK x)
VOID CHUNK_vaddr_i_set (CHUNK x, IADDR y)
OADDR CHUNK_vaddr_o (CHUNK x)
EXT CHUNK_ext (CHUNK x)
string str (CHUNK chunk)
LOCALINLINE VOID CHUNK_allocated_set (CHUNK x, BOOL y)
LOCALINLINE VOID CHUNK_original_set (CHUNK x, BOOL y)
LOCALINLINE VOID CHUNK_data_i_set (CHUNK x, const VOID *y)
LOCALINLINE VOID CHUNK_size_i_set (CHUNK x, UINT32 y)
LOCALINLINE VOID CHUNK_next_set (CHUNK x, CHUNK y)
LOCALINLINE VOID CHUNK_prev_set (CHUNK x, CHUNK y)
LOCALINLINE VOID CHUNK_size_o_set (CHUNK x, USIZE y)
LOCALINLINE VOID CHUNK_data_o_set (CHUNK x, VOID *y)
LOCALINLINE VOID CHUNK_vaddr_o_set (CHUNK x, OADDR y)
LOCALINLINE VOID CHUNK_size_max_set (CHUNK x, USIZE y)
LOCALINLINE USIZE CHUNK_size_max (CHUNK x)
VOID CHUNK_GarbageCollect ()
CHUNK CHUNK_Alloc ()
VOID CHUNK_Free (CHUNK chunk)
VOID CHUNK_InsertBefore (CHUNK chunk, CHUNK before, SEC parent)
VOID CHUNK_Append (CHUNK chunk, SEC parent)
VOID CHUNK_InsertAfter (CHUNK chunk, CHUNK after, SEC parent)
VOID CHUNK_Prepend (CHUNK chunk, SEC parent)
VOID CHUNK_Unlink (CHUNK chunk)
VOID CHUNK_Init (CHUNK chunk, CHUNK_TYPE type, USIZE size, const VOID *data, UINT32 alignment)
VOID CHUNK_InitOriginal (CHUNK chunk, CHUNK_TYPE type, IADDR vaddr, USIZE size, const VOID *data, UINT32 alignment)
LOCALFUN REL CHUNK_FindRelWithTargetOffAboveThreshold (CHUNK chunk, UINT32 offset)
LOCALFUN REL CHUNK_FindRelWithValueOffAboveThreshold (CHUNK chunk, UINT32 offset)
VOID CHUNK_SplitData (CHUNK chunk, UINT32 offset)
BOOL CHUNK_ContainsIaddr (CHUNK chunk, IADDR iaddr)
BOOL CHUNK_ContainsIaddrEndInclusive (CHUNK chunk, IADDR iaddr)
BOOL CHUNK_ContainsOaddr (CHUNK chunk, OADDR oaddr)
BOOL CHUNK_ContainsOaddrEndInclusive (CHUNK chunk, OADDR oaddr)
VOID CHUNK_PutODataByOffsetUINT32 (CHUNK chunk, USIZE offset, UINT32 value)
VOID CHUNK_PutODataByOffsetUINT64 (CHUNK chunk, USIZE offset, UINT64 value)
VOID CHUNK_PutIDataByOffsetUINT32 (CHUNK chunk, USIZE offset, UINT32 value)
VOID CHUNK_PutIDataByOffsetUINT64 (CHUNK chunk, USIZE offset, UINT64 value)
VOID CHUNK_PutUnalignedIDataByOffsetUINT64 (CHUNK chunk, USIZE offset, UINT64 value)
UINT32 CHUNK_GetUnalignedIDataByOffsetUINT32 (CHUNK chunk, USIZE offset)
UINT32 CHUNK_GetIDataByOffsetUINT32 (CHUNK chunk, USIZE offset)
UINT64 CHUNK_GetIDataByOffsetUINT64 (CHUNK chunk, USIZE offset)
UINT32 CHUNK_GetUnalignedIDataByOffsetUINT64 (CHUNK chunk, USIZE offset)
VOID CHUNK_SetNewSizeAndAddress (CHUNK chunk, USIZE size, OADDR oaddr)
VOID CHUNK_SetNewData (CHUNK chunk, VOID *data)
LOCALFUN string ChunkTypeString (CHUNK_TYPE type)
string CHUNK_StringShort (CHUNK chunk)
string CHUNK_StringLong (CHUNK chunk)
REL CHUNK_FindRelForOffset (CHUNK chunk, UINT32 offset)
USIZE CHUNK_AppendData (CHUNK chunk, USIZE num_bytes)
VOID CHUNK_Check (CHUNK chunk)
VOID IMG_SetNewChunkSizesAndAddresses (IMG img)
KNOB< BOOL > KnobAttachComment (KNOB_MODE_WRITEONCE,"supported","comment","0","Attach comments to data structures")
const ATTRIBUTE AttrComment ("comment:","core","comment", EXT_ATTR_MODE_SINGLE, VAL_TYPE_STRING, FALSE, FALSE,"comment")
VOID INS_AttachComment (const INS ins, string comment)
string INS_Comment (INS ins)
VOID INS_CopyComment (INS toIns, INS fromIns)
ARRAYBASE EdgArrayBase ("edg pool", 64 *1024)
STRIPE< EDG_STRUCT_BASE > EdgStripeBase ("edg stripe base","core",&EdgArrayBase)
EDG EDG_INVALID ()
BOOL EDG_valid (EDG x)
INT32 EDG_no (EDG x)
BOOL EDG_allocated (EDG x)
BOOL EDG_mark (EDG x)
VOID EDG_mark_set (EDG x, BOOL y)
BOOL EDG_mark2 (EDG x)
VOID EDG_mark2_set (EDG x, BOOL y)
EDG_TYPE EDG_type (EDG x)
VOID EDG_type_set (EDG x, EDG_TYPE y)
BOOL EDG_linked (EDG x)
BBL EDG_bbl_src (EDG x)
BBL EDG_bbl_dst (EDG x)
EDG EDG_next_succ (EDG x)
EDG EDG_next_pred (EDG x)
EXT EDG_ext (EDG x)
INT32 EDG_weight (EDG x)
VOID EDG_weight_set (EDG x, INT32 y)
LOCALINLINE VOID EDG_allocated_set (EDG x, BOOL y)
LOCALINLINE VOID EDG_linked_set (EDG x, BOOL y)
LOCALINLINE VOID EDG_next_succ_set (EDG x, EDG y)
LOCALINLINE VOID EDG_next_pred_set (EDG x, EDG y)
LOCALINLINE VOID EDG_bbl_dst_set (EDG x, BBL y)
LOCALINLINE VOID EDG_bbl_src_set (EDG x, BBL y)
VOID EDG_GarbageCollect ()
EDG EDG_Alloc ()
VOID EDG_Free (EDG edg)
EDG EDG_AllocAndLink (BBL src, BBL dst, EDG_TYPE type)
VOID EDG_PredInsertAfter (EDG edg, EDG after, BBL parent)
VOID EDG_PredPrepend (EDG edg, BBL parent)
VOID EDG_SuccInsertAfter (EDG edg, EDG after, BBL parent)
VOID EDG_SuccPrepend (EDG edg, BBL parent)
VOID EDG_Unlink (EDG edg)
LOCALFUN VOID EDG_UnlinkPred (EDG edg)
VOID EDG_UnlinkSucc (EDG edg)
BOOL BBL_CheckSuccEdgType (BBL bbl, EDG_TYPE et)
EDG BBL_SuccEdgFind (BBL src, EDG_TYPE type)
UINT32 BBL_AllowableSuccEdgCount (BBL bbl, UINT32 max)
LOCALFUN VOID EDG_UpdateBranchTargetField (EDG edg)
BOOL EDG_InterProcedural (EDG e)
VOID EDG_Link (EDG edg, BBL src, BBL dst)
VOID EDG_MoveSuccEdges (BBL a, BBL b)
VOID EDG_MovePredEdges (BBL bbl_from, BBL bbl_to)
string EDG_StringShort (EDG_TYPE type)
string str (EDG edg)
string EDG_StringShort (EDG edg)
BOOL EDG_IsFallthrough (EDG edg)
EDG BBL_PredEdgFind (BBL dst, EDG_TYPE type)
EDG BBL_SuccEdgFind (BBL src, BBL dst)
EDG BBL_SuccEdgFindWithType (BBL src, BBL dst, EDG_TYPE type)
EDG BBL_SuccEdgFindPcRelative (BBL bbl)
UINT32 BBL_NumPreds (BBL bbl)
UINT32 BBL_NumPredsInterproc (BBL bbl)
UINT32 BBL_NumPredsInterprocNonCall (BBL bbl)
UINT32 BBL_NumSuccs (BBL bbl)
VOID EDG_Check (EDG edg)
ARRAYBASE ExtArrayBase ("ext pool", 32 *1024)
STRIPE< EXT_STRUCT_BASE > ExtStripeBase ("ext stripe base","core",&ExtArrayBase)
EXT EXT_INVALID ()
BOOL EXT_valid (EXT x)
UINT32 EXT_number (EXT x)
UINT32 EXT_tag (EXT x)
EXT EXT_next (EXT n)
VOID EXT_next_set (EXT n, EXT v)
BOOL EXT_has_attribute (EXT n, const ATTRIBUTE *attr)
BOOL EXT_is_crosslink (EXT n)
BOOL EXT_is_hidden (EXT n)
VAL * EXT_value_val (EXT x)
VAL_TYPE EXT_value_type (EXT x)
SYM EXT_value_sym (EXT x)
CHUNK EXT_value_chunk (EXT x)
string * EXT_value_string (EXT x)
VOID EXT_value_string_set (EXT x, string *v)
REL EXT_value_rel (EXT x)
INT32 EXT_value_int32 (EXT x)
VOID EXT_value_int32_set (EXT x, INT32 v)
INS EXT_value_ins (EXT x)
BBL EXT_value_bbl (EXT x)
VOID EXT_value_bbl_set (EXT x, BBL v)
EDG EXT_value_edg (EXT x)
GOT EXT_value_got (EXT x)
FLT64 EXT_value_flt64 (EXT x)
VOID EXT_value_flt64_set (EXT x, FLT64 v)
UINT64 EXT_value_uint64 (EXT x)
VOID EXT_value_uint64_set (EXT x, UINT64 v)
UINT32 EXT_value_uint32 (EXT x)
VOID EXT_value_uint32_set (EXT x, UINT32 v)
REG EXT_value_reguse_reg (EXT x)
UINT32 EXT_value_reguse_use (EXT x)
VOID EXT_value_reguse_set (EXT x, REG r, UINT32 u)
REG EXT_value_regint32_reg (EXT x)
UINT32 EXT_value_regint32_int (EXT x)
VOID EXT_value_regint32_set (EXT x, REG r, INT32 u)
REG EXT_value_versioncase_reg (EXT x)
INT32 EXT_value_versioncase_casev (EXT x)
ADDRINT EXT_value_versioncase_version (EXT x)
VOID EXT_value_versioncase_set (EXT x, REG reg, INT32 casev, ADDRINT version)
IADDR EXT_value_iaddrint32_iaddr (EXT x)
INT32 EXT_value_iaddrint32_int32 (EXT x)
VOID EXT_value_iaddrint32_set (EXT x, IADDR ia, INT32 u)
REG EXT_value_regallochint_vreg (EXT x)
REG EXT_value_regallochint_preg (EXT x)
REGALLOC_HINT_TYPE EXT_value_regallochint_hint (EXT x)
VOID EXT_value_regallochint_set (EXT x, REG vr, REG pr, REGALLOC_HINT_TYPE h)
const SACT & EXT_value_sact (EXT x)
VOID EXT_value_sact_set (EXT x, SACT v)
IADDR EXT_value_iaddr (EXT x)
VOID EXT_value_iaddr_set (EXT x, IADDR v)
const VOID * EXT_value_const_ptr (EXT x)
VOID EXT_value_const_ptr_set (EXT x, const VOID *v)
VOID * EXT_value_ptr (EXT x)
VOID EXT_value_ptr_set (EXT x, VOID *v)
AFUNPTR EXT_value_afunptr (EXT x)
VOID EXT_value_afunptr_set (EXT x, AFUNPTR v)
BOOL EXT_linked (EXT n)
VOID EXT_linked_set (EXT n, BOOL v)
BOOL EXT_persistent (EXT x)
VOID EXT_persistent_set (EXT x)
VOID EXT_persistent_clear (EXT x)
LOCALINLINE BOOL EXT_allocated (EXT n)
LOCALINLINE VOID EXT_allocated_set (EXT n, BOOL v)
LOCALINLINE VOID INS_ext_set (INS n, EXT ext)
LOCALINLINE VOID BBL_ext_set (BBL n, EXT ext)
LOCALINLINE VOID EDG_ext_set (EDG n, EXT ext)
LOCALINLINE VOID RTN_ext_set (RTN n, EXT ext)
LOCALINLINE VOID CHUNK_ext_set (CHUNK n, EXT ext)
LOCALINLINE VOID EXT_number_set (EXT x, UINT32 v)
LOCALINLINE VOID EXT_tag_set (EXT x, UINT32 v)
LOCALINLINE VOID EXT_value_edg_set (EXT x, EDG v)
LOCALINLINE VOID EXT_value_ins_set (EXT x, INS v)
LOCALINLINE VOID EXT_value_sym_set (EXT x, SYM v)
LOCALINLINE VOID EXT_value_opd_set (EXT x, int v)
LOCALINLINE VOID EXT_value_chunk_set (EXT x, CHUNK v)
LOCALINLINE VOID EXT_value_pltoff_set (EXT x, int v)
LOCALINLINE VOID EXT_value_rel_set (EXT x, REL v)
LOCALINLINE VOID EXT_value_got_set (EXT x, GOT v)
LOCALINLINE INT32 EXT_no (EXT x)
VOID EXT_GarbageCollect ()
EXT EXT_Alloc ()
VOID EXT_Free (EXT ext)
VOID EXT_Copy (EXT ext, EXT clone)
EXT EXT_Clone (EXT ext)
EXT EXTLIST_ext (EXTLIST x)
VOID EXTLIST_ext_set (EXTLIST x, EXT y)
VOID EXTLIST_ExtPrepend (EXT ext, EXTLIST &parent)
VOID EXTLIST_ExtInsertAfter (EXT ext, EXT after, EXTLIST &parent)
VOID EXT_ExtlistUnlink (EXT ext, EXTLIST parent)
VOID EXTLIST_MoveInsExtRev (INS src, EXTLIST dst, const ATTRIBUTE *attr)
VOID INS_ExtInsertAfter (EXT ext, EXT after, INS parent)
VOID INS_ExtPrepend (EXT ext, INS parent)
VOID INS_ExtTransfer (INS src, INS dst)
UINT32 INS_NumExt (INS parent)
VOID EXT_InsUnlink (EXT ext, INS parent)
VOID BBL_ExtInsertAfter (EXT ext, EXT after, BBL parent)
VOID BBL_ExtPrepend (EXT ext, BBL parent)
VOID BBL_ExtAppend (EXT ext, BBL parent)
UINT32 BBL_NumExt (BBL parent)
VOID EXT_BblUnlink (EXT ext, BBL parent)
VOID EDG_ExtInsertAfter (EXT ext, EXT after, EDG parent)
VOID EDG_ExtPrepend (EXT ext, EDG parent)
UINT32 EDG_NumExt (EDG parent)
VOID EXT_EdgUnlink (EXT ext, EDG parent)
VOID RTN_ExtInsertAfter (EXT ext, EXT after, RTN parent)
VOID RTN_ExtPrepend (EXT ext, RTN parent)
UINT32 RTN_NumExt (RTN parent)
VOID EXT_RtnUnlink (EXT ext, RTN parent)
VOID CHUNK_ExtInsertAfter (EXT ext, EXT after, CHUNK parent)
VOID CHUNK_ExtPrepend (EXT ext, CHUNK parent)
UINT32 CHUNK_NumExt (CHUNK parent)
VOID EXT_ChunkUnlink (EXT ext, CHUNK parent)
EXT EXT_AllocAndLinkChunkGot (CHUNK chunk, const ATTRIBUTE *attribute, UINT32 number, GOT got)
EXT EXT_AllocAndLinkChunkSym (CHUNK chunk, const ATTRIBUTE *attribute, UINT32 number, SYM sym)
EXT EXT_AllocAndLinkChunkRel (CHUNK chunk, const ATTRIBUTE *attribute, UINT32 number, REL rel)
EXT EXT_AllocInsNone (const ATTRIBUTE *attribute, UINT32 number)
EXT EXT_AllocAndLinkInsNone (INS ins, const ATTRIBUTE *attribute, UINT32 number)
EXT EXT_AllocAndLinkInsUint32 (INS ins, const ATTRIBUTE *attribute, UINT32 number, UINT32 value)
EXT EXT_AllocAndLinkInsInt32 (INS ins, const ATTRIBUTE *attribute, UINT32 number, INT32 value)
EXT EXT_AllocAndLinkInsString (INS ins, const ATTRIBUTE *attribute, UINT32 number, string *value)
EXT EXT_AllocAndLinkInsFlt64 (INS ins, const ATTRIBUTE *attribute, UINT32 number, FLT64 value)
EXT EXT_AllocAndLinkInsUint64 (INS ins, const ATTRIBUTE *attribute, UINT32 number, UINT64 value)
EXT EXT_AllocAndLinkInsBbl (INS ins, const ATTRIBUTE *attribute, UINT32 number, BBL value)
EXT EXT_AllocAndLinkInsReguse (INS ins, const ATTRIBUTE *attribute, UINT32 number, REG reg, UINT32 use)
EXT EXT_AllocRegInt32 (const ATTRIBUTE *attribute, UINT32 number, REG reg, INT32 use)
EXT EXT_AllocVersionCase (const ATTRIBUTE *attribute, UINT32 number, REG reg, INT32 casev, ADDRINT version)
EXT EXT_AllocAndLinkInsRegInt32 (INS ins, const ATTRIBUTE *attribute, UINT32 number, REG reg, INT32 use)
EXT EXT_AllocIaddrInt32 (const ATTRIBUTE *attribute, UINT32 number, IADDR iaddr, INT32 val)
EXT EXT_AllocAndLinkInsRegallochint (INS ins, const ATTRIBUTE *attribute, UINT32 number, REG vreg, REG preg, REGALLOC_HINT_TYPE hint)
EXT EXT_AllocAndLinkBblRegallochint (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, REG vreg, REG preg, REGALLOC_HINT_TYPE hint)
EXT EXT_AllocAndLinkInsRel (INS ins, const ATTRIBUTE *attribute, UINT32 number, REL rel)
EXT EXT_AllocAndLinkBblBbl (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, BBL value)
EXT EXT_AllocAndLinkBblInt32 (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, INT32 value)
EXT EXT_AllocAndLinkBblUint32 (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, UINT32 value)
EXT EXT_AllocAndLinkBblIns (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, INS value)
EXT EXT_AllocAndLinkBblGot (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, GOT got)
EXT EXT_AllocAndLinkBblNone (BBL bbl, const ATTRIBUTE *attribute, UINT32 number)
EXT EXT_AllocAndLinkBblOpd (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, UINT32 index)
EXT EXT_AllocAndLinkBblPltoff (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, UINT32 index)
EXT EXT_AllocAndLinkBblFlt64 (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, FLT64 value)
EXT EXT_AllocAndLinkBblRel (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, REL rel)
EXT EXT_AllocAndLinkBblSym (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, SYM sym)
EXT EXT_AllocAndLinkBblChunk (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, CHUNK chunk)
EXT EXT_AllocAndLinkRtnSym (RTN rtn, const ATTRIBUTE *attribute, UINT32 number, SYM sym)
EXT EXT_AllocAndLinkRtnInt32 (RTN rtn, const ATTRIBUTE *attribute, UINT32 number, int value)
EXT EXT_AllocAndLinkRtnBbl (RTN rtn, const ATTRIBUTE *attribute, UINT32 number, BBL value)
EXT EXT_AllocAndLinkEdgEdg (EDG edg, const ATTRIBUTE *attribute, UINT32 number, EDG value)
EXT EXT_AllocAndLinkEdgFlt64 (EDG edg, const ATTRIBUTE *attribute, UINT32 number, FLT64 value)
EXT EXT_AllocAndLinkBblSact (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, SACT act)
EXT EXT_AllocAndLinkInsSact (INS ins, const ATTRIBUTE *attribute, UINT32 number, SACT act)
EXT EXT_AllocAndLinkInsConstPtr (INS ins, const ATTRIBUTE *attribute, UINT32 number, const VOID *ptr)
EXT EXT_AllocAndLinkInsPtr (INS ins, const ATTRIBUTE *attribute, UINT32 number, VOID *ptr)
EXT EXT_AllocAndLinkBblConstPtr (BBL bbl, const ATTRIBUTE *attribute, UINT32 number, const VOID *ptr)
EXT EXT_AllocAndLinkInsIaddr (INS ins, const ATTRIBUTE *attribute, UINT32 number, IADDR iaddr)
EXT EXT_AllocAndLinkInsAfunptr (INS ins, const ATTRIBUTE *attribute, UINT32 number, AFUNPTR fptr)
LOCALFUN EXT ext_FindExt (EXT ext, UINT16 tag)
EXT EXT_FindFirst (EXT ext, const ATTRIBUTE *attribute)
EXT EXT_FindNext (EXT ext)
string EXT_StringShort (EXT ext, BOOL tiny)
string EXT_ListString (EXT ext)
VOID EXT_Check (EXT ext)
VOID EXT_CheckFree ()
const ATTRIBUTE ATTR_ins_delete ("ins_delete","inst","ins_delete", EXT_ATTR_MODE_SINGLE, VAL_TYPE_NONE, FALSE, FALSE,"Delete instruction")
ARRAYBASE ImgArrayBase ("img pool", 1024)
STRIPE< IMG_STRUCT_BASE > ImgStripeBase ("img stripe base","core",&ImgArrayBase)
IMG IMG_INVALID ()
INT32 IMG_no (IMG x)
IMG_BUILDER IMG_builder (IMG x)
void IMG_builder_set (IMG x, IMG_BUILDER t)
IMG_TYPE IMG_type (IMG x)
void IMG_type_set (IMG x, IMG_TYPE y)
BOOL IMG_valid (IMG x)
IMG IMG_next (IMG x)
VOID IMG_next_set (IMG x, IMG y)
IMG IMG_prev (IMG x)
VOID IMG_prev_set (IMG x, IMG y)
SEC IMG_first_original_sec (IMG x)
VOID IMG_first_original_sec_set (IMG x, SEC y)
SEC IMG_sec_head (IMG x)
VOID IMG_sec_head_set (IMG x, SEC y)
SEC IMG_sec_tail (IMG x)
VOID IMG_sec_tail_set (IMG x, SEC y)
SYM IMG_first_original_symtab (IMG x)
VOID IMG_first_original_symtab_set (IMG x, SYM y)
SYM IMG_regsym_head (IMG x)
VOID IMG_regsym_head_set (IMG x, SYM y)
SYM IMG_regsym_tail (IMG x)
VOID IMG_regsym_tail_set (IMG x, SYM y)
SYM IMG_first_original_dynsym (IMG x)
VOID IMG_first_original_dynsym_set (IMG x, SYM y)
SYM IMG_dynsym_head (IMG x)
VOID IMG_dynsym_head_set (IMG x, SYM y)
SYM IMG_dynsym_tail (IMG x)
VOID IMG_dynsym_tail_set (IMG x, SYM y)
BBL IMG_entry (IMG x)
VOID IMG_entry_set (IMG x, BBL y)
const string & IMG_filename_i (IMG x)
VOID IMG_filename_i_set (IMG x, const string *y)
const VOID * IMG_data_i (IMG x)
VOID IMG_data_i_set (IMG x, const VOID *y)
USIZE IMG_size_i (IMG x)
VOID IMG_size_i_set (IMG x, UINT32 y)
UINT32 IMG_numpltoffentries (IMG x)
VOID IMG_numpltoffentries_set (IMG x, UINT32 y)
UINT64 IMG_pv_delta (IMG x)
VOID IMG_pv_delta_set (IMG x, UINT64 y)
IADDR IMG_gp_i (IMG x)
VOID IMG_gp_i_set (IMG x, IADDR y)
IADDR IMG_init (IMG x)
VOID IMG_init_set (IMG x, IADDR y)
IADDR IMG_seg_text_vaddr_i (IMG x)
IADDR IMG_seg_data_vaddr_i (IMG x)
OADDR IMG_seg_text_vaddr_o (IMG x)
OADDR IMG_seg_data_vaddr_o (IMG x)
USIZE IMG_seg_text_vsize_i (IMG x)
USIZE IMG_seg_data_vsize_i (IMG x)
USIZE IMG_seg_text_vsize_o (IMG x)
USIZE IMG_seg_data_vsize_o (IMG x)
USIZE IMG_seg_text_fsize_i (IMG x)
USIZE IMG_seg_data_fsize_i (IMG x)
USIZE IMG_seg_text_fsize_o (IMG x)
USIZE IMG_seg_data_fsize_o (IMG x)
USIZE IMG_seg_text_foffset_i (IMG x)
USIZE IMG_seg_data_foffset_i (IMG x)
USIZE IMG_seg_text_foffset_o (IMG x)
USIZE IMG_seg_data_foffset_o (IMG x)
VOID IMG_seg_text_vaddr_i_set (IMG x, IADDR y)
VOID IMG_seg_data_vaddr_i_set (IMG x, IADDR y)
VOID IMG_seg_text_vaddr_o_set (IMG x, OADDR y)
VOID IMG_seg_data_vaddr_o_set (IMG x, OADDR y)
VOID IMG_seg_text_vsize_i_set (IMG x, USIZE y)
VOID IMG_seg_data_vsize_i_set (IMG x, USIZE y)
VOID IMG_seg_text_vsize_o_set (IMG x, USIZE y)
VOID IMG_seg_data_vsize_o_set (IMG x, USIZE y)
VOID IMG_seg_text_fsize_i_set (IMG x, USIZE y)
VOID IMG_seg_data_fsize_i_set (IMG x, USIZE y)
VOID IMG_seg_text_fsize_o_set (IMG x, USIZE y)
VOID IMG_seg_data_fsize_o_set (IMG x, USIZE y)
VOID IMG_seg_text_foffset_i_set (IMG x, USIZE y)
VOID IMG_seg_data_foffset_i_set (IMG x, USIZE y)
VOID IMG_seg_text_foffset_o_set (IMG x, USIZE y)
VOID IMG_seg_data_foffset_o_set (IMG x, USIZE y)
OADDR IMG_gp_o (IMG x)
VOID IMG_gp_o_set (IMG x, OADDR y)
const VOID * IMG_fileheader_i (IMG x)
const VOID * IMG_progheaders_i (IMG x)
string str (IMG img)
ADDRINT IMG_load_offset (IMG x)
VOID IMG_load_offset_set (IMG x, ADDRINT y)
ADDRINT IMG_low_address (IMG x)
VOID IMG_low_address_set (IMG x, ADDRINT y)
ADDRINT IMG_high_address (IMG x)
VOID IMG_high_address_set (IMG x, ADDRINT y)
BOOL IMG_runtime (IMG x)
VOID IMG_runtime_set (IMG x, BOOL y)
BOOL IMG_text_from_image (IMG x)
VOID IMG_text_from_image_set (IMG x, BOOL y)
UINT32 IMG_unique_id (IMG x)
VOID IMG_unique_id_set (IMG x, UINT32 y)
IADDR IMG_entry_addr_i (IMG x)
VOID IMG_entry_addr_i_set (IMG x, IADDR y)
BOOL IMG_is_main_executable (IMG x)
VOID IMG_is_main_executable_set (IMG x, BOOL y)
BOOL IMG_x32 (IMG x)
VOID IMG_x32_set (IMG x, BOOL y)
VOID IMG_elf_object_set (IMG x, VOID *obj)
VOID * IMG_elf_object (IMG x)
BOOL IMG_found_in_memory (IMG x)
VOID IMG_found_in_memory_set (IMG x, BOOL y)
BOOL IMG_allocated (IMG x)
UINT32 IMG_num_regions (IMG x)
VOID IMG_num_regions_set (IMG x, UINT32 y)
IMG_REGION * IMG_regions (IMG x)
VOID IMG_regions_set (IMG x, IMG_REGION *y)
VOID IMG_is_loader_set (IMG x, BOOL y)
BOOL IMG_is_loader (IMG x)
VOID IMG_is_vdso_set (IMG x, BOOL y)
BOOL IMG_is_vdso (IMG x)
VOID IMG_loader_info_set (IMG x, VOID *y)
VOID * IMG_loader_info (IMG x)
VOID IMG_x32_shs_set (IMG x, const VOID *y)
const VOID * IMG_x32_shs (IMG x)
IMG_REGION CreateNewRegion (ADDRINT low, ADDRINT high)
LOCALINLINE VOID IMG_allocated_set (IMG x, BOOL y)
LOCALINLINE VOID IMG_app_set (IMG x, APP y)
LOCALINLINE APP IMG_app (IMG x)
VOID IMG_GarbageCollect ()
IMG IMG_Alloc ()
SEC IMG_FindSecByName (IMG img, const string &name)
SEC IMG_FindSecByNameWithType (IMG img, const string &name, SEC_TYPE type)
SYM IMG_FindRegsymByOriginalIndex (IMG img, UINT32 index)
SYM IMG_FindDynsymByOriginalIndex (IMG img, UINT32 index)
SEC IMG_FindSecByOriginalIndex (IMG img, UINT32 index)
SEC IMG_FindSecByIaddrEndInclusive (IMG img, IADDR iaddr)
SEC IMG_FindSecByIaddr (IMG img, IADDR iaddr)
SEC IMG_FindSecByOaddrEndInclusive (IMG img, OADDR oaddr)
SEC IMG_FindSecByOaddr (IMG img, OADDR oaddr)
UINT32 IMG_NumSec (IMG img)
UINT32 IMG_NumRegsym (IMG img)
SYM IMG_FindRegsymByName (IMG img, const CHAR *name)
UINT32 IMG_NumDynsym (IMG img)
LOCALFUN int cmp_secs_foffset (const void *p1, const void *p2)
VOID IMG_SortSecsByVaddr (IMG img)
VOID IMG_ComputeNewSecSizeUncooked (IMG img)
VOID IMG_InitOriginalImg (IMG img, const string &filename, const void *start, USIZE size)
VOID IMG_ComputeNewSecDataUncooked (IMG img)
string IMG_StringLong (IMG img)
VOID IMG_Check (IMG img)
VOID FreeImageLoaderInfo (VOID *arg)
VOID * CopyImageLoaderInfo (VOID *arg)
void IMG_load_offset_propagate (IMG img, void *loaderInfo)
VOID IMG_Free (IMG img)
VOID IMG_CookExecutableSections (IMG img)
VOID IMG_Append (IMG img, APP parent)
VOID IMG_Unlink (IMG img)
VOID IMG_InsertAfter (IMG img, IMG after, APP parent)
VOID IMG_InsertBefore (IMG img, IMG before, APP parent)
BOOL IMG_IsMainImage (IMG img)
BOOL IMG_IsAddressInImage (IMG img, ADDRINT addr)
ARRAYBASE InsArrayBase ("ins pool", 1024 *1024)
STRIPE< INS_STRUCT_BASE > InsStripeBase ("ins stripe base","core",&InsArrayBase)
INS INS_INVALID ()
BOOL INS_valid (INS x)
INT32 INS_no (INS x)
BOOL INS_allocated (INS x)
BOOL INS_original (INS x)
VOID INS_original_set (INS x, BOOL y)
BOOL INS_preserve (INS x)
VOID INS_preserve_set (INS x, BOOL y)
BOOL INS_unwind (INS x)
VOID INS_unwind_set (INS x, BOOL y)
BOOL INS_resolved (INS x)
VOID INS_resolved_set (INS x, BOOL y)
BOOL INS_emuft (INS x)
VOID INS_emuft_set (INS x, BOOL y)
BOOL INS_needscondcallextraregs (INS x)
VOID INS_needscondcallextraregs_set (INS x, BOOL y)
BOOL INS_needsrepextraregs (INS x)
VOID INS_needsrepextraregs_set (INS x, BOOL y)
BOOL INS_analysisarg (INS x)
VOID INS_analysisarg_set (INS x, BOOL y)
BOOL INS_interruptable (INS x)
VOID INS_interruptable_set (INS x, BOOL y)
BOOL INS_placeholder (INS x)
VOID INS_placeholder_set (INS x, BOOL y)
BOOL INS_skipValueOpt (INS x)
VOID INS_skipValueOpt_set (INS x, BOOL y)
BOOL INS_isLastInsOfAddressCalculation (INS x)
VOID INS_isLastInsOfAddressCalculation_set (INS x, BOOL y)
BOOL INS_needsSegmentTranslation (INS x)
VOID INS_needsSegmentTranslation_set (INS x, BOOL y)
BOOL INS_insertedSegmentWrite (INS x)
VOID INS_insertedSegmentWrite_set (INS x, BOOL y)
BOOL INS_isJzOverThen (INS x)
VOID INS_isJzOverThen_set (INS x, BOOL y)
VOID INS_ret_in_xymm0_set (INS x, BOOL y)
BOOL INS_ret_in_xymm0 (INS x)
VOID INS_liveness_computed_set (INS x, BOOL y)
BOOL INS_liveness_computed (INS x)
VOID INS_first_ins_of_inlined_analysis_code_set (INS x, BOOL y)
BOOL INS_first_ins_of_inlined_analysis_code (INS x)
VOID INS_is_switch_to_pin_code_marker_set (INS x, BOOL y)
BOOL INS_is_switch_to_app_code_marker (INS x)
VOID INS_is_switch_to_app_code_marker_set (INS x, BOOL y)
BOOL INS_is_call_bridge (INS x)
VOID INS_is_call_bridge_set (INS x, BOOL y)
BOOL INS_is_switch_to_pin_code_marker (INS x)
VOID INS_inlined_analysis_code_set (INS x, BOOL y)
BOOL INS_inlined_analysis_code (INS x)
VOID INS_is_target_set (INS x, BOOL y)
BOOL INS_is_target (INS x)
VOID INS_encoded_with_corresponding_app_reg_set (INS x, BOOL y)
BOOL INS_encoded_with_corresponding_app_reg (INS x)
BBL INS_bbl (INS x)
INS INS_next (INS x)
INS INS_prev (INS x)
EXT INS_ext (INS x)
string str (INS ins)
REL INS_rel (INS x)
VOID INS_rel_set (INS x, REL y)
IADDR INS_iaddr (INS x)
VOID INS_iaddr_set (INS x, IADDR y)
LOCALINLINE VOID INS_allocated_set (INS x, BOOL y)
LOCALINLINE VOID INS_bbl_set (INS x, BBL y)
LOCALINLINE VOID INS_next_set (INS x, INS y)
LOCALINLINE VOID INS_prev_set (INS x, INS y)
VOID INS_GarbageCollect ()
LOCALFUN void INS_Initialize (INS ins)
INS INS_Alloc ()
INS INS_AllocLocked ()
VOID INS_Free (INS ins)
VOID INS_FreeLocked (INS ins)
VOID INS_FreeRel (INS ins)
VOID INS_InsertBefore (INS ins, INS before, BBL parent)
VOID INS_Append (INS ins, BBL parent)
VOID INS_InsertAfter (INS ins, INS after, BBL parent)
VOID INS_Prepend (INS ins, BBL parent)
VOID INS_Unlink (INS ins)
UINT32 INS_NumAttrCrosslink (INS ins)
VOID IMG_AllocateNewSecDataExec (IMG img)
VOID INS_Copy (INS ins, INS clone)
INS INS_Clone (INS ins)
BOOL INS_MarkedForDeletion (INS ins)
VOID INS_MarkForDeletion (INS ins)
VOID INS_ExtMoveRev (INS src, INS dst, const ATTRIBUTE *attr)
VOID INS_ExtMove (INS src, INS dst, const ATTRIBUTE *attr)
STRIPE< INS_STRUCT_MAP > InsStripeMap ("ins stripe map","map",&InsArrayBase)
STRIPE< INS_STRUCT_SPARSE > InsStripeSparse ("ins stripe sparse","pincore",&InsArrayBase)
USIZE INS_pos (INS x)
VOID INS_pos_set (INS x, USIZE y)
BBL INS_bbl_target (INS x)
VOID INS_bbl_target_set (INS x, BBL y)
INT32 INS_bbl_target_weight (INS x)
VOID INS_bbl_target_weight_set (INS x, INT32 y)
INS INS_ins_target (INS x)
VOID INS_ins_target_set (INS x, INS y)
OADDR INS_GetOaddr (INS ins)
VOID IMG_ComputeNewSecSizeExecAndAddressMapping (IMG img)
VOID IMG_ComputeNewSecDataExec (IMG img)
ADDRINT SEC_ComputeOutputSizeOfExecutableSec (SEC sec, const ADDRINT secStart)
VOID INS_CheckFree ()
PINVM::PINSYNC_RWLOCK * GetINSResizeLock ()
VOID InitializeINSSupplementaryResizeLock (PINVM::ILOCK *lock)
VOID INS_CopyXlateAttributes (INS insNew, INS insOrig)
PREG MAKE_PREG (INT32 y)
REG PREG_2_REG (PREG pr)
REGVALUE MAKE_REGVALUE (ADDRINT y)
REGVALUE MAKE_PTR_REGVALUE (const VOID *y)
REGVALUE MemoryLoadRegvalue (REGVALUE address)
REGVALUE128 MemoryLoadRegvalue128 (ADDRINT address, UINT32 sizeInBytes)
REGVALUE256 MemoryLoadRegvalue256 (ADDRINT address, UINT32 sizeInBytes)
REGVALUE512 MemoryLoadRegvalue512 (ADDRINT address, UINT32 sizeInBytes)
VOID MemoryStoreRegvalue (REGVALUE address, REGVALUE value)
VOID MemoryStoreRegvalue128 (ADDRINT address, const REGVALUE128 &value, UINT32 sizeInBytes)
VOID MemoryStoreRegvalue256 (ADDRINT address, const REGVALUE256 &value, UINT32 sizeInBytes)
VOID MemoryStoreRegvalue512 (ADDRINT address, const REGVALUE512 &value, UINT32 sizeInBytes)
ARRAYBASE RelArrayBase ("rel pool", 1024 *1024)
STRIPE< REL_STRUCT_BASE > RelStripeBase ("rel stripe base","core",&RelArrayBase)
REL REL_INVALID ()
BOOL REL_valid (REL x)
BOOL REL_allocated (REL x)
REL_TYPE REL_type (REL x)
INT32 REL_no (REL x)
REL REL_target_next (REL x)
REL REL_target_prev (REL x)
CHUNK REL_target_chunk (REL x)
UINT32 REL_target_off (REL x)
INS REL_target_ins (REL x)
VAL_TYPE REL_value_type (REL x)
VAL * REL_value_val (REL x)
SEC REL_value_val_secoff_sec (REL x)
UINT32 REL_value_val_secoff_off (REL x)
SYM REL_value_val_symoff_sym (REL x)
UINT32 REL_value_val_symoff_off (REL x)
GOT REL_value_val_got (REL x)
UINT32 REL_value_val_opd (REL x)
CHUNK REL_value_val_chunk (REL x)
UINT32 REL_value_val_pltoff (REL x)
UINT64 REL_value_val_uint64 (REL x)
BBL REL_value_val_bbl (REL x)
INS REL_value_val_ins (REL x)
CHUNK REL_value_val_chunkoff_chunk (REL x)
UINT32 REL_value_val_chunkoff_off (REL x)
string str (REL rel)
VOID REL_target_ins_set (REL x, INS y)
BOOL REL_IsChunkType (REL rel)
BOOL REL_IsInsType (REL rel)
LOCALINLINE VOID REL_allocated_set (REL x, BOOL y)
LOCALINLINE VOID REL_target_next_set (REL x, REL y)
LOCALINLINE VOID REL_target_prev_set (REL x, REL y)
LOCALINLINE VOID REL_type_set (REL x, REL_TYPE y)
LOCALINLINE VOID REL_value_type_set (REL x, VAL_TYPE y)
LOCALINLINE VOID REL_target_chunk_set (REL x, CHUNK y)
LOCALINLINE VOID REL_target_off_set (REL x, UINT32 y)
const ATTRIBUTE ATTR_bbl_rel ("rel","rel","bbl_rel", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_REL, B_CROSSLINK, FALSE,"")
const ATTRIBUTE ATTR_ins_rel ("rel","rel","ins_rel", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_REL, B_CROSSLINK, FALSE,"")
const ATTRIBUTE ATTR_chunk_rel ("rel","rel","chunk_rel", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_REL, B_CROSSLINK, FALSE,"")
REL REL_Alloc ()
REL REL_First ()
REL REL_Next (REL rel)
VOID REL_Free (REL rel)
LOCALFUN VOID REL_LinkChunkoff (REL rel, CHUNK parent, UINT32 offset)
VOID REL_TargetSetAndLinkChunkoff (REL rel, REL_TYPE type, CHUNK parent, UINT32 offset)
VOID REL_UnlinkChunk (REL rel)
VOID REL_TargetSetAndLinkIns (REL rel, REL_TYPE type, INS ins)
VOID REL_UnlinkIns (REL rel)
VOID REL_ValueSetVal (REL rel, VAL_TYPE type, const VAL *val)
VOID REL_ValueSetChunk (REL rel, CHUNK chunk)
VOID REL_ValueSetChunkoff (REL rel, CHUNK chunk, USIZE off)
VOID REL_ValueSetBbl (REL rel, BBL bbl)
VOID REL_ValueSetIns (REL rel, INS ins)
VOID REL_ValueSetLdef (REL rel, LDEF ldef)
VOID REL_ValueSetGot (REL rel, GOT got)
VOID REL_ValueSetUint32 (REL rel, UINT32 v)
VOID REL_ValueSetUint64 (REL rel, UINT64 v)
VOID REL_ValueSetZero (REL rel)
VOID REL_ValueSetSymoff (REL rel, SYM sym, UINT32 off)
LOCALFUN EXT FindRelInExtChain (EXT head, const ATTRIBUTE *attr, REL rel)
VOID REL_ValueUnlink (REL rel, BOOL relax)
VOID REL_MoveoverBblValues (const BBL src, const BBL dst)
VOID REL_MoveoverInsValues (const INS src, const INS dst)
BOOL REL_ValueEqual (REL rel, REL master)
BOOL HasSpecialOffsetForGotPcAccess (RTN rtn)
VOID CHUNK_ApplyRels (CHUNK chunk)
LOCALFUN string RELTYPE_StringShort (REL_TYPE type)
string REL_StringShort (REL rel)
VOID REL_Check (REL rel)
ARRAYBASE RtnArrayBase ("rtn pool", 64 *1024)
STRIPE< RTN_STRUCT_BASE > RtnStripeBase ("rtn stripe base","core",&RtnArrayBase)
RTN RTN_INVALID ()
BOOL RTN_valid (RTN x)
INT32 RTN_no (RTN x)
BOOL RTN_allocated (RTN x)
RTN_TYPE RTN_type (RTN x)
VOID RTN_type_set (RTN x, RTN_TYPE y)
BOOL RTN_marked (RTN x)
VOID RTN_marked_set (RTN x, BOOL y)
BOOL RTN_trampoline (RTN x)
VOID RTN_trampoline_set (RTN x, BOOL y)
BOOL RTN_optimizable (RTN x)
VOID RTN_optimizable_set (RTN x, BOOL y)
BOOL RTN_inssFetched (RTN x)
VOID RTN_inssFetched_set (RTN x, BOOL y)
BOOL RTN_hasOutsideBranch (RTN x)
VOID RTN_hasOutsideBranch_set (RTN x, BOOL y)
BOOL RTN_dynamic (RTN x)
VOID RTN_dynamic_set (RTN x, BOOL y)
SEC RTN_sec (RTN x)
VOID RTN_sec_set (RTN x, SEC y)
RTN RTN_next (RTN x)
RTN RTN_prev (RTN x)
BBL RTN_bbl_head (RTN x)
VOID RTN_bbl_head_set (RTN x, BBL y)
BBL RTN_bbl_tail (RTN x)
VOID RTN_bbl_tail_set (RTN x, BBL y)
BBL RTN_bbl_ins_head_only (RTN x)
VOID RTN_bbl_ins_head_only_set (RTN x, BBL y)
const string & RTN_name (RTN x)
const string & RTN_file (RTN x)
SYM RTN_sym (RTN x)
VOID RTN_sym_set (RTN x, SYM y)
IADDR RTN_vaddr_i (RTN x)
OADDR RTN_vaddr_o (RTN x)
VOID RTN_vaddr_o_set (RTN x, OADDR y)
USIZE RTN_size (RTN x)
VOID RTN_size_set (RTN x, USIZE y)
VOID RTN_aoti_set (RTN x, BOOL y)
BOOL RTN_aoti (RTN x)
EXT RTN_ext (RTN x)
string str (RTN rtn)
string longstr (RTN rtn)
IADDR * RTN_unprobed_function (RTN x)
VOID RTN_artificial_set (RTN x, BOOL y)
BOOL RTN_artificial (RTN x)
RTN RTN_ifunc_impl (RTN x)
VOID RTN_ifunc_impl_set (RTN x, RTN impl)
RTN RTN_ifunc_resolver (RTN x)
VOID RTN_ifunc_resolver_set (RTN x, RTN resolver)
LOCALINLINE VOID RTN_allocated_set (RTN x, BOOL y)
LOCALINLINE VOID RTN_vaddr_i_set (RTN x, IADDR y)
LOCALINLINE VOID RTN_next_set (RTN x, RTN y)
LOCALINLINE VOID RTN_prev_set (RTN x, RTN y)
LOCALINLINE VOID RTN_fileptr_set (RTN x, const string *y)
LOCALINLINE VOID RTN_nameptr_set (RTN x, const string *y)
LOCALINLINE const string * RTN_nameptr (RTN x)
LOCALINLINE const string * RTN_fileptr (RTN x)
LOCALINLINE VOID RTN_sym_init (RTN x)
VOID RTN_GarbageCollect ()
LOCALCONST string StringNoname ("*noname*")
LOCALCONST string StringNofile ("*nofile*")
RTN RTN_Alloc ()
VOID RTN_Free (RTN rtn)
VOID RTN_InsertBefore (RTN rtn, RTN before, SEC parent)
VOID RTN_Append (RTN rtn, SEC parent)
VOID RTN_InsertAfter (RTN rtn, RTN after, SEC parent)
VOID RTN_Prepend (RTN rtn, SEC parent)
VOID RTN_Unlink (RTN rtn)
VOID RTN_SetVaddr (RTN rtn, IADDR iaddr)
VOID RTN_SetName (RTN rtn, const string &name)
UINT32 RTN_numIns (RTN rtn)
UINT32 RTN_ByteSize (RTN rtn)
UINT32 RTN_NumBbl (RTN rtn)
UINT32 RTN_NumAttrCrosslink (RTN rtn)
BOOL RTN_IsLeaf (RTN rtn)
BOOL RTN_ShouldNotBeChanged (RTN rtn)
VOID RTN_Check (RTN rtn)
string RTN_StringLong (RTN rtn)
string RTN_StringLongFancy (RTN rtn)
string RTN_StringLongDataFancy (RTN rtn)
VOID RTN_Unmark1Bbls (RTN rtn)
VOID RTN_Mark1Bbls (RTN rtn)
VOID RTN_MoveBbls (RTN src, RTN dst)
VOID RTN_MakeBbls (RTN rtn)
VOID RTN_UnmakeBbls (RTN rtn)
VOID RTN_RemoveAllExt (RTN rtn)
ARRAYBASE SecArrayBase ("sec pool", 1024)
STRIPE< SEC_STRUCT_BASE > SecStripeBase ("sec stripe base","core",&SecArrayBase)
SEC SEC_INVALID ()
BOOL SEC_valid (SEC x)
INT32 SEC_no (SEC x)
BOOL SEC_allocated (SEC x)
BOOL SEC_mapped (SEC x)
BOOL SEC_original (SEC x)
BOOL SEC_readonly (SEC x)
VOID SEC_readonly_set (SEC x, BOOL y)
BOOL SEC_rel_processed (SEC x)
BOOL SEC_sparse (SEC x)
VOID SEC_sparse_set (SEC x, BOOL y)
BOOL SEC_on_disk (SEC x)
VOID SEC_on_disk_set (SEC x, BOOL y)
BOOL SEC_cooked (SEC x)
VOID SEC_cooked_set (SEC x, BOOL y)
SEC_TYPE SEC_type (SEC x)
VOID SEC_type_set (SEC x, SEC_TYPE y)
SEGMENT_TYPE SEC_segment (SEC x)
VOID SEC_segment_set (SEC x, SEGMENT_TYPE y)
SEC_STATE SEC_state (SEC x)
IMG SEC_img (SEC x)
SYM SEC_regsym (SEC x)
VOID SEC_regsym_set (SEC x, SYM y)
SYM SEC_dynsym (SEC x)
VOID SEC_dynsym_set (SEC x, SYM y)
INS SEC_first_original_ins (SEC x)
VOID SEC_first_original_ins_set (SEC x, INS y)
SEC SEC_next (SEC x)
SEC SEC_prev (SEC x)
RTN SEC_rtn_head (SEC x)
VOID SEC_rtn_head_set (SEC x, RTN y)
RTN SEC_rtn_tail (SEC x)
VOID SEC_rtn_tail_set (SEC x, RTN y)
CHUNK SEC_chunk_head (SEC x)
VOID SEC_chunk_head_set (SEC x, CHUNK y)
CHUNK SEC_chunk_tail (SEC x)
VOID SEC_chunk_tail_set (SEC x, CHUNK y)
const string & SEC_name (SEC x)
const CHAR * SEC_seg_name (SEC x)
VOID SEC_seg_name_set (SEC x, CHAR *y)
UINT32 SEC_alignment (SEC x)
VOID SEC_alignment_set (SEC x, UINT32 y)
const VOID * SEC_data_i (SEC x)
VOID SEC_data_i_set (SEC x, const VOID *y)
VOID * SEC_data_o (SEC x)
USIZE SEC_foffset_i (SEC x)
USIZE SEC_foffset_o (SEC x)
USIZE SEC_size_o (SEC x)
USIZE SEC_size_i (SEC x)
const VOID * SEC_sectheader_i (SEC x)
VOID SEC_sectheader_i_set (SEC x, const VOID *y)
VOID * SEC_sectheader_o (SEC x)
IADDR SEC_vaddr_i (SEC x)
OADDR SEC_vaddr_o (SEC x)
SEC SEC_sec_dynrel (SEC x)
SEC SEC_sec_regrel (SEC x)
UINT32 SEC_index_i (SEC x)
VOID SEC_name_set (SEC x, const string *y)
string str (SEC sec)
string longstr (SEC sec)
VOID SEC_vaddr_o_set (SEC x, OADDR y)
LOCALINLINE VOID SEC_allocated_set (SEC x, BOOL y)
LOCALINLINE VOID SEC_mapped_set (SEC x, BOOL y)
LOCALINLINE VOID SEC_original_set (SEC x, BOOL y)
LOCALINLINE VOID SEC_size_i_set (SEC x, UINT32 y)
LOCALINLINE VOID SEC_index_i_set (SEC x, UINT32 y)
LOCALINLINE VOID SEC_next_set (SEC x, SEC y)
LOCALINLINE VOID SEC_prev_set (SEC x, SEC y)
LOCALINLINE VOID SEC_size_o_set (SEC x, USIZE y)
LOCALINLINE VOID SEC_data_o_set (SEC x, VOID *y)
LOCALINLINE VOID SEC_state_set (SEC x, SEC_STATE y)
LOCALINLINE VOID SEC_img_set (SEC x, IMG y)
LOCALINLINE VOID SEC_foffset_i_set (SEC x, USIZE y)
LOCALINLINE VOID SEC_foffset_o_set (SEC x, USIZE y)
LOCALINLINE VOID SEC_vaddr_i_set (SEC x, IADDR y)
VOID SEC_GarbageCollect ()
SEC SEC_Alloc ()
VOID SEC_Free (SEC sec)
VOID SEC_InsertBefore (SEC sec, SEC before, IMG parent)
VOID SEC_Append (SEC sec, IMG parent)
VOID SEC_InsertAfter (SEC sec, SEC after, IMG parent)
VOID SEC_Prepend (SEC sec, IMG parent)
VOID SEC_Unlink (SEC sec)
VOID SEC_InitOriginalSec (SEC sec, const string &name, UINT32 index, IADDR iaddr, USIZE offset, USIZE size, const VOID *data, UINT32 alignment, BOOL mapped, BOOL on_disk, const VOID *sectheader)
VOID SEC_InitDynamicCodeSection (SEC newSec, IADDR iaddr, USIZE size)
RTN SEC_FindRtnByName (SEC sec, const string &name)
RTN SEC_FindRtnByIaddr (SEC sec, IADDR iaddr)
CHUNK SEC_FindChunkByIaddr (SEC sec, IADDR iaddr)
BOOL SEC_ContainsIaddr (SEC sec, IADDR iaddr)
BOOL SEC_ContainsIaddrEndInclusive (SEC sec, IADDR iaddr)
BOOL SEC_ContainsOaddr (SEC sec, OADDR oaddr)
BOOL SEC_ContainsOaddrEndInclusive (SEC sec, OADDR oaddr)
LOCALFUN SEC_STATE FindNextState (SEC_STATE state, const SEC_STATE *list)
VOID SEC_StateSet (SEC sec, SEC_STATE state)
UINT64 SEC_GetUnalignedIDataByOffsetUINT64 (SEC sec, USIZE offset)
UINT64 SEC_GetIDataByOffsetUINT64 (SEC sec, UINT64 offset)
UINT64 SEC_GetIDataUINT64 (SEC sec, IADDR iaddr)
INT32 SEC_GetUnalignedIDataByOffsetINT32 (SEC sec, UINT64 offset)
INT32 SEC_GetIDataByOffsetUINT32 (SEC sec, UINT64 offset)
INT32 SEC_GetIDataINT32 (SEC sec, IADDR iaddr)
UINT32 SEC_NumRtn (SEC sec)
string SEC_String (SEC_TYPE type)
string SEC_String (SEC_STATE state)
string SEGMENT_StringShort (SEGMENT_TYPE segment)
string SEC_StringLong (SEC sec)
string SEC_StringLongWithChunks (SEC sec)
string SEC_StringDataDumpI (SEC sec, UINT32 width)
VOID SEC_SetNewSize (SEC sec, USIZE size)
VOID SEC_SetNewAddressAndOffset (SEC sec, OADDR oaddr, USIZE offset)
VOID SEC_IncNewSize (SEC sec, USIZE size)
VOID SEC_SetNewData (SEC sec, VOID *data)
VOID SEC_SetDataCopy (SEC sec)
VOID SEC_Check (SEC sec)
LOCALVAR KNOB< UINT32 > KnobMaxIns (KNOB_MODE_WRITEONCE,"supported:debug","max_ins","16384","Maximum number of INS allowed")
LOCALVAR KNOB< UINT32 > KnobMaxRtn (KNOB_MODE_WRITEONCE,"supported:debug","max_rtn","16384","Maximum number of RTN allowed")
LOCALVAR KNOB< UINT32 > KnobMaxSym (KNOB_MODE_WRITEONCE,"supported:debug","max_sym","16384","Maximum number of SYM allowed")
LOCALVAR KNOB< UINT32 > KnobMaxSec (KNOB_MODE_WRITEONCE,"supported:debug","max_sec","16384","Maximum number of SEC allowed")
LOCALVAR KNOB< BOOL > KnobRecycle (KNOB_MODE_WRITEONCE,"supported:debug","recycle","1","Reuse freed stripe elements")
LOCALVAR KNOB< BOOL > KnobRecycleRtn (KNOB_MODE_WRITEONCE,"supported:debug","recycle_rtn","1","Reuse freed rtn")
VOID InitializeStripes ()
ARRAYBASE SymArrayBase ("sym pool", 128 *1024)
STRIPE< SYM_STRUCT_BASE > SymStripeBase ("sym stripe base","core",&SymArrayBase)
SYM SYM_INVALID ()
BOOL SYM_valid (SYM x)
INT32 SYM_no (SYM x)
BOOL SYM_allocated (SYM x)
BOOL SYM_original (SYM x)
BOOL SYM_global (SYM x)
BOOL SYM_dynamic (SYM x)
SYM_IFUNC_TYPE SYM_ifunc_type (SYM x)
VAL_TYPE SYM_type (SYM x)
BOOL SYM_ifunc_resolver (SYM x)
BOOL SYM_ifunc_impl (SYM x)
BOOL SYM_is_generated_by_pin (SYM x)
SYM_STATE SYM_state (SYM x)
IMG SYM_img (SYM x)
SYM SYM_next (SYM x)
SYM SYM_prev (SYM x)
const string & SYM_name (SYM x)
UINT32 SYM_index_i (SYM x)
VOID SYM_index_i_set (SYM x, UINT32 y)
UINT32 SYM_string_offset (SYM x)
IADDR SYM_vaddr_i (SYM x)
UINT32 SYM_size_i (SYM x)
const VOID * SYM_symbheader_i (SYM x)
VAL * SYM_val (SYM x)
IADDR SYM_val_iaddr (SYM x)
BBL SYM_val_bbl (SYM x)
RTN SYM_val_rtn (SYM x)
SEC SYM_val_sec (SYM x)
LDEF SYM_val_ldef (SYM x)
CHUNK SYM_val_chunkoff_chunk (SYM x)
UINT32 SYM_val_chunkoff_off (SYM x)
VOID SYM_val_iaddr_set (SYM x, IADDR y)
VOID SYM_val_bbl_set (SYM x, BBL y)
VOID SYM_val_rtn_set (SYM x, RTN y)
VOID SYM_val_sec_set (SYM x, SEC y)
VOID SYM_val_ldef_set (SYM x, LDEF y)
VOID SYM_val_chunkoff_chunk_set (SYM x, CHUNK y)
VOID SYM_val_chunkoff_off_set (SYM x, UINT32 y)
string str (SYM sym)
string longstr (SYM sym)
VOID SYM_ifunc_type_set (SYM x, SYM_IFUNC_TYPE y)
SYM SYM_contained_symbols (SYM x)
LOCALINLINE VOID SYM_symbheader_i_set (SYM x, const VOID *y)
LOCALINLINE VOID SYM_nameptr_set (SYM x, const string *y)
LOCALINLINE const string * SYM_nameptr (SYM x)
LOCALINLINE VOID SYM_dynamic_set (SYM x, BOOL y)
LOCALINLINE VOID SYM_global_set (SYM x, BOOL y)
LOCALINLINE VOID SYM_allocated_set (SYM x, BOOL y)
LOCALINLINE VOID SYM_original_set (SYM x, BOOL y)
LOCALINLINE VOID SYM_img_set (SYM x, IMG y)
LOCALINLINE VOID SYM_next_set (SYM x, SYM y)
LOCALINLINE VOID SYM_prev_set (SYM x, SYM y)
LOCALINLINE VOID SYM_type_set (SYM x, VAL_TYPE y)
LOCALINLINE VOID SYM_vaddr_i_set (SYM x, IADDR y)
LOCALINLINE VOID SYM_size_i_set (SYM x, UINT32 y)
LOCALINLINE VOID SYM_state_set (SYM x, SYM_STATE y)
LOCALINLINE VOID SYM_string_offset_set (SYM x, UINT32 y)
LOCALINLINE VOID SYM_contained_symbols_set (SYM x, SYM y)
const ATTRIBUTE ATTR_bbl_regsym ("reg","sym","bbl_regsym", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_SYM, B_CROSSLINK, FALSE,"")
const ATTRIBUTE ATTR_bbl_dynsym ("dyn","sym","bbl_dynsym", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_SYM, B_CROSSLINK, FALSE,"")
const ATTRIBUTE ATTR_chunk_regsym ("reg","sym","chunk_regsym", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_SYM, B_CROSSLINK, FALSE,"")
const ATTRIBUTE ATTR_chunk_dynsym ("dyn","sym","chunk_dynsym", EXT_ATTR_MODE_MULTIPLE, VAL_TYPE_SYM, B_CROSSLINK, FALSE,"")
VOID SYM_GarbageCollect ()
VOID SYM_SetSize (SYM sym, UINT32 size)
SYM SYM_Alloc ()
VOID SYM_Free (SYM sym)
VOID REGSYM_InsertBefore (SYM sym, SYM before, IMG parent)
VOID REGSYM_Append (SYM sym, IMG parent)
VOID REGSYM_InsertAfter (SYM sym, SYM after, IMG parent)
VOID REGSYM_Prepend (SYM sym, IMG parent)
VOID DYNSYM_InsertBefore (SYM sym, SYM before, IMG parent)
VOID DYNSYM_Append (SYM sym, IMG parent)
VOID DYNSYM_InsertAfter (SYM sym, SYM after, IMG parent)
VOID DYNSYM_Prepend (SYM sym, IMG parent)
VOID DYNSYM_Unlink (SYM sym)
VOID REGSYM_Unlink (SYM sym)
VOID SYM_Init (SYM sym, VAL_TYPE type, BOOL dynamic, SYM_IFUNC_TYPE ifunc_type, const string &name, UINT32 index, IADDR iaddr, UINT32 isize, const VOID *symbheader, BOOL global, BOOL original, UINT32 string_offset)
LOCALFUN SYM_STATE FindNextState (SYM_STATE state, const SYM_STATE *list)
VOID SYM_StateSet (SYM sym, SYM_STATE state)
VOID SYM_ValueSetAndLinkSec (SYM sym, SEC sec)
VOID SYM_ValueSetLdef (SYM sym, LDEF ldef)
VOID SYM_ValueSetAndLinkBbl (SYM sym, BBL bbl)
VOID SYM_ValueSetIaddr (SYM sym, IADDR x)
VOID SYM_ValueSetAndLinkChunkoff (SYM sym, CHUNK chunk, UINT32 offset)
VOID BBL_RemoveRegsyms (BBL bbl)
VOID CHUNK_RemoveRegsyms (CHUNK chunk)
LOCALFUN VOID SYM_LinkWithTarget (SYM sym, IMG img)
VOID IMG_LinkRegsymWithTarget (IMG img)
SYM IMG_AllocAndAppendNewUndefDynsym (IMG img, const string &name)
SYM IMG_AllocAndAppendNewBblDynsym (IMG img, const string &name, BBL bbl)
SYM IMG_AllocAndAppendNewRtnRegsym (IMG img, const string &name, BBL bbl)
SYM IMG_AllocAndAppendNewChunkDynsym (IMG img, const string &name, CHUNK chunk, UINT32 chunk_offset)
SYM IMG_AllocAndAppendNewChunkRegsym (IMG img, const string &name, CHUNK chunk, UINT32 chunk_offset)
VOID IMG_LinkDynsymWithTarget (IMG img)
string SYM_StringShort (SYM sym)
string IMG_PrintRegSyms (IMG img)
VOID SYM_Check (SYM sym)
VOID SYM_AddContainedSymbol (SYM sym, SYM contained_sym)
SACT VAL_sact (VAL_TYPE t, const VAL *val)
RTN VAL_rtn (VAL_TYPE t, const VAL *val)
BBL VAL_bbl (VAL_TYPE t, const VAL *val)
EDG VAL_edg (VAL_TYPE t, const VAL *val)
INS VAL_ins (VAL_TYPE t, const VAL *val)
SEC VAL_sec (VAL_TYPE t, const VAL *val)
LDEF VAL_ldef (VAL_TYPE t, const VAL *val)
CHUNK VAL_chunk (VAL_TYPE t, const VAL *val)
SYM VAL_sym (VAL_TYPE t, const VAL *val)
GOT VAL_got (VAL_TYPE t, const VAL *val)
IADDR VAL_iaddr (VAL_TYPE t, const VAL *val)
SYM VAL_symoff_sym (VAL_TYPE t, const VAL *val)
UINT32 VAL_symoff_off (VAL_TYPE t, const VAL *val)
SEC VAL_secoff_sec (VAL_TYPE t, const VAL *val)
UINT32 VAL_secoff_off (VAL_TYPE t, const VAL *val)
CHUNK VAL_chunkoff_chunk (VAL_TYPE t, const VAL *val)
UINT32 VAL_chunkoff_off (VAL_TYPE t, const VAL *val)
UINT32 VAL_opd (VAL_TYPE t, const VAL *val)
UINT32 VAL_pltoff (VAL_TYPE t, const VAL *val)
UINT64 VAL_uint64 (VAL_TYPE t, const VAL *val)
UINT32 VAL_uint32 (VAL_TYPE t, const VAL *val)
UINT32 VAL_two_int_i1 (VAL_TYPE t, const VAL *val)
UINT32 VAL_two_int_i2 (VAL_TYPE t, const VAL *val)
REG VAL_regallochint_vreg (VAL_TYPE t, const VAL *val)
REG VAL_regallochint_preg (VAL_TYPE t, const VAL *val)
REGALLOC_HINT_TYPE VAL_regallochint_hint (VAL_TYPE t, const VAL *val)
VOID VAL_sact_set (VAL_TYPE t, VAL *val, SACT act)
VOID VAL_rtn_set (VAL_TYPE t, VAL *val, RTN y)
VOID VAL_bbl_set (VAL_TYPE t, VAL *val, BBL y)
VOID VAL_edg_set (VAL_TYPE t, VAL *val, EDG y)
VOID VAL_ins_set (VAL_TYPE t, VAL *val, INS y)
VOID VAL_sec_set (VAL_TYPE t, VAL *val, SEC y)
VOID VAL_sym_set (VAL_TYPE t, VAL *val, SYM y)
VOID VAL_ldef_set (VAL_TYPE t, VAL *val, LDEF y)
VOID VAL_chunk_set (VAL_TYPE t, VAL *val, CHUNK y)
VOID VAL_iaddr_set (VAL_TYPE t, VAL *val, IADDR y)
VOID VAL_secoff_sec_set (VAL_TYPE t, VAL *val, SEC y)
VOID VAL_secoff_off_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_symoff_sym_set (VAL_TYPE t, VAL *val, SYM y)
VOID VAL_symoff_off_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_chunkoff_chunk_set (VAL_TYPE t, VAL *val, CHUNK y)
VOID VAL_chunkoff_off_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_opd_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_pltoff_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_got_set (VAL_TYPE t, VAL *val, GOT y)
VOID VAL_uint64_set (VAL_TYPE t, VAL *val, UINT64 y)
VOID VAL_uint32_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_two_int_i1_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_two_int_i2_set (VAL_TYPE t, VAL *val, UINT32 y)
VOID VAL_regallochint_vreg_set (VAL_TYPE t, VAL *val, REG y)
VOID VAL_regallochint_preg_set (VAL_TYPE t, VAL *val, REG y)
VOID VAL_regallochint_hint_set (VAL_TYPE t, VAL *val, REGALLOC_HINT_TYPE y)
string VAL_StringShort (VAL_TYPE type, const VAL *val, BOOL tiny)
OADDR VAL_Oaddr (VAL_TYPE type, const VAL *val, IMG img)
BOOL VAL_Equal (VAL_TYPE t1, const VAL *v1, VAL_TYPE t2, const VAL *v2)
VOID AddBranchEdgeToBbl (BBL bbl, BBL target_bbl, INS branch, EDG_TYPE type)
VOID AddFallthruEdgeToBbl (BBL bbl, BBL target_bbl, EDG_TYPE type)
VOID BBL_TypifyAndCreateEdgsFromBblToBbl (BBL src_bbl, BBL dst_bbl)
LOCALFUN VOID AddBranchEdge (SEC sec, BBL bbl, INS branch, EDG_TYPE type)
LOCALFUN VOID AddIndirectBranchEdge (SEC sec, BBL bbl, INS branch, EDG_TYPE type)
LOCALFUN VOID AddFallthruEdge (BBL bbl, EDG_TYPE type)
VOID BBL_TypifyAndCreateEdgs (SEC sec, BBL bbl)
VOID IMG_RetypifyBbls (IMG img)
VOID IMG_ChunkifySecs (IMG img)
string FLAGS_StringShort (const FLAGS x)
FLAGS FLAGS_Or (const FLAGS x, const FLAGS y)
FLAGS FLAGS_Subtract (const FLAGS x, const FLAGS y)
FLAGS FLAGS_And (const FLAGS x, const FLAGS y)
BOOL FLAGS_IsSubset (const FLAGS subset, const FLAGS superset)
KNOB< BOOL > KnobRegUseSahf (KNOB_MODE_WRITEONCE,"supported:regalloc","use_sahf","1","use sahf lahf to save restore eflags")
KNOB< BOOL > KnobRegFlagsSplit (KNOB_MODE_WRITEONCE,"supported:regalloc","flags_split","1","split eflags representation")
BOOL UseSahfLahfSequence ()
BOOL DoFlagsSplit ()
KNOB< BOOL > KnobVirtualSegments (KNOB_MODE_OVERWRITE,"supported:region","virtual_segments", KNOB_ONLY_ON_UNIX,"Virtual access to segment registers\n")
KNOB< BOOL > KnobSegmentEffectiveAddresses (KNOB_MODE_WRITEONCE,"supported:region","segment_ea","1","Computation of effective addresses with seg override\n")
UINT INS_ImmediateWidthBytes (INS ins)
BOOL REG_IsRewrittenSegmentReg (REG reg)
REG INS_IsSimpleRegIndirectWrite (INS ins)
LOCALINLINE xed_iclass_enum_t INS_Iclass (const INS ins)
LOCALINLINE BOOL INS_IclassTest (const INS ins, xed_iclass_enum_t iclass)
LOCALINLINE BOOL INS_IclassTest (const INS ins, xed_iclass_enum_t iclass1, xed_iclass_enum_t iclass2)
LOCALINLINE BOOL INS_CategoryTest (const INS ins, xed_category_enum_t category)
LOCALINLINE BOOL INS_CategoryTest (const INS ins, xed_category_enum_t category1, xed_category_enum_t category2)
INT32 INS_Category (const INS ins)
INT32 INS_Extension (const INS ins)
REG INS_IsSimpleRegIndirectRead (INS ins)
BOOL INS_HasImplicitFullMask (INS ins)
UINT32 INS_EffectiveAddressWidth (INS ins)
USIZE INS_MemoryOperandSize (INS ins, UINT32 memoryOp)
USIZE INS_MemoryWriteSize (INS ins)
USIZE INS_MemoryReadSize (INS ins)
PREDICATE INS_GetPredicate (INS ins)
BOOL INS_IsMemoryRead (INS ins)
BOOL INS_IsMemoryWrite (INS ins)
BOOL INS_HasMemoryRead2 (INS ins)
BOOL INS_HasFallThrough (INS ins)
BOOL INS_IsSysenter (INS ins)
BOOL INS_IsXbegin (INS ins)
BOOL INS_IsXend (INS ins)
BOOL INS_IsLea (INS ins)
BOOL INS_IsNop (INS ins)
string OPCODE_StringShort (UINT32 opcode)
string INS_Mnemonic (INS ins)
BOOL INS_IsBblTerminator (INS ins)
BOOL INS_IsBranch (INS ins)
BOOL INS_IsDirectBranch (INS ins)
BOOL INS_IsDirectCall (INS ins)
BOOL INS_IsDirectBranchOrCall (INS ins)
BOOL INS_IsHalt (INS ins)
BOOL INS_IsBranchOrCall (INS ins)
BOOL INS_Stutters (INS ins)
BOOL INS_IsPcMaterialization (INS ins)
BOOL INS_IsCall (INS ins)
BOOL INS_IsFarCall (INS ins)
BOOL INS_IsFarJump (INS ins)
BOOL INS_IsDirectFarJump (INS ins)
BOOL INS_IsXsaveFamily (INS ins)
BOOL INS_IsAvx (INS ins)
BOOL INS_IsAvxOrXSave (INS ins)
BOOL INS_IsVgather (INS ins)
BOOL INS_IsVscatter (INS ins)
BOOL INS_HasMemoryVector (INS ins)
BOOL INS_IsSse (INS ins)
BOOL INS_IsMmx (INS ins)
VOID INS_GetFarPointer (INS ins, UINT16 &segment_selector, UINT32 &displacement)
BOOL INS_IsProcedureCall (INS ins)
BOOL XED_INS_IsMultimedia (INS ins)
BOOL INS_IsFloat (INS ins)
BOOL INS_IsFxsave (INS ins)
BOOL INS_IsFxrestore (INS ins)
BOOL INS_IsXsave (INS ins)
BOOL INS_IsXsavec (INS ins)
BOOL INS_IsXsaveopt (INS ins)
BOOL INS_IsXrestore (INS ins)
BOOL INS_IsCmov (INS ins)
BOOL INS_IsSetCC (INS ins)
BOOL INS_IsFCmov (INS ins)
BOOL INS_IsBitTest (INS ins)
BOOL INS_IsEnter (INS ins)
BOOL INS_IsCmps (INS ins)
BOOL INS_IsScas (INS ins)
BOOL INS_IsJZ (INS ins)
BOOL INS_IsJNZ (INS ins)
BOOL INS_IsJCXZ (INS ins)
BOOL INS_IsLoopType (const INS ins)
BOOL INS_IsLoop (INS ins)
BOOL INS_IsLoope (INS ins)
BOOL INS_IsLoopne (INS ins)
BOOL INS_IsLeave (INS ins)
BOOL INS_IsBsr (INS ins)
BOOL INS_IsUJmp (INS ins)
BOOL INS_IsCJmp (INS ins)
BOOL INS_IsInterrupt (INS ins)
BOOL INS_IsCondWrite (INS ins)
BOOL INS_IsRet (INS ins)
BOOL INS_IsSysret (INS ins)
BOOL INS_IsFarRet (INS ins)
BOOL INS_IsPrefetch (INS ins)
BOOL INS_IsShift (INS ins)
BOOL INS_IsStringOp (INS ins)
BOOL INS_IsIOStringOp (INS ins)
BOOL INS_IsPush (const INS ins)
BOOL INS_IsPop (const INS ins)
BOOL INS_IsPopF (const INS ins)
BOOL INS_IsPopFD (const INS ins)
BOOL INS_IsPopFQ (const INS ins)
BOOL INS_IsAnyPopF (const INS ins)
BOOL INS_IsInc (const INS ins)
BOOL INS_IsDec (const INS ins)
BOOL INS_IsAdd (const INS ins)
BOOL INS_IsSub (const INS ins)
BOOL INS_IsMov (const INS ins)
BOOL INS_IsMovFullRegRegSame (const INS ins)
BOOL INS_IsMovImmToReg (const INS ins, ADDRINT &imm, REG &reg)
BOOL INS_IsMMXorXMM (const INS ins)
BOOL INS_IsAtomicUpdate (const INS ins)
BOOL INS_IsRDTSC (const INS ins)
BOOL INS_IsMaskMov (const INS ins)
REG INS_CountRegister (INS ins)
REG INS_RepCountRegister (INS ins)
FLAGS INS_PhyFlagsMustWritten (const INS ins)
FLAGS INS_PhyFlagsMayWritten (const INS ins)
FLAGS INS_PhyFlagsRead (const INS ins)
BOOL INS_IsIpRelAddr (INS ins)
BOOL INS_IsXlat (INS ins)
BOOL INS_IsCpuid (INS ins)
BOOL INS_IsIndirectBranchOrCall (INS ins)
BOOL INS_CallOrBranchIsRegisterIndirect (INS ins)
BOOL INS_HasFixed8BitBranchDisplacement (INS ins)
REG INS_SegmentRegPrefix (INS ins)
BOOL INS_HasMemoryDisplacement (INS ins)
ADDRDELTA INS_GetMemoryDisplacement (INS ins)
BOOL INS_IsPushAll32 (INS ins)
BOOL INS_IsPushAll16 (INS ins)
BOOL INS_IsPopAll32 (INS ins)
BOOL INS_IsPopAll16 (INS ins)
UINT32 INS_BranchDisplacementWidthBytes (INS ins)
ADDRINT INS_MemoryDisplacementWidthBytes (INS ins)
UINT32 INS_BranchDisplacementWidthBits (INS ins)
LOCALFUN REG INS_GetRoleReg (INS ins, xed_operand_enum_t role)
REG INS_GetIndexReg (INS ins)
REG INS_GetBaseReg (INS ins)
BOOL INS_RegIsBaseReg (INS ins, int readRegNum)
REG INS_GetBaseRegOne (INS ins)
BOOL INS_MemopDisplacementOnly (INS ins)
VOID INS_DisableSegmentPrefix (INS ins)
PIN_DEPRECATED_API BOOL INS_IsRewritableMemOpBaseLimited (INS ins, MEMORY_TYPE mtype, REG &base)
PIN_DEPRECATED_API BOOL INS_IsRewritableMemOpBase (INS ins, MEMORY_TYPE mtype, REG &base)
PIN_DEPRECATED_API BOOL INS_IsDynamicRewritableMemOpBase (INS ins, MEMORY_TYPE mtype, REG &reg)
VOID XED_RAWINS_ReplaceReg (const INS ins, const REG oldreg, const REG newreg)
VOID XED_RAWINS_ReplacePinRegsByAppRegs (const INS ins, const UINT32 num_pinregs, REG *pin_regs, REG *app_regs)
VOID INS_scan_for_memop_info (INS ins, REG &base0, REG &index, ADDRINT &offset, ADDRINT &scale, REG &base1, REG &seg0, REG &seg1)
INS INS_ConvertLoadToMoveHack (INS jmp)
VOID INS_ConvertCallToBranch (INS ins)
VOID INS_ConvertToIndirectJumpHack (INS ins)
VOID INS_MakeAbsolute32Address (INS ins, IADDR target)
VOID INS_SetIndexRegister (INS ins, REG newIndex)
VOID INS_SetRegisterOperand (INS ins, UINT32 operand, REG newReg)
VOID INS_SetMemoryDisplacement (INS ins, ADDRDELTA disp, UINT length_bytes)
VOID INS_SetBranchDisplacement (INS ins, ADDRDELTA disp, UINT length_bytes)
LOCALFUN UINT FieldWidthToSize (const unsigned int width)
VOID INS_SetImmediate (INS ins, ADDRINT imm)
VOID INS_RemoveRep (INS ins)
LOCALFUN INS_XED_STRUCT_DECODE * INS_get_arch (INS x)
VOID INS_CopyArchFields (INS ins, INS clone)
BOOL INS_EqualArchFields (INS ins1, INS ins2)
ADDRINT INS_GetImmediate (INS ins)
ADDRINT INS_IsSignedImmediate (INS ins)
ADDRDELTA INS_GetSignedImmediate (INS ins)
ADDRINT INS_GetSecondImmediate (INS ins)
ADDRDELTA INS_GetBranchDisplacement (INS ins)
BOOL INS_HasImmediateOperand (INS ins)
BOOL INS_HasImplicitMemoryReference (INS ins)
BOOL INS_HasExplicitMemoryReference (INS ins)
BOOL INS_HasImplicitStackReference (INS ins)
UINT32 INS_GetScale (INS ins)
BOOL INS_ReadsAllMMRegisters (INS ins)
BOOL INS_WritesAllMMRegisters (INS ins)
BOOL INS_ReadsAllMmxRegisterss (INS ins)
BOOL INS_WritesAllMmxRegisters (INS ins)
BOOL INS_MayWriteAllMMRegisters (INS ins)
BOOL INS_AccessesManyFPRegisters (INS ins)
BOOL INS_IsFpop (INS ins)
LOCALVAR KNOB_COMMENT KnobDisassemblyFamily (knobfamily,"IA-32 architecture and Intel(R) 64 architecture disassembly format")
LOCALVAR KNOB< BOOL > KnobXedDisassembly (KNOB_MODE_WRITEONCE, knobfamily,"xedprint","0","Disassemble using Intel(R) X86 Encoder Decoder format")
LOCALVAR KNOB< BOOL > KnobATTDisassembly (KNOB_MODE_WRITEONCE, knobfamily,"attprint","0","Disassemble using ATT format")
LOCALVAR KNOB< BOOL > KnobIntelDisassembly (KNOB_MODE_WRITEONCE, knobfamily,"intelprint","0","Disassemble using Intel format (default)")
LOCALFUN VOID INS_SetSyntaxFromKnobs ()
VOID PIN_SetSyntaxIntel ()
VOID PIN_SetSyntaxATT ()
VOID PIN_SetSyntaxXED ()
string INS_PrintString (INS ins, ADDRINT addr)
VOID INS_RegRSet (INS x, UINT32 k, REG r)
VOID INS_RegWSet (INS x, UINT32 k, REG r)
REG INS_RegR (INS x, UINT32 k)
REG INS_RegW (INS x, UINT32 k)
REG INS_GetFirstAluSourceReg (INS ins)
BOOL INS_CallOrBranchIsMemoryIndirect (INS ins)
BOOL INS_IsExplicitReadOnly (const INS ins, const UINT32 pos)
BOOL INS_IsExplicit (const INS ins, const UINT32 pos)
BOOL INS_IsImplicitRead (const INS ins, const UINT32 pos)
BOOL INS_IsImplicitWrite (const INS ins, const UINT32 pos)
REG INS_CallOrBranchGetIndirectRegister (INS ins)
BOOL INS_HasRepEqual (INS ins)
OPCODE INS_Opcode (INS ins)
string CATEGORY_StringShort (UINT32 num)
string EXTENSION_StringShort (UINT32 num)
VOID INS_ZeroExtend (BBL bbl, REG src, REG dst)
VOID INS_SignExtend (BBL bbl, REG src, REG dst)
BOOL INS_SegPrefixIsMemoryRead (INS ins)
BOOL INS_SegPrefixIsMemoryWrite (INS ins)
BOOL INS_AddressSizePrefix (INS ins)
BOOL INS_BranchNotTakenPrefix (INS ins)
BOOL INS_BranchTakenPrefix (INS ins)
BOOL INS_LockPrefix (INS ins)
BOOL INS_OperandSizePrefix (INS ins)
BOOL INS_RepPrefix (INS ins)
BOOL INS_RepnePrefix (INS ins)
BOOL INS_SegmentPrefix (INS ins)
BOOL INS_HasSegmentRegPrefix (INS ins)
BOOL INS_IsXchg (INS ins)
BOOL INS_IsStringop (INS ins)
BOOL INS_IsIRet (INS ins)
LOCALTYPE BOOL operator< (const ENCODING_ADDRESS_RANGE_KEY &left, const ENCODING_ADDRESS_RANGE_KEY &right)
LOCALVAR MESSAGE_TYPE MessageTypeLogEncoding ("log_encoding","", false, false, false, true, LOGTYPE_LOGFILE,"pin log: encodings")
VOID ThreadAwareMemcpy (VOID *dst, const VOID *src, USIZE size)
USIZE ThreadAwareInsEncoder (INS ins, ADDRINT address)
LOCALFUN BOOL BranchDisplacementFits (INS ins, INT64 delta)
LOCALFUN char NibbleToAsciHex (UINT8 i)
LOCALFUN void PrintHexLine (char *buf, const UINT8 *array, const int length)
LOCALFUN string Disassemble (ADDRINT start, ADDRINT stop)
BBL SimulateRetPush (INS call)
USIZE INS_MaxProbeSize (BOOL requestRipAndAddrProbe)
BBL SimulateRetPopToMem (INS ret, ADDRINT offset)
USIZE INS_EncodeAtAddr (INS ins, ADDRINT address)
VOID INS_InitBranch (INS ins, BBL target)
UINT32 INS_MaxNumRRegs (INS x)
UINT32 INS_MaxNumWRegs (INS x)
BOOL INS_RegRContain (const INS ins, const REG reg)
BOOL INS_RegWContain (const INS ins, const REG reg)
BOOL INS_FullRegRContain (const INS ins, const REG reg)
BOOL INS_FullRegWContain (const INS ins, const REG reg)
BOOL BBL_TypeIsSane (BBL bbl)
VOID SetDecoderExceptionInfo (EXCEPTION_INFO *pExceptInfo, EXCEPTION_CODE exceptCode, ADDRINT addr, size_t size)
INSDECODE INS_DecodeIns (INS ins, const VOID **address, UINT32 size, EXCEPTION_CODE *excCode)
BOOL INS_InitOriginalIns (INS ins, const VOID **address, UINT32 maxSize, EXCEPTION_INFO *pExceptInfo=0)
template<typename FETCHER_>
GLOBALTEMPLATEFUN BOOL INS_Fetch (INS ins, const VOID **address, const FETCHER_ &insBytesFetcher, UINT32 maxSize, EXCEPTION_INFO *pExceptInfo=0)
int INS_MaxDecodedBytes ()
UINT64 INS_Id (INS ins)
BOOL INS_ValidateEncoding (const INS ins)
IADDR INS_CallRetIaddr (INS ins)
VOID INS_Check (INS ins)
VOID BBL_Check (BBL bbl)
LOCALFUN VOID OverwriteDisplacement (INS ins, INT64 value, UINT32 valueLen)
LOCALFUN VOID ApplyPcRelRelocation (INS ins, REL rel, IMG img)
LOCALFUN VOID ApplyImmRelocation (INS ins, REL rel, IMG img)
LOCALFUN VOID ApplyRelocation (INS ins, IMG img)
VOID SEC_ComputeNewSecDataExec (SEC sec, VOID *data)
string SEC_StringDis (SEC sec)
BOOL INS_Equal (INS ins, INS ins2)
USIZE INS_SizeOfDirectJmp ()
USIZE INS_SizeOfIpRelativeMemJmp ()
USIZE INS_InitDirectJmp (INS ins, ADDRINT brAddr, ADDRINT tgtAddr)
BOOL INS_IsMTSafeToPatch (ADDRINT addr, USIZE size)
ADDRINT INS_GetMTSafePatchLocation (ADDRINT addr, USIZE size)
LOCALFUN BOOL INS_MTSafeOverwrite (INS ins, ADDRINT addr, USIZE size)
LOCALFUN BOOL INS_MTSafeOverwriteDisplacement (INS ins, ADDRINT addr, USIZE size, UINT curDisplacementBytes, UINT newDisplacementBytes, ADDRDELTA displacement)
LOCALVAR STAT_UINT64 PinPatchedInssStat ("pin","insts","fetched_for_patch","")
BOOL INS_MTSafePatchBranch (OADDR brAddr, OADDR tgtAddr)
LOCALVAR STAT_UINT64 PinOverwriteWithJmpInssStat ("pin","insts","fetched_for_jmp_overwrite","")
BOOL INS_MTSafeWriteJmp (OADDR insAddr, OADDR tgtAddr)
OADDR INS_NextInsOaddr (INS ins, OADDR addr)
IADDR INS_NextInsIaddr (INS ins)
ADDRDELTA SignedOffset (ADDRINT imm)
IADDR INS_DirectBranchOrCallTargetIaddr (INS ins, IADDR iaddr)
IADDR INS_DirectBranchOrCallTargetIaddr (INS ins)
OADDR INS_DirectBranchOrCallTargetOaddr (INS ins, OADDR oaddr)
IADDR INS_IpRelTargetIaddr (INS ins)
BOOL INS_IsStackRead (const INS ins)
BOOL INS_IsStackWrite (const INS ins)
BOOL INS_IsIpRelRead (const INS ins)
BOOL INS_IsIpRelWrite (const INS ins)
BOOL INS_IsPredicated (INS ins)
BOOL INS_HasRealRep (INS ins)
REL_TYPE REL_AddrintRel ()
VOID INS_InitEncodeDecoder ()
VOID SEC_CreateOriginalIns (SEC sec)
VOID IMG_ConvertWeirdBranches (IMG img)
LOCALFUN string INS_RawInstBytes (INS ins)
LOCALVAR KNOB< BOOL > KnobPrintRawInstruction (KNOB_MODE_WRITEONCE,"supported","rawinst","0","Print raw instruction encoding in string conversions")
LOCALVAR KNOB< BOOL > KnobPrintPinRegs (KNOB_MODE_WRITEONCE,"supported","printpinreg","0","Print Pin registers in disassembly")
LOCALVAR KNOB< BOOL > KnobPrintBranch (KNOB_MODE_WRITEONCE,"supported","printbr","0","Print branch information in disassembly")
LOCALFUN string INS_RegsRead (INS ins)
LOCALFUN string INS_RegsWritten (INS ins)
string INS_StringShorter (INS ins)
string INS_StringShort (INS ins)
BOOL INS_IsOriginal (INS ins)
string INS_Disassemble (INS ins)
string INS_StringShortFancy (INS ins)
string INS_StringLong (INS ins)
BOOL INS_IsSimpleStackOffsetRead (INS ins, INT32 *offset)
BOOL INS_IsSimpleStackOffsetWrite (INS ins, INT32 *offset)
BOOL INS_IsPatchable (INS ins)
REG REG_RenameAppReg (const REG reg)
REG REG_RenamePinReg (const REG reg)
BOOL REG_ShouldBeRenamed (CALLING_STANDARD std, REG reg)
VOID INS_RenameRegsForInlining (CALLING_STANDARD std, INS ins)
PIN_DEPRECATED_API ADDRINT INS_MemoryOffset (INS ins)
ADDRDELTA INS_MemoryDisplacement (INS ins)
PIN_DEPRECATED_API ADDRDELTA INS_MemoryDisplacementSigned (INS ins)
REG INS_MemoryBaseReg (INS ins)
REG INS_MemoryIndexReg (INS ins)
UINT32 INS_MemoryScale (INS ins)
BOOL INS_IsStandardMemop (INS ins)
BOOL INS_hasKnownMemorySize (INS ins)
BOOL INS_ChangeReg (const INS ins, const REG old_reg, const REG new_reg, const BOOL as_read)
REG INS_ChangeToPinFlagsReg (const INS ins, const BOOL as_read)
LOCALFUN VOID ChangeStackPtr (INS ins, UINT32 num, BOOL read, BOOL *changed)
BOOL INS_ChangeStackPtr (INS ins)
BOOL INS_ChangeToUsePinFlags (const INS ins)
BOOL INS_RegsReadBeforeWritten (INS ins)
BOOL INS_ReadsAndWritesDestReg (INS ins)
BOOL INS_IsRegWrittenByIns (INS ins, REG reg)
BOOL INS_IsCacheLineFlush (INS ins)
LOCALFUN REGWIDTH GetRegWidthOfEaWidth (INT32 ea_width)
LOCALFUN UINT GetBitSizeOfRegWidth (REGWIDTH reg_width)
LOCALFUN INT32 GetEffectiveAddressBitWidth (REG base, REG index)
VOID validate_displacement (INT32 signed_displacement, UINT32 bytes, UINT8 legal_displacement_bytewidths_bitmap)
LOCALFUN VOID INS_ChangeImmediate (INS ins, UINT64 immed)
UINT INS_VerifyScale (UINT scale)
LOCALFUN VOID XED_modify_legal_bytewidths_bitmap (xed_reg_enum_t dummy_base, UINT8 &legal_bytewidths_bitmap)
LOCALFUN UINT INS_compute_memop_width (UINT opwidth, REGWIDTH reg_width, UINT membytes=0)
LOCALFUN UINT8 ComputeNumBytesNeededForSignedImmediate (UINT64 immed, UINT32 legal_immed_bytewidths_bitmap, UINT32 extendedSize=8 *sizeof(ADDRINT), UINT32 destination_bit_size=0)
LOCALFUN xed_encoder_operand_t GetShortestWidthSignedImmediate (UINT64 immed, UINT32 legal_immed_bytewidths_bitmap, UINT32 extendedSize=8 *sizeof(ADDRINT), UINT32 destination_bit_size=0)
LOCALFUN VOID ClearOperand (xed_encoder_request_t *xed_enc, UINT32 operandIndex)
LOCALFUN VOID UpdateRegs (BOOL read, INS origIns, INS newIns, UINT32 origNum, UINT32 newNum)
LOCALFUN UINT32 MaxImmediate (INS ins)
LOCALFUN UINT8 INS_GetMemoryDisplacementLengthBits (INS ins)
LOCALFUN UINT8 GetLegalByteWidthsBitmapForEaWidth (INT32 ea_width)
LOCALFUN VOID VerifySameEncoding (INS checkIns, INS insOrig, int fromWhere)
LOCALFUN BOOL INS_CompareReadAndWriteRegs (INS ins1, INS ins2)
LOCALVAR STAT_UINT64 INSInitNoRegOpStat ("pin","insts","inssNoRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitRegOpStat ("pin","insts","inssRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitRegRegOpStat ("pin","insts","inssRegRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitYmmRegRegRegOp ("pin","insts","inssYmmRegRegRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitRegWordRegByteOp ("pin","insts","inssegWordRegByteOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitRegWidthRegOp ("pin","insts","inssRegWidthRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitRegImmOp ("pin","insts","inssRegImmOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitImmOp ("pin","insts","inssImmOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitWidthRegImmOp ("pin","insts","inssWidthRegImmOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitFarDirectOp ("pin","insts","inssFarDirectOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitSDispOp ("pin","insts","inssSDispOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitMemImmOp ("pin","insts","inssMemImmOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitMMRegRegOp ("pin","insts","inssMMRegRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitMMLoad ("pin","insts","inssMMLoad_via_xed","")
LOCALVAR STAT_UINT64 INSInitMMStore ("pin","insts","inssMMStore_via_xed","")
LOCALVAR STAT_UINT64 INSInitYMMInsertOp ("pin","insts","inssYMMInsertOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitLoadMemop ("pin","insts","inssLoadMemop_via_xed","")
LOCALVAR STAT_UINT64 INSInitStoreMemop ("pin","insts","inssStoreMemop_via_xed","")
LOCALVAR STAT_UINT64 INSInitRetImm ("pin","insts","inssRetImm_via_xed","")
LOCALVAR STAT_UINT64 INSInitSizedNop ("pin","insts","inssSizedNop_via_xed","")
LOCALVAR STAT_UINT64 INSInitYMMRegOp ("pin","insts","inssYMMRegOp_via_xed","")
LOCALVAR STAT_UINT64 INSInitChangeOperandToImmediate ("pin","insts","ChangeOpToImm_via_xed","")
LOCALVAR STAT_UINT64 PinReusedInssStat ("pin","insts","generated_inss_via_reuse","")
LOCALVAR STAT_NORM TimerINS_Init ("pin","time","INS_Init","",&TimerCompile)
LOCALFUN VOID INS_XedProcessInstAndUpdateStripe (INS ins, xed_encoder_instruction_t *xed_inst, int ea_width=0)
LOCALFUN VOID INS_XedInst0 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width)
LOCALFUN VOID INS_XedInst1 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width, const xed_encoder_operand_t &op0, int ea_width=0)
LOCALFUN VOID INS_XedInst2 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width, const xed_encoder_operand_t &op0, const xed_encoder_operand_t &op1)
LOCALFUN VOID INS_XedInst3 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width, const xed_encoder_operand_t &op0, const xed_encoder_operand_t &op1, const xed_encoder_operand_t &op2)
LOCALFUN VOID INS_XedInst4 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width, const xed_encoder_operand_t &op0, const xed_encoder_operand_t &op1, const xed_encoder_operand_t &op2, const xed_encoder_operand_t &op3)
LOCALFUN VOID INS_XedInst5 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width, const xed_encoder_operand_t &op0, const xed_encoder_operand_t &op1, const xed_encoder_operand_t &op2, const xed_encoder_operand_t &op3, const xed_encoder_operand_t &op4)
LOCALFUN VOID INS_InitSizedNopOriginal (INS ins, UINT requested_length_bytes)
VOID INS_InitSizedNop (INS ins, UINT requested_length_bytes)
LOCALFUN VOID INS_InitNoRegOpOriginal (INS ins, xed_iclass_enum_t iclass)
LOCALFUN VOID INS_InitNoRegOp (INS ins, xed_iclass_enum_t iclass)
LOCALINLINE xed_reg_enum_t get_dummy_reg_native (UINT i)
LOCALINLINE xed_reg_enum_t get_dummy_reg (UINT i, REGWIDTH reg_width)
LOCALINLINE xed_reg_enum_t get_dummy_index_reg (UINT i, REGWIDTH reg_width)
LOCALINLINE xed_reg_enum_t get_dummy_base_reg (UINT i, REGWIDTH reg_width)
LOCALINLINE VOID INS_InitRegOpGetDummyRegs (REG reg, xed_reg_enum_t *dummy_reg, REGWIDTH regWidth)
LOCALFUN VOID INS_InitRegOpReplaceDummyRegs (INS ins, xed_reg_enum_t dummy_reg, REG reg)
LOCALFUN VOID INS_InitRegOpOriginal (INS ins, REG reg, xed_iclass_enum_t iclass, REGWIDTH regWidth, BOOL replaceXedRegs)
LOCALFUN VOID INS_InitRegOp (INS ins, REG reg, xed_iclass_enum_t iclass, REGWIDTH regWidth)
LOCALFUN VOID INS_InitRegRegOpGetDummyRegsAndWidths (REG dst, xed_reg_enum_t *dummy_dst, xed_reg_enum_t *dummy_src, unsigned int *op_width, REGWIDTH *reg_width)
LOCALFUN VOID INS_InitRegRegOpReplaceDummyRegs (INS ins, xed_reg_enum_t dummy_dst, REG dst, xed_reg_enum_t dummy_src, REG src)
LOCALFUN VOID INS_InitRegRegOpOriginal (INS ins, REG src_reg, REG dst_reg, xed_iclass_enum_t iclass, BOOL replaceXedRegs, xed_reg_enum_t dummy_src=XED_REG_ECX, xed_reg_enum_t dummy_dst=XED_REG_EDX, unsigned int op_width=32)
LOCALFUN VOID INS_InitRegRegOp (INS ins, REG src, REG dst, xed_iclass_enum_t iclass, xed_reg_enum_t dummy_src=XED_REG_ECX, xed_reg_enum_t dummy_dst=XED_REG_EDX, unsigned int op_width=32)
LOCALFUN VOID INS_InitYmmRegRegRegOpReplaceDummyRegs (INS ins, REG dest, xed_reg_enum_t dummy_dest, REG src1, xed_reg_enum_t dummy_src1, REG src2, xed_reg_enum_t dummy_src2)
LOCALFUN VOID INS_InitYmmRegRegRegOpOriginal (INS ins, REG src2, REG src1, REG dest, xed_iclass_enum_t iclass, BOOL replaceXedRegs, xed_reg_enum_t dummy_src2=XED_REG_YMM0, xed_reg_enum_t dummy_src1=XED_REG_YMM0, xed_reg_enum_t dummy_dest=XED_REG_YMM0)
LOCALFUN VOID INS_InitYmmRegRegRegOp (INS ins, REG src2, REG src1, REG dest, xed_iclass_enum_t iclass, xed_reg_enum_t dummy_src2=XED_REG_YMM0, xed_reg_enum_t dummy_src1=XED_REG_YMM0, xed_reg_enum_t dummy_dest=XED_REG_YMM0)
LOCALFUN VOID INS_InitRegWordRegByteOpOriginal (INS ins, REG srcByte, REG dstWord, xed_iclass_enum_t iclass, BOOL replaceXedRegs, xed_reg_enum_t dummy_src=XED_REG_CL, xed_reg_enum_t dummy_dst=XED_REG_DX, unsigned int op_width=16)
LOCALFUN VOID INS_InitRegWordRegByteOpReplaceDummyRegs (INS ins, REG dstWord, xed_reg_enum_t dummy_dst, REG srcByte, xed_reg_enum_t dummy_src)
LOCALFUN VOID INS_InitRegWordRegByteOp (INS ins, REG srcByte, REG dstWord, xed_iclass_enum_t iclass, xed_reg_enum_t dummy_src=XED_REG_CL, xed_reg_enum_t dummy_dst=XED_REG_DX, unsigned int op_width=16)
LOCALFUN VOID INS_InitRegWidthRegOpOriginal (INS ins, REG src, REG dst, xed_iclass_enum_t iclass, REGWIDTH regWidth, BOOL replaceXedRegs, unsigned int op_width=32)
LOCALFUN VOID INS_InitRegWidthRegOpGetDummyRegs (xed_reg_enum_t *dummy_dst, xed_reg_enum_t *dummy_src, REGWIDTH regWidth)
LOCALFUN VOID INS_InitRegWidthRegOpReplaceDummyRegs (INS ins, REG dst, xed_reg_enum_t dummy_dst, REG src, xed_reg_enum_t dummy_src)
LOCALFUN VOID INS_InitRegWidthRegOp (INS ins, REG src, REG dst, xed_iclass_enum_t iclass, REGWIDTH regWidth, unsigned int op_width=32)
LOCALFUN VOID INS_InitRegImmOpReplaceDummyRegs (INS ins, xed_reg_enum_t dummy_reg, REG reg)
LOCALFUN VOID INS_InitRegImmOpOriginal (INS ins, REG reg, UINT64 immed, xed_iclass_enum_t iclass, UINT8 legal_immed_bytewidths_bitmap, BOOL replaceXedRegs)
LOCALFUN VOID INS_InitRegImmOp (INS ins, REG reg, UINT64 immed, xed_iclass_enum_t iclass, UINT8 legal_immed_bytewidths_bitmap)
LOCALFUN VOID INS_InitImmOpOriginal (INS ins, UINT64 immed, xed_iclass_enum_t iclass, UINT8 legal_immed_bytewidths_bitmap=7)
LOCALFUN VOID INS_InitImmOp (INS ins, UINT64 immed, xed_iclass_enum_t iclass, UINT8 legal_immed_bytewidths_bitmap=7)
LOCALFUN VOID INS_InitWidthRegImmOpOriginal (INS ins, REG reg, UINT64 immed, xed_iclass_enum_t iclass, UINT8 legal_immed_bytewidths_bitmap, REGWIDTH regWidth, BOOL replaceXedRegs)
LOCALFUN VOID INS_InitWidthRegImmOp (INS ins, REG reg, UINT64 immed, xed_iclass_enum_t iclass, UINT8 legal_immed_bytewidths_bitmap, REGWIDTH regWidth)
LOCALFUN VOID INS_InitSDispOpOriginal (INS ins, INT64 disp, xed_iclass_enum_t iclass, INT32 ea_width, INS orig)
LOCALFUN VOID INS_InitSDispOp (INS ins, INT64 disp, xed_iclass_enum_t iclass, INT32 ea_width=sizeof(VOID *)*8, INS orig=INS_INVALID())
VOID INS_InitSDispOpGlobal (INS ins, INT64 disp, OPCODE iclass)
LOCALFUN VOID INS_InitXbeginOriginal (INS ins)
VOID INS_InitXbegin (INS ins)
LOCALFUN VOID INS_InitMemImmOpGetDummyRegs (REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, INT32 ea_width, BOOL exactCopy, BOOL *ins_encoded_with_corresponding_app_reg)
LOCALFUN VOID INS_InitMemImmOpReplaceDummyRegs (INS ins, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index)
LOCALFUN VOID INS_InitMemImmOpOriginal (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, OPCODE op, UINT64 immed, UINT8 legal_immed_bytewidths_bitmap, REGWIDTH reg_width, BOOL replaceXedRegs, BOOL exactCopy)
VOID INS_InitMemImmOp (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, OPCODE op, UINT64 immed, UINT8 legal_immed_bytewidths_bitmap, REGWIDTH reg_width, BOOL exactCopy)
LOCALFUN VOID INS_InitMMRegRegOpOriginal (INS ins, REG mmdst, REG mmsrc, xed_iclass_enum_t iclass, BOOL replaceXedRegs, xed_reg_enum_t dummy_dst, xed_reg_enum_t dummy_src, REGWIDTH regWidth=REGWIDTH_NATIVE)
LOCALFUN VOID INS_InitMMRegRegOpReplaceDummyRegs (INS ins, REG mmsrc, xed_reg_enum_t dummy_src, REG mmdst, xed_reg_enum_t dummy_dst)
LOCALFUN VOID INS_InitMMRegRegOp (INS ins, REG mmdst, REG mmsrc, xed_iclass_enum_t iclass, xed_reg_enum_t dummy_dst, xed_reg_enum_t dummy_src, REGWIDTH regWidth=REGWIDTH_NATIVE)
LOCALFUN VOID INS_InitMMLoadGetDummyRegs (REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, REG mm_dst, xed_reg_enum_t *dummy_mm_dst, xed_reg_enum_t dummy_dst_param, REG maskReg, xed_reg_enum_t *dummy_mask, xed_reg_enum_t dummy_mask_param, INT32 ea_width, BOOL exactCopy)
LOCALFUN VOID INS_InitMMLoadReplaceDummyRegs (INS ins, REG mmdst, xed_reg_enum_t dummy_dst, REG maskReg, xed_reg_enum_t dummy_mask, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index)
LOCALFUN VOID INS_InitMMLoadOriginal (INS ins, REG mmdst, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG pinseg, xed_iclass_enum_t iclass, UINT32 memop_byte_length, xed_reg_enum_t dummy_dst_param, xed_reg_enum_t dummy_mask_param, BOOL replaceXedRegs, BOOL exactCopy)
LOCALFUN VOID INS_InitMMLoad (INS ins, REG mmdst, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG pinseg, xed_iclass_enum_t iclass, UINT32 memop_byte_length, xed_reg_enum_t dummy_dst_param, xed_reg_enum_t dummy_mask_param, BOOL exactCopy)
LOCALFUN VOID INS_InitMMStoreGetDummyRegs (REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, REG mmsrc, xed_reg_enum_t *dummy_mmsrc, xed_reg_enum_t dummy_mmsrc_param, REG maskReg, xed_reg_enum_t *dummy_mask, xed_reg_enum_t dummy_mask_param, INT32 ea_width, BOOL exactCopy)
LOCALFUN VOID INS_InitMMStoreReplaceDummyRegs (INS ins, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index, REG mmsrc, xed_reg_enum_t dummy_src, REG maskReg, xed_reg_enum_t dummy_mask, xed_operand_enum_t xedreg_op, xed_operand_enum_t maskreg_op, const UINT memop_pos, const UINT regop_pos, const UINT maskop_pos)
LOCALFUN VOID INS_InitMMStoreOriginal (INS ins, REG mmsrc, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG pinseg, xed_iclass_enum_t iclass, UINT32 memop_byte_length, xed_reg_enum_t dummy_src_param, xed_reg_enum_t dummy_mask_param, BOOL replaceXedRegs, BOOL exactCopy)
LOCALFUN VOID INS_InitMMStore (INS ins, REG mmsrc, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG pinseg, xed_iclass_enum_t iclass, UINT32 memop_byte_length, xed_reg_enum_t dummy_src_param, xed_reg_enum_t dummy_mask_param, BOOL exactCopy)
LOCALFUN VOID INS_InitMMInsertOpGetDummyRegs (REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, REG mm_src, xed_reg_enum_t *dummy_mmsrc, REG mm_dst, xed_reg_enum_t *dummy_mmdst, REG maskReg, xed_reg_enum_t *dummy_maskReg)
LOCALFUN VOID INS_InitMMInsertOpReplaceDummyRegs (INS ins, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index, REG mmsrc, xed_reg_enum_t dummy_src, REG mmdst, xed_reg_enum_t dummy_dst, REG maskReg, xed_reg_enum_t dummy_mask)
LOCALFUN VOID INS_InitMMInsertOpOriginal (INS ins, REG mmDest, REG mmSrc, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG seg, UINT32 imm8, xed_iclass_enum_t iclass, UINT32 operandWidthBits, BOOL replaceXedRegs)
LOCALFUN VOID INS_InitMMInsertOp (INS ins, REG mmDest, REG mmSrc, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG seg, UINT32 imm8, xed_iclass_enum_t iclass, UINT32 operandWidthBits)
LOCALFUN VOID INS_InitMMExtractOpGetDummyRegs (REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, REG mm_src, xed_reg_enum_t *dummy_mmsrc, REG maskReg, xed_reg_enum_t *dummy_maskReg)
LOCALFUN VOID INS_InitMMExtractOpReplaceDummyRegs (INS ins, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index, REG mmsrc, xed_reg_enum_t dummy_src, REG maskReg, xed_reg_enum_t dummy_mask)
LOCALFUN VOID INS_InitMMExtractOpOriginal (INS ins, REG mmSrc, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG seg, UINT32 imm8, xed_iclass_enum_t iclass, UINT32 operandWidthBits, BOOL replaceXedRegs)
LOCALFUN VOID INS_InitMMExtractOp (INS ins, REG mmSrc, REG maskReg, REG base, INT32 displacement, UINT disp_bytes, REG index, UINT scale, REG seg, UINT32 imm8, xed_iclass_enum_t iclass, UINT32 operandWidthBits, BOOL replaceXedRegs)
LOCALFUN VOID INS_InitLoadMemopGetDummyRegs (REG dst, xed_reg_enum_t *dummy_dst, REG index, xed_reg_enum_t *dummy_index, REG base, xed_reg_enum_t *dummy_base, INT32 ea_width, REGWIDTH reg_width, BOOL exactCopy, xed_iclass_enum_t iclass)
LOCALFUN VOID INS_InitLoadmemopReplaceDummyRegs (INS ins, REG dst, xed_reg_enum_t dummy_dst, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index, UINT memop_pos)
LOCALFUN VOID INS_InitLoadMemopOriginal (INS ins, REG dst, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, xed_iclass_enum_t iclass, BOOL replaceXedRegs, BOOL exactCopy, xed_operand_enum_t xed_op=XED_OPERAND_MEM0, UINT8 legal_displacement_bytewidths_bitmap=5, REGWIDTH reg_width=REGWIDTH_NATIVE, INT32 ea_width=sizeof(VOID *)*8, UINT load_bytes=0)
LOCALFUN VOID INS_InitLoadMemop (INS ins, REG dst, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, xed_iclass_enum_t iclass, BOOL exactCopy, xed_operand_enum_t xed_op=XED_OPERAND_MEM0, UINT8 legal_displacement_bytewidths_bitmap=5, REGWIDTH reg_width=REGWIDTH_NATIVE, INT32 ea_width=sizeof(VOID *)*8, UINT load_bytes=0)
LOCALFUN VOID INS_InitStoreMemopGetDummyRegs (REG src, xed_reg_enum_t *dummy_src, REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, REGWIDTH reg_width, INT32 ea_width, BOOL exactCopy, xed_iclass_enum_t iclass)
LOCALFUN VOID INS_InitStoreMemopReplaceDummyRegs (INS ins, REG src, xed_reg_enum_t dummy_src, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index)
LOCALFUN VOID INS_InitStoreMemopOriginal (INS ins, REG src, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, xed_iclass_enum_t iclass, BOOL replaceXedRegs, BOOL exactCopy, UINT8 legal_displacement_bytewidths_bitmap=5, REGWIDTH reg_width=REGWIDTH_NATIVE, UINT store_bytes=0)
LOCALFUN VOID INS_InitStoreMemop (INS ins, REG src, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, xed_iclass_enum_t iclass, BOOL exactCopy, REGWIDTH reg_width=REGWIDTH_NATIVE, UINT store_bytes=0)
LOCALFUN VOID INS_InitRetImmOriginal (INS ins, UINT64 imm)
VOID INS_InitRetImm (INS ins, UINT64 imm)
VOID INS_ReplaceMemop (INS ins, unsigned int operand_index, REG base, ADDRDELTA displacement, REG index, ADDRINT scale, REG pinseg, REGWIDTH ea_width)
LOCALFUN VOID INS_ChangeOperandToImmediateReplaceDummyRegs (INS ins, INS origIns)
LOCALFUN VOID INS_ChangeOperandToImmediateOriginal (INS ins, UINT32 operandIndex, UINT64 immediate, REG regBeingReplaced, BOOL replaceXedRegs)
VOID INS_ChangeOperandToImmediate (INS ins, UINT32 operandIndex, REG regBeingReplaced, UINT64 immediate)
LOCALFUN VOID INS_InitFarDirectOp (INS ins, UINT32 displacement, UINT16 segment_selector, xed_iclass_enum_t iclass)
VOID INS_GenRegRegOp (INS ins, REG src_reg, REG dst_reg, OPCODE opcode)
VOID INS_GenRegRegWordOp (INS ins, REG src_reg, REG dst_reg, OPCODE opcode)
VOID INS_GenRegRegDwordOp (INS ins, REG src_reg, REG dst_reg, OPCODE opcode)
VOID INS_GenRegRegByteOp (INS ins, REG src_reg, REG dst_reg, OPCODE opcode)
VOID INS_GenRegImmOp (INS ins, REG reg, UINT64 immed, OPCODE opcode)
VOID INS_GenRegImmByteOp (INS ins, REG reg, UINT64 immed, OPCODE opcode)
VOID INS_GenRegImmWordOp (INS ins, REG reg, UINT64 immed, OPCODE opcode)
VOID INS_GenRegImmDwordOp (INS ins, REG reg, UINT64 immed, OPCODE opcode)
VOID INS_InitHalt (INS ins)
VOID INS_InitMovMemImmOp (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, UINT64 immed, UINT8 legal_immed_bytewidths_bitmap, BOOL exactCopy)
VOID INS_InitMovMemImmOpWidth (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, UINT64 immed, UINT8 legal_immed_bytewidths_bitmap, REGWIDTH reg_width)
VOID INS_InitStoreMaskReg (INS ins, REG src, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, BOOL exactCopy)
VOID INS_InitLoadMaskReg (INS ins, REG dst, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, BOOL exactCopy)
VOID INS_GenMemImmOpWidth (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, UINT64 immed, OPCODE opcode, UINT8 legal_immed_bytewidths_bitmap, REGWIDTH reg_width)
VOID INS_GenSizedNop (INS ins, UINT requested_length_bytes)
LOCALFUN UINT GetSimpleDisplacementWidthForAVX512 (const INT32 displacement)
VOID INS_InitUnalignedStoreXMM (INS ins, REG src, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitUnalignedStoreXMMUsingAvx (INS ins, REG src, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitUnalignedStoreYMM (INS ins, REG src, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitAlignedStoreXMM (INS ins, REG src, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitAlignedStoreZMM (INS ins, REG src, REG mask, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitUnalignedStoreZMM (INS ins, REG src, REG mask, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitUnalignedLoadXMM (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitUnalignedLoadYMM (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitAlignedLoadXMM (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitAlignedLoadZMM (INS ins, REG dst, REG mask, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
VOID INS_InitUnalignedLoadZMM (INS ins, REG dst, REG mask, REG base, INT32 displacement, REG index, UINT scale, REG seg, BOOL exactCopy)
LOCALFUN VOID INS_InitXMMLoadOp (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg, xed_iclass_enum_t iclass)
LOCALFUN VOID INS_InitXMMRegRegOp (INS ins, REG dst, REG src, xed_iclass_enum_t iclass)
LOCALFUN VOID INS_InitGPR32XMMOp (INS ins, REG dst, REG src, xed_iclass_enum_t iclass)
VOID INS_InitVxorpd (INS ins, REG ymmDest, REG ymmSrc1, REG ymmSrc2)
VOID INS_Vinsertf128FromMem (INS ins, REG ymmDest, REG ymmSrc1, REG base, INT32 displacement, REG index, UINT scale, REG seg, UINT8 imm8)
VOID INS_Vinsertf32x4FromMem (INS ins, REG zmmDest, REG zmmSrc1, REG maskReg, REG base, INT32 displacement, REG index, UINT scale, REG seg, UINT8 imm8)
VOID INS_InitPCMPEQBRegMem (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitPCMPEQDRegMem (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitPORRegMem (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitMOVDQARegReg (INS ins, REG dst, REG src)
VOID INS_InitPANDRegReg (INS ins, REG dst, REG src)
VOID INS_InitPMOVMSKB (INS ins, REG dst, REG src)
VOID INS_InitLoadMMX (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitStoreMMX (INS ins, REG src, REG base, INT32 displacement, REG index, UINT scale, REG seg)
VOID INS_InitLoad (INS ins, REG dst, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG seg, BOOL exactCopy)
VOID INS_InitLoadWidth (INS ins, REG dst, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG seg, REGWIDTH reg_width)
VOID INS_InitLoadEaWidth (INS ins, REG dst, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG seg, INT32 ea_width)
VOID INS_InitStore (INS ins, REG src, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, BOOL exactCopy)
VOID INS_InitStore (INS ins, REG src, REG base, ADDRINT displacement, REG index, UINT32 scale, BOOL exactCopy)
VOID INS_InitStoreWidth (INS ins, REG src, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, REGWIDTH reg_width, BOOL exactCopy)
VOID INS_InitStoreNTIWidth (INS ins, REG src, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, REGWIDTH reg_width)
VOID INS_InitLea (INS ins, REG dst, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitLea (INS ins, REG dst, REG base, REG seg)
VOID INS_InitLeaEaWidth (INS ins, REG dst, REG base, ADDRINT displacement, REG index, UINT32 scale, INT32 ea_width)
VOID INS_InitLeaEaWidth (INS ins, REG dst, REG base, ADDRINT displacement, REG index, UINT32 scale, INT32 ea_width, REGWIDTH reg_width)
VOID INS_InitStoreMxcsr (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, BOOL useAvxVersion)
VOID INS_InitLoadMxcsr (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, BOOL useAvxVersion)
VOID INS_InitFxsave (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitXsave (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitFxrstor (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitXrstor (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitPush (INS ins, REG reg)
LOCALFUN VOID INS_InitVZeroUpperOriginal (INS ins)
VOID INS_InitVZeroUpper (INS ins)
VOID INS_InitPop (INS ins, REG reg)
VOID INS_InitPushF (INS ins)
VOID INS_InitLods (INS ins)
VOID INS_InitStos (INS ins)
VOID INS_InitRepStos (INS ins)
VOID INS_InitPopF (INS ins)
VOID INS_InitSAHF (INS ins)
VOID INS_InitLAHF (INS ins)
VOID INS_InitPushAL (INS ins)
VOID INS_InitPopAL (INS ins)
VOID INS_InitPush (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg)
VOID INS_InitPushWidth (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, REGWIDTH reg_width)
VOID INS_InitPop (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitFarDirectJmp (INS ins, UINT32 displacement, UINT16 segment_selector)
VOID INS_InitFarDirectCall (INS ins, UINT32 displacement, UINT16 segment_selector)
VOID INS_InitIntx86 (INS ins, UINT64 num)
VOID INS_InitAndI (INS ins, REG reg, UINT64 imm)
VOID INS_InitAnd (INS ins, REG src, REG dst)
VOID INS_InitOrI (INS ins, REG reg, UINT64 imm)
VOID INS_InitShlI (INS ins, REG reg, UINT64 imm)
VOID INS_InitBsr (INS ins, REG src, REG dst)
VOID INS_InitShrI (INS ins, REG reg, UINT64 imm)
VOID INS_InitAddI (INS ins, REG reg, UINT64 imm)
VOID INS_InitAddCI (INS ins, REG reg, UINT64 imm)
VOID INS_InitSubI (INS ins, REG reg, UINT64 imm)
VOID INS_InitNeg (INS ins, REG reg)
VOID INS_InitNot (INS ins, REG reg)
VOID INS_InitCld (INS ins)
VOID INS_InitStd (INS ins)
VOID INS_InitPushI (INS ins, UINT64 imm)
VOID INS_InitJmpL (INS ins, UINT64 imm)
VOID INS_InitJmpR (INS ins, REG src)
VOID INS_InitJxMemoryFromOtherIns (INS ins, INS other, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitJmpM (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, REG segreg)
VOID INS_InitJxBLFromOtherIns (INS ins, INS other, UINT64 imm)
VOID INS_InitJNZ (INS ins, INT32 imm)
VOID INS_InitJZ (INS ins, INT32 imm)
VOID INS_InitJAE (INS ins, INT32 imm)
VOID INS_InitJMP (INS ins, INT32 imm)
VOID INS_InitJCXZ (INS ins, UINT64 imm, REG countReg)
VOID INS_GenRetImm (INS ins, UINT64 imm)
VOID INS_InitCall (INS ins, UINT64 imm)
VOID INS_InitCallIndirectMemory (INS ins, REG segment, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitCallIndirectRegister (INS ins, REG target)
VOID INS_InitRet (INS ins)
VOID INS_InitInt (INS ins, UINT8 imm)
VOID INS_InitInt3 (INS ins)
VOID INS_InitUD2 (INS ins)
VOID INS_InitTest (INS ins, REG src, REG dst)
VOID INS_InitTestI (INS ins, REG reg, UINT64 imm)
VOID INS_InitTestMI (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, UINT64 immed)
VOID INS_InitAndMI (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, UINT64 immed)
VOID INS_InitOrMI (INS ins, REG base, ADDRINT displacement, REG index, ADDRINT scale, REG pinseg, UINT64 immed)
VOID INS_InitXor (INS ins, REG src, REG dst)
VOID INS_InitNop (INS ins)
VOID INS_InitMov (INS ins, REG src, REG dst)
VOID INS_InitMov32 (INS ins, REG src, REG dst)
VOID INS_InitMov16 (INS ins, REG src, REG dst)
VOID INS_InitMov8 (INS ins, REG src, REG dst)
VOID INS_InitMovzx (INS ins, REG src, REG dst)
VOID INS_InitMovsx (INS ins, REG src, REG dst)
VOID INS_InitMovsxMemop (INS ins, REG dst, REG base, ADDRINT displacement, REG index, UINT32 scale, REG seg, UINT32 memWidth)
VOID INS_InitMovSW (INS ins)
VOID INS_InitMovRegMem (INS ins, REG src, REG base, ADDRINT displacement, REG index, UINT32 scale)
VOID INS_InitMovMemReg (INS ins, REG segment, REG base, ADDRINT displacement, REG index, UINT32 scale, REG dst)
VOID INS_InitMovI (INS ins, UINT64 imm, REG dst, BOOL denyImm32SignExtension=FALSE)
VOID INS_InitMovAddrint (INS ins, ADDRINT imm, REG dst)
VOID INS_InitCmpI (INS ins, REG reg, UINT64 imm)
VOID INS_InitCmpBI (INS ins, REG reg, UINT64 imm)
VOID INS_InitCmpWI (INS ins, REG reg, UINT64 imm)
VOID INS_InitCmp (INS ins, REG src_reg, REG dst_reg)
VOID INS_InitXchg (INS ins, REG src_reg, REG dst_reg)
VOID INS_InitSubR (INS ins, REG src, REG dst)
VOID INS_InitAddR (INS ins, REG src, REG dst)
VOID INS_InitAddCR (INS ins, REG src, REG dst)
VOID INS_InitCmpMR (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, REG reg)
VOID INS_InitRdtsc (INS ins)
VOID INS_GenRegMemOpWidth (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, REG reg, OPCODE opcode, UINT8 legal_displacement_bytewidths_bitmap, REGWIDTH reg_width)
VOID INS_GenMemRegOpWidth (INS ins, REG base, ADDRINT displacement, REG index, UINT32 scale, REG src, OPCODE opcode, REGWIDTH reg_width, UINT store_bytes)
VOID INS_InitCmovccFromJcc (INS ins, INS jcc, REG src, REG dst)
VOID INS_InitCmov (INS ins, REG src, REG dst, PREDICATE_IA32 cond)
VOID INS_InitSetCC (INS ins, REG reg, PREDICATE_IA32 cond)
VOID INS_InitAAA (INS ins)
VOID INS_InitSeto (INS ins, REG reg)
VOID INS_InvertBr (INS ins)
VOID INS_InitIncMem (INS ins, REG base, ADDRINT disp, BOOL lock)
VOID INS_EmbedValue (INS ins, VOID *valuePtr, UINT32 valueSize)
VOID INS_MakeBaseAddress (INS ins, REG base)
UINT32 INS_min_alignment ()
INS SEC_FindOriginalTargetIns (SEC sec, INS ins)
BBL SEC_FindTargetBbl (SEC sec, INS ins)
IADDR SEC_MapOriginalInsToIaddr (SEC sec, INS ins)
INS SEC_MapIaddrToOriginalIns (SEC sec, IADDR iaddr)
LOCALVAR MESSAGE_TYPE MessageTypeLogInsReuse ("log_ins_reuse","", false, false, false, false, LOGTYPE_LOGFILE,"pin log: ins_reusing")
INS_REUSERS_MANAGER & InsReusersManager ()
KNOB< BOOL > KnobUseInsReusing (KNOB_MODE_WRITEONCE,"supported:regalloc","ins_reusing","1","Enable ins reusing")
LOCALVAR STAT_NORM StatInReusingStoreBytes ("mem","bytes","ins_reusing","",&StatRawMmapBytes)
LOCALVAR MESSAGE_TYPE MessageTypeLogXEDIa32 ("log_xed","", false, false, false, false, LOGTYPE_LOGFILE,"pin log: Intel(R) X86 Encoder Decoder ")
LOCALVAR STAT_UINT64 XEDStatDecode ("pin","xed","decoded_insts_by_xed","")
LOCALVAR STAT_UINT64 XEDStatDecodeForDecodeIns ("pin","xed","decoded_insts_for_DecodeIns","")
LOCALVAR STAT_UINT64 XEDStatDecodeForValidation ("pin","xed","decoded_insts_for_Validation","")
LOCALVAR STAT_UINT64 XEDStatDecodeFor_update_stripe ("pin","insts","decoded_for_update_stripe","")
LOCALVAR STAT_UINT64 XEDStatEncode ("pin","insts","encoded_insts_by_xed","")
LOCALVAR STAT_UINT64 XEDStatReencodeAndDecode ("pin","insts","encoded_decode_reencode","")
LOCALVAR STAT_UINT64 PinFetchedInssStat ("pin","insts","fetched_total","")
LOCALVAR STAT_UINT64 PinGeneratedInssStat ("pin","insts","generated_inss_via_xed","")
LOCALVAR STAT_NORM TimerXEDStatEncodeAndDecode ("pin","time","XED_e_d_updt_strp","",&TimerCompile)
LOCALVAR STAT_UINT64 XEDStatInsEncode ("pin","insts","encode_INS_Encode_total","")
LOCALVAR STAT_UINT64 XEDStatInsEncodeUsedCachedEncode ("pin","insts","encode_INS_Encode_used_cached","")
LOCALVAR STAT_UINT64 XEDStatCachedReencode ("pin","insts","cached_reencoded_insts","")
LOCALVAR KNOB_COMMENT knob_xed_family ("supported:xed","Intel(R) X86 Encoder Decoder switches")
KNOB< BOOL > knob_mpx_mode (KNOB_MODE_WRITEONCE,"supported:xed","xed_mpx_mode","0","Enable Intel(R) MPX instruction decoding")
KNOB< BOOL > knob_cet_mode (KNOB_MODE_WRITEONCE,"supported:xed","xed_cet_mode","0","Enable Intel(R) CET instruction decoding")
LOCALVAR KNOB< BOOL > KnobXedValidateEncoding (KNOB_MODE_WRITEONCE,"supported","xedvalidateencoding","0","Check the encoding by decoding and comparing")
LOCALVAR KNOB< BOOL > KnobXedReencodeTest (KNOB_MODE_WRITEONCE,"supported","xedreencodetest","0","Intel(R) X86 Encoder Decoder reencode test")
LOCALVAR KNOB< BOOL > KnobXedReencodeCache (KNOB_MODE_WRITEONCE,"supported","xedreencodecache","1","Intel(R) X86 Encoder Decoder reencode cache")
LOCALVAR KNOB< BOOL > KnobXedEncoderTest (KNOB_MODE_WRITEONCE,"supported","xedenc","0","Intel(R) X86 Encoder Decoder encoder testing")
LOCALVAR KNOB< UINT32 > KnobXedLog (KNOB_MODE_WRITEONCE,"supported","xedlog","0","Intel(R) X86 Encoder Decoder log messages levels 0-5")
LOCALVAR KNOB< string > KnobXedLogfile (KNOB_MODE_WRITEONCE,"supported","xedlogfile","xed.log","The Intel(R) X86 Encoder Decoder logfile prefix")
LOCALVAR KNOB< BOOL > KnobXedDecodeLog (KNOB_MODE_WRITEONCE,"supported","log_xed_decode","0","log all decodes")
LOCALVAR KNOB< BOOL > KnobXedEncodeLog (KNOB_MODE_WRITEONCE,"supported","log_xed_encode","0","log all encodes")
STRIPE< INS_XED_STRUCT_DECODE > InsStripeXEDDecode ("ins stripe Intel(R) X86 Encoder Decoder ia32 decoded","core",&InsArrayBase)
STRIPE< INS_XED_STRUCT_ENCODE > InsStripeXEDEncode ("ins stripe Intel(R) X86 Encoder Decoder ia32 encoded","core",&InsArrayBase)
UINT32 INS_orig_size (INS x)
VOID INS_orig_size_set (INS x, UINT32 y)
xed_decoded_inst_t * INS_xed_dec (INS ins)
xed_operand_values_t * INS_xed_operand_values (INS ins)
VOID INS_SetDirty (INS ins)
xed_decoded_inst_t * INS_XedDec (INS ins)
LOCALINLINE VOID INS_ClearDirty (INS ins)
VOID INS_ClearDirtyG (INS ins)
LOCALINLINE BOOL INS_Dirty (INS ins)
BOOL INS_DirtyG (INS ins)
LOCALINLINE VOID INS_EncodeSizeSet (INS ins, UINT32 size)
VOID INS_EncodeSizeSetG (INS ins, UINT32 size)
LOCALINLINE UINT32 INS_EncodeSize (INS ins)
UINT32 INS_EncodeSizeG (INS ins)
LOCALINLINE UINT8 * INS_EncodeBuffer (INS ins)
UINT8 * INS_EncodeBufferG (INS ins)
VOID INS_set_reg_r (INS x, UINT i, REG r)
VOID INS_set_reg_w (INS x, UINT i, REG r)
REG INS_get_reg_r (INS x, UINT i)
REG INS_get_reg_w (INS x, UINT i)
xed_operand_enum_t INS_get_role_r (INS x, UINT i)
xed_operand_enum_t INS_get_role_w (INS x, UINT i)
UINT INS_get_pos_r (INS x, UINT i)
UINT INS_get_pos_w (INS x, UINT i)
xed_operand_enum_t INS_GetRole (INS ins, UINT i, BOOL read)
UINT INS_GetPos (INS ins, UINT i, BOOL read)
REG INS_GetReg (INS ins, UINT i, BOOL read)
VOID INS_SetReg (INS ins, UINT i, REG r, BOOL read)
UINT8 INS_get_num_reads (INS x)
UINT8 INS_get_num_writes (INS x)
UINT8 INS_set_num_reads (INS x, UINT v)
UINT8 INS_set_num_writes (INS x, UINT v)
LOCALFUN VOID INS_set_role_r (INS x, UINT i, xed_operand_enum_t r)
LOCALFUN VOID INS_set_role_w (INS x, UINT i, xed_operand_enum_t r)
LOCALFUN VOID INS_set_pos_r (INS x, UINT i, UINT r)
LOCALFUN VOID INS_set_pos_w (INS x, UINT i, UINT r)
LOCALFUN string XED_StringXed (xed_decoded_inst_t *xedd)
string INS_StringXed (INS ins)
LOCALFUN string BeforeAfter (xed_decoded_inst_t *before, xed_decoded_inst_t *after)
LOCALFUN VOID RecordMismatch (BOOL &mismatch, ostringstream &ostr, const string reason)
LOCALVAR STAT_NORM TimerDecode ("pin","time","decode_(overlaps)","",&TimerVm)
LOCALFUN VOID XED_print_bytes (ostream &os, const UINT8 *buf, UINT len)
LOCALFUN xed_error_enum_t XedDecode (xed_decoded_inst_t *output, const UINT8 *buffer, UINT32 size)
LOCALVAR STAT_NORM TimerEncode ("pin","time","encode_(overlaps)","",&TimerVm)
LOCALFUN BOOL XedEncode (xed_encoder_request_t *xed_enc, UINT8 *new_bits, const UINT itext_length, UINT *olen)
LOCALFUN VOID ValidateEncoding (INS inputIns, UINT len, UINT8 *buffer)
LOCALFUN VOID XED_decode_update_stripe (INS ins, const xed_operand_values_t *enc_operands, UINT itext_buf_len, UINT enc_len, UINT8 *itext_buf)
LOCALFUN string StrXedEnc (const xed_encoder_request_t *r)
VOID XED_reencode_decode_update_stripe (INS ins)
VOID XED_encode_decode_update_stripe (INS ins, xed_encoder_request_t *xed_enc)
REG xed_reg_to_pin_reg (xed_reg_enum_t xedreg, INS ins)
REG XED_BaseOnly (INS ins, BOOL filterWrites, BOOL filterReads, BOOL filterImplicit)
VOID XED_logger (INS ins, char *msg)
LOCALFUN VOID init_xed_pin_reg_arrays ()
REG INS_XedExactMapToPinReg (unsigned int r)
REG xed_exact_map_to_pin_reg (xed_reg_enum_t xed_reg)
REG xed_map_to_pin_reg (xed_reg_enum_t xed_reg)
xed_reg_enum_t xed_exact_map_from_pin_reg (REG pin_reg)
VOID XED_RegRolePosToXED (INS ins)
FLAGS XED_PhyFlagsWritten (const xed_decoded_inst_t *xedd, BOOL onlyDefinite)
FLAGS XED_PhyFlagsRead (const xed_decoded_inst_t *xedd)
LOCALINLINE VOID AddRegToRegsRead (INS ins, UINT &nr, REG pinRegR, xed_operand_enum_t xed_operand, UINT xed_operand_index)
LOCALINLINE VOID AddRegToRegsWritten (INS ins, UINT &nw, REG pinRegW, xed_operand_enum_t xed_operand, UINT xed_operand_index)
LOCALFUN VOID XED_add_reg_to_stripe (INS ins, const xed_decoded_inst_t *xedd, const xed_operand_action_enum_t rw, xed_operand_enum_t xed_operand, UINT xed_operand_index, UINT &nr, UINT &nw)
LOCALFUN UINT find_or_bump_pos_write (INS ins, const xed_operand_enum_t xed_operand, UINT &n)
LOCALFUN UINT find_or_bump_pos_read (INS ins, const xed_operand_enum_t xed_operand, UINT &n)
LOCALFUN VOID XED_update_reg_in_stripe (INS ins, const xed_decoded_inst_t *xedd, const xed_operand_action_enum_t rw, xed_operand_enum_t xed_operand, UINT xed_operand_index, UINT &nr, UINT &nw)
LOCALINLINE BOOL IsMultiSourceOperand (const xed_operand_type_enum_t otype)
LOCALINLINE REG GetBaseVectorReg (const REG reg)
LOCALINLINE REG GetLastVectorReg (const REG reg)
LOCALINLINE UINT32 GetMultiSourceOperandVectorMask (const xed_operand_type_enum_t otype)
LOCALINLINE UINT32 NumOfRegsInMultiSourceOperand (const xed_operand_type_enum_t otype)
LOCALFUN VOID XED_add_multisource_reg_to_stripe (INS ins, const xed_decoded_inst_t *xedd, const xed_operand_type_enum_t otype, xed_operand_enum_t xed_operand, UINT xed_operand_index, UINT &nr)
VOID XED_RegRolePosFromXED (INS ins)
VOID INS_XED_replace_dummy (INS ins, xed_reg_enum_t xedreg, REG pin_virt_reg, xed_operand_enum_t role, UINT xedpos)
VOID XED_log_init ()
LOCALFUN VOID InitJccConvertTable ()
xed_iclass_enum_t JccIclassToCmovcc (INS ins)
PREDICATE_IA32 INS_TestedCondition (INS ins)
LOCALFUN VOID pin_abort_for_xed (const char *msg, const char *file, int line, void *)
VOID XED_init ()
INT32 INS_RawEncodeIns (INS ins, UINT8 *buffer)
UINT32 INS_EncodeIns (INS ins, VOID *buffer)
LOCALFUN VOID ReencodeTest (xed_decoded_inst_t *xedd, UINT orig_len, const UINT8 *bytes, INS ins)
LOCALFUN EXCEPTION_CODE XedError2ExceptionCode (xed_error_enum_t xed_error)
UINT32 INS_OperandCount (INS ins)
UINT32 INS_OperandNameId (INS ins, UINT32 n)
BOOL INS_OperandIsMemory (INS ins, UINT32 n)
REG INS_OperandMemoryBaseReg (INS ins, UINT32 n)
REG INS_OperandMemoryIndexReg (INS ins, UINT32 n)
REG INS_OperandMemorySegmentReg (INS ins, UINT32 n)
UINT32 INS_OperandMemoryScale (INS ins, UINT32 n)
ADDRDELTA INS_OperandMemoryDisplacement (INS ins, UINT32 n)
BOOL INS_OperandIsFixedMemop (INS ins, UINT32 n)
VOID GetNumberAndSizeOfMemAccesses (INS ins, int *numAccesses, int *accessSize, int *indexSize)
UINT32 INS_MemoryOperandCount (INS ins)
BOOL INS_OperandIsAddressGenerator (INS ins, UINT32 n)
BOOL INS_OperandIsBranchDisplacement (INS ins, UINT32 n)
BOOL INS_OperandIsReg (INS ins, UINT32 n)
REG INS_OperandReg (INS ins, UINT32 n)
BOOL INS_OperandIsImmediate (INS ins, UINT32 n)
UINT64 INS_OperandImmediate (INS ins, UINT32 n)
BOOL INS_OperandIsImplicit (INS ins, UINT32 n)
BOOL INS_RegIsImplicit (INS ins, REG reg)
UINT32 INS_OperandWidth (INS ins, UINT32 n)
BOOL INS_OperandRead (INS ins, UINT32 n)
BOOL INS_OperandWritten (INS ins, UINT32 n)
BOOL INS_OperandReadOnly (INS ins, UINT32 n)
BOOL INS_OperandWrittenOnly (INS ins, UINT32 n)
BOOL INS_OperandReadAndWritten (INS ins, UINT32 n)
PIN_DEPRECATED_API BOOL INS_OperandReadAndWriten (INS ins, UINT32 n)
BOOL INS_OperandIsGsOrFsReg (INS ins)
BOOL INS_PrefixIsGsOrFsReg (INS ins)
BOOL INS_MemoryOperandIsRead (INS ins, UINT32 memopIdx)
BOOL INS_MemoryOperandIsWritten (INS ins, UINT32 memopIdx)
UINT32 INS_MemoryOperandIndexToOperandIndex (INS ins, UINT32 memopIdx)
BOOL REGSET_Contains (const REGSET &regset, REG reg)
VOID REGSET_Insert (REGSET &regset, REG reg)
VOID REGSET_Remove (REGSET &regset, REG reg)
VOID REGSET_Clear (REGSET &regset)
VOID REGSET_AddAll (REGSET &regset)
REG REGSET_PopNext (REGSET &regset)
UINT32 REGSET_PopCount (const REGSET &regset)
BOOL REGSET_PopCountIsZero (const REGSET &regset)
string REGSET_StringShort (const REGSET &regset)
string REGSET_StringList (const REGSET &regset)
UINT32 REGSET_HashKey (const REGSET &regset)
BOOL REGSET_CONTEXT_Contains (const REGSET_CONTEXT regset, REG reg)
VOID REGSET_CONTEXT_Insert (REGSET_CONTEXT &regset, REG reg)
VOID REGSET_CONTEXT_Remove (REGSET_CONTEXT &regset, REG reg)
VOID REGSET_CONTEXT_Clear (REGSET_CONTEXT &regset)
REG REGSET_CONTEXT_PopNext (REGSET_CONTEXT &regset)
UINT32 REGSET_CONTEXT_PopCount (const REGSET_CONTEXT &regset)
BOOL REGSET_CONTEXT_PopCountIsZero (const REGSET_CONTEXT &regset)
string REGSET_CONTEXT_StringShort (const REGSET_CONTEXT &regset)
string REGSET_CONTEXT_StringList (const REGSET &regset)
LOCALINLINE VOID SetX87Bit (FPSTATE *fpstate)
LOCALINLINE VOID SetSseBit (FPSTATE *fpstate)
LOCALINLINE VOID SetAvxBit (FPSTATE *fpstate)
LOCALINLINE VOID SetOpmaskBit (FPSTATE *fpstate)
LOCALINLINE VOID SetZmmHi256Bit (FPSTATE *fpstate)
VOID REG_StoreXmmToFxsave (const REG xmm, const REGVALUE128 &val, FPSTATE *fpstate)
VOID REG_StoreXmmToFxsave (const REG xmm, const VOID *val, FPSTATE *fpstate)
VOID REG_StoreYmmToFxsave (const REG ymm, const REGVALUE256 &val, FPSTATE *fpstate)
VOID REG_StoreYmmToFxsave (const REG ymm, const VOID *val, FPSTATE *fpstate)
VOID REG_StoreZmmToFxsave (const REG zmm, const REGVALUE512 &val, FPSTATE *fpstate)
VOID REG_StoreZmmToFxsave (const REG zmm, const VOID *val, FPSTATE *fpstate)
VOID REG_StoreKMaskToFxsave (const REG kmask, const UINT64 &val, FPSTATE *fpstate)
const REGVALUE128 & REG_ReadXmmFromFxsave (const REG xmm, const FPSTATE *fpstate)
VOID REG_ReadXmmFromFxsave (const REG xmm, const FPSTATE *fpstate, VOID *val)
VOID REG_ReadYmmFromFxsave (const REG ymm, const FPSTATE *fpstate, VOID *val)
REGVALUE256 REG_ReadYmmFromFxsave (const REG ymm, const FPSTATE *fpstate)
VOID REG_ReadZmmFromFxsave (const REG zmm, const FPSTATE *fpstate, VOID *val)
const REGVALUE512 REG_ReadZmmFromFxsave (const REG zmm, const FPSTATE *fpstate)
const UINT64 & REG_ReadKMaskFromFxsave (const REG kmask, const FPSTATE *fpstate)
VOID REG_StoreShortFpToFxsave (REG reg, const REGVALUE val, FXSAVE *fxsave)
VOID REG_StoreShortFpToFpstate (REG reg, const REGVALUE val, FPSTATE *fpstate)
REGVALUE REG_ReadShortFpFromFxsave (REG reg, const FXSAVE *fxsave)
REGVALUE REG_ReadShortFpFromFpstate (REG reg, const FPSTATE *fpstate)
VOID REG_StoreStToFxsave (REG reg, const VOID *val, FXSAVE *fxsave)
VOID REG_StoreStToFpstate (REG reg, const VOID *val, FPSTATE *fpstate)
VOID REG_StoreStToFxsave (REG reg, const REGVALUE128 &val, FXSAVE *fxsave)
VOID REG_StoreStToFpstate (REG reg, const REGVALUE128 &val, FPSTATE *fpstate)
VOID REG_ReadStFromFxsave (REG reg, const FXSAVE *fxsave, VOID *val)
VOID REG_ReadStFromFpstate (REG reg, const FPSTATE *fpstate, VOID *val)
const REGVALUE128 & REG_ReadStFromFxsave (REG reg, const FXSAVE *fxsave)
const REGVALUE128 & REG_ReadStFromFpstate (REG reg, const FPSTATE *fpstate)
REGVALUE REG_ReadPseudo (REG reg)
VOID REG_StorePseudo (REG reg, REGVALUE val)
VOID CopyCompFpStateToStandard (ADDRINT compFpState, FPSTATE *standardFpState, UINT64 compMask)
SYSCALL_STANDARD NativeSysCallStd ()
REG REG_SysCallResult (SYSCALL_STANDARD std=NativeSysCallStd())
REG REG_SysCallErrno (SYSCALL_STANDARD std=NativeSysCallStd())
REG REG_SysCallNumber (SYSCALL_STANDARD std=NativeSysCallStd())
UINT32 InvalidSysCallNumber ()
INT32 REG_NumSysCallArgRegs (SYSCALL_STANDARD std=NativeSysCallStd())
REGSET REGSET_SyscalleeSavedGr (SYSCALL_STANDARD std=NativeSysCallStd())
REG REG_SysCallArgReg (INT32 ith_arg, SYSCALL_STANDARD std=NativeSysCallStd())
BOOL GetSysCallArgMem (INT32 ith_arg, MEM_ADDR_EXP *pExp, SYSCALL_STANDARD std=NativeSysCallStd())
LOCALFUN INT32 INT_Immediate (xed_decoded_inst_t *xedd)
BOOL INS_IsSyscall (INS ins)
SYSCALL_STANDARD INS_SyscallStd (INS ins)
LOCALFUN SYSCALL_TYPE INS_SyscallType (INS ins)
BOOL INS_SyscallHasFallThrough (INS ins)
BOOL INS_SyscallIsTakenBranch (INS ins)

Variables

LOCALVAR BBL last_nonreturning_fun = BBL_INVALID()
GLOBALCONST BOOL B_HIDDEN = 1
GLOBALCONST BOOL B_CROSSLINK = 1
GLOBALCONST PIN_DEPRECATED_API
UINT32 
VARIABLE_MEMORY_REFERENCE_SIZE = ~0U
LOCALVAR PINVM::PINSYNC_RWLOCK InsResizeLock
LOCALVAR const SEC_STATE SEC_StateMachineExe []
LOCALVAR const SEC_STATE SEC_StateMachineData []
LOCALVAR const SEC_STATE SEC_StateMachineCooked []
LOCALVAR const SYM_STATE SYM_StateMachine []
LOCALVAR CHAR const * knobfamily = "supported:disassembly"
LOCALVAR xed_syntax_enum_t syntax = XED_SYNTAX_INTEL
GLOBALCONST UINT32 MAX_INSTRUCTION_SIZE = 15
GLOBALCONST USIZE SIZE_OF_RIP_AND_ADDR_PROBE = 14
GLOBALCONST USIZE SIZE_OF_RIP_PROBE = 6
GLOBALCONST USIZE SIZE_OF_MEMOFFSET_PROBE = 7
GLOBALCONST USIZE SIZE_OF_OFFSET_PROBE = 5
LOCALTYPE set< ENCODING_ADDRESS_RANGE_KEY > _dir
LOCALVAR USIZE sizeOfDirectJmp = 0
LOCALVAR USIZE sizeOfIpRelativeMemJmp = 0
GLOBALCONST USIZE INS_PATCH_UNIT = 8
LOCALCONST UINT AUTO_DISP_BYTES = 0
LOCALCONST INT32 DEFAULT_EA_WIDTH = sizeof(VOID*) * 8
LOCALCONST xed_state_t DSTATE
LOCALCONST UINT NATIVE_REG_WIDTH_IN_BITS = GetBitSizeOfRegWidth(REGWIDTH_NATIVE)
LOCALCONST UINT MAX_DUMMY_REGS = 3
LOCALCONST UINT MAX_DUMMY_REG_WIDTHS = 4
LOCALCONST REGWIDTH MAX_DUMMY_REGWIDTH = REGWIDTH_64
LOCALVAR const xed_reg_enum_t dummy_regs_native_table [MAX_DUMMY_REGS]
LOCALVAR const xed_reg_enum_t dummy_regs_width_table [MAX_DUMMY_REGS][MAX_DUMMY_REG_WIDTHS]
struct {
   xed_iclass_enum_t   cmovOp
   xed_iclass_enum_t   setOp
   xed_iclass_enum_t   _cmov
   xed_iclass_enum_t   _brinv
   PREDICATE_IA32   _condition
predicateToOp []
LOCALVAR string reuserTypeStr []
LOCALVAR BOOL xed_decode_log
LOCALVAR BOOL xed_encode_log
GLOBALCONST UINT32 MAX_XED_REG_TO_PIN_REG = XED_REG_LAST
GLOBALCONST UINT32 MAX_PIN_REG_TO_XED_REG = REG_MACHINE_LAST+1
LOCALVAR REG xed_reg_to_pin_reg_exact [MAX_XED_REG_TO_PIN_REG]
LOCALVAR xed_reg_enum_t pin_reg_to_xed_reg_exact [MAX_PIN_REG_TO_XED_REG]
struct {
   xed_iclass_enum_t   cmovOp
   xed_iclass_enum_t   setOp
   xed_iclass_enum_t   _cmov
   xed_iclass_enum_t   _brinv
   PREDICATE_IA32   _condition
JccToCMOVcc [XED_ICLASS_LAST]
GLOBALCONST REG REG_FirstInRegset = REG_RBASE
GLOBALCONST REG REG_LastInRegset = REG(REG_LAST-1)
GLOBALCONST REG REG_FirstInRegsetPhyContext = REG_PHYSICAL_INTEGER_BASE
GLOBALCONST REG REG_LastInRegsetPhyContext = REG_PHYSICAL_INTEGER_END
const REGSET REGSET_NONE
const REGSET_CONTEXT REGSET_CONTEXT_NONE
const FAST_REGSET FAST_REGSET_NONE


Detailed Description

This file contains APP primitives


Typedef Documentation

typedef EXT* LEVEL_CORE::EXTLIST
 

This is a handle for a list of EXT. This is useful if you don't have a container to hold them (e.g. INS, BBL, ...)

typedef class FAST_REGISTER_SET< REG_FirstInRegset, REG_LastInRegset > LEVEL_CORE::FAST_REGSET
 

A regset type that contains all registers

typedef size_t(* LEVEL_CORE::INS_BYTES_FETCHER)(VOID *buf, const VOID *insAddr, size_t size, EXCEPTION_INFO *pExceptInfo)
 

Prototype of a function that reads raw bytes of an instruction to be decoded.

Note:
The INS_BYTES_FETCHER type is an example of a generic type <T> that provides the following function-call operator: size_t T::operator() (VOID *buf, const VOID *insAddr, size_t size, EXCEPTION_INFO *pExceptInfo) const; We will use the term "INS_BYTES_FETCHER functor" to denote types that provide this operator.
Parameters:
[out] buf A buffer which receives the instruction bytes. This buffer is at least size bytes long.
[in] insAddr Address of the first instruction's byte to be read.
[in] size The number of bytes to be read
[out] pExceptInfo If less than size bytes are fetched, pExceptInfo receives an exception that describes why more bytes could not be fetched. If Pin needs more bytes to decode the next instruction, this exception will be delivered to the application.
Returns:
The number of bytes successfully fetched into the buffer.

typedef ADDRINT LEVEL_CORE::INS_REUSER_HANDLE
 

opaque type of INS_REUSER passed to client of ins_reuse_ia32.cpp as handle

typedef vector<ADDRINT> LEVEL_CORE::INS_REUSER_ID_VEC
 

The contents of this vector uniquely identify the INS within an INS_REUSER_TYPE. This vector will hold the values of the third and following parameters of the *GetCopy function.

typedef ADDRINT LEVEL_CORE::INS_REUSER_STORE_HANDLE
 

opaque type

typedef class INDEX< 202 > LEVEL_CORE::PREG
 

Type that represents a physical register. Note the difference: PREG is a physical register REG is a virtual register

typedef class REGISTER_SET< REG_FirstInRegsetPhyContext, REG_LastInRegsetPhyContext > LEVEL_CORE::REGSET_CONTEXT
 

A regset type that contains registers in the physical context

typedef class ADDR< 200 > LEVEL_CORE::REGVALUE
 

Type that represents a value of an ADDRINT-size register


Enumeration Type Documentation

enum LEVEL_CORE::BBL_STATE
 

bbl state enumeration - not used

enum LEVEL_CORE::BBL_TYPE
 

BBL types enumeration

Enumerator:
BBL_TYPE_INVALID  illegal type, to indicate unknown type use BBL_TYPE_UNKNOWN instead
BBL_TYPE_UBREAK  break (no go)
BBL_TYPE_CBREAK  conditional break
BBL_TYPE_STOP  stop (no go)
BBL_TYPE_UCALL_UNKNOWN  (indirect) call to unknown target
BBL_TYPE_UCALL_FUN  call to known target
BBL_TYPE_UCALL_OS  os call
BBL_TYPE_CCALL_OS  conditional os call
BBL_TYPE_CCALL_UNKNOWN  conditonal (indirect) call to unknown target
BBL_TYPE_CCALL_FUN  conditonal call to known target
BBL_TYPE_NORMAL  fallthrough bbl
BBL_TYPE_CBRANCH  conditional branch
BBL_TYPE_UBRANCH  unconditional branch
BBL_TYPE_COUNTED  conditional branch (counted)
BBL_TYPE_SWPIPELINED  conditional branch (counted,register rotation)
BBL_TYPE_CHECK  check
BBL_TYPE_PREFETCH  prefetch
BBL_TYPE_UJUMP  jump
BBL_TYPE_UJUMP_DYNLINK  jump into the dynamic linker (in .plt)
BBL_TYPE_UJUMP_THUNK  call of dynamically linked code
BBL_TYPE_UJUMP_TRAMPOLINE  jump through a trampoline
BBL_TYPE_UBRANCH_TRAMPOLINE  jump through a trampoline
BBL_TYPE_CJUMP  conditional jump
BBL_TYPE_CJUMP_SWITCH  conditional jump
BBL_TYPE_STUB  jump bbl that implements a shared lib stub
BBL_TYPE_URETURN  return
BBL_TYPE_CRETURN  conditional return
BBL_TYPE_DATA  data -- NB: data entries must be contiguous. see BBL_IsData
BBL_TYPE_DATA_IADDR  data -- pin IADDR for ip relative branch on the Intel(R) 64 architecture
BBL_TYPE_DATA_ARGBLOCK  data -- pin argument block for VM
BBL_TYPE_DATA_SWITCH1  data
BBL_TYPE_DATA_UNWIND  data -- unwind data of type UNWIND_INFO linked to portion of code in RTN
BBL_TYPE_DATA_LAST  data
BBL_TYPE_CONTAINER  initial container
BBL_TYPE_UNKNOWN  unknown type
BBL_TYPE_VMSVC  vm service request
BBL_TYPE_IBRANCH_LOOKUP  indirect branch lookup code
BBL_TYPE_EMU_FT  invoke pin emulator on instruction with a fall through path
BBL_TYPE_UCALL_NATIVE_TARGET  bbl generated by SetNativeTarget

enum LEVEL_CORE::CALLING_STANDARD
 

Names of calling standards Following names in Agner Fog's document

enum LEVEL_CORE::CHUNK_STATE
 

CHUNK state, to be used for consitency checking

enum LEVEL_CORE::CHUNK_TYPE
 

CHUNK types

enum LEVEL_CORE::EDG_STATE
 

EDG state enumeration - not used

enum LEVEL_CORE::EDG_TYPE
 

EDG type enumeration

Enumerator:
EDG_TYPE_INVALID  illegal type,
EDG_TYPE_RETURN  return edge (not used)
EDG_TYPE_CALL  call edge (callsite -> callee)
EDG_TYPE_LINK  link edge (callsite->returnsite)
EDG_TYPE_COMP  compensation edge (not used)
EDG_TYPE_FALSE  generic fall through edge (predicated)
EDG_TYPE_BRANCH  branch edge
EDG_TYPE_SWITCH  switch edge
EDG_TYPE_PREFETCH  prefetch edge
EDG_TYPE_EXCEPTION  EH edge (callsite -> landing pad ).
EDG_TYPE_NORMAL  fall through edge (not predicated)
EDG_TYPE_IBRANCH  indirect branch (lookup -> target)

enum LEVEL_CORE::EXT_ATTR_MODE
 

EXT attribute mode

Enumerator:
EXT_ATTR_MODE_SINGLE  attribute can only occure once
EXT_ATTR_MODE_MULTIPLE  attribute can occure multiple times

enum LEVEL_CORE::FLAGS
 

Enumeration type for individual flags

enum LEVEL_CORE::FUNCTION_TYPE
 

Function type is a description of the types of the arguments and return value. Function type + calling standard determines the argument location. This is a placeholder; the real function type cannot be an enumeration, probably use an array of arguments types + return type.

enum LEVEL_CORE::IMG_STATE
 

not used

enum LEVEL_CORE::INS_REUSER_TYPE
 

These are the types of INSs maintained for use in generating new INSs. In ins_initis_api_xed_ia32.cpp there is an a INS_Init* function which implicitly uses the corresponding type when calling the *GetCopy function defined in this file. For each INS_REUSER_TYPE_* there can be multiple INSs recorded - according to values specified by the third and following parameters to the *GetCopy function.

enum LEVEL_CORE::REL_TYPE
 

Relocation types

Enumerator:
REL_TYPE_CHUNK_ABS32  32-bit value in the chunk
REL_TYPE_CHUNK_ABS64  64-bit value in the chunk
REL_TYPE_INS_PCREL  PC-relative operand.
REL_TYPE_INS_IA32IMM  "immediate" operand of an ia32 instruction

enum LEVEL_CORE::RTN_STATE
 

not used

enum LEVEL_CORE::RTN_TYPE
 

RTN type

enum LEVEL_CORE::SACT_TYPE
 

x

Enumerator:
SACT_VERSION  Applies to this bbl and successor.
SACT_TARGET_VERSION  Applies to bbl that is branch target.

enum LEVEL_CORE::SEC_STATE
 

SEC state, used for consitency checking

enum LEVEL_CORE::SEGMENT_TYPE
 

SEC Each elf program header describes a segment, which may contain multiple sections

Enumerator:
SEGMENT_TYPE_TEXT  text segment
SEGMENT_TYPE_DATA  initialized data segment
SEGMENT_TYPE_BSS  uninitialized data segment

enum LEVEL_CORE::SYM_IFUNC_TYPE
 

Symbols Ifunc type indicates about the symbol role in resolving ifunc.

enum LEVEL_CORE::SYM_STATE
 

used for consistency checking

enum LEVEL_CORE::SYSCALL_TYPE
 

enum describing how the system call is delivered to the kernel. these values are also used is baresyscall assembly file (on mac), modifications should be done in both places.

Enumerator:
SYSCALL_TYPE_NONE  not a system call
SYSCALL_TYPE_SYSCALL  system call delivered via syscall
OS_SYSCALL_TYPE_SYSENTER  system call delivered via sysenter
SYSCALL_TYPE_FARCALL  system call delivered via far call (lcall)
OS_SYSCALL_TYPE_INT80  system call delivered via int 0x80
OS_SYSCALL_TYPE_INT81  system call delivered via int 0x81
OS_SYSCALL_TYPE_INT82  system call delivered via int 0x82
OS_SYSCALL_TYPE_INT83  system call delivered via int 0x83

enum LEVEL_CORE::VAL_TYPE
 

VAL types


Function Documentation

VOID LEVEL_CORE::AddBranchEdgeToBbl BBL  bbl,
BBL  target_bbl,
INS  branch,
EDG_TYPE  type
 

Add a branch edge from bbl to target_bbl. The edge will have type EDG_TYPE type ==================================================================

VOID LEVEL_CORE::AddFallthruEdgeToBbl BBL  bbl,
BBL  target_bbl,
EDG_TYPE  type
 

Add a fallthru edge from bbl to target_bbl. The edge will have type EDG_TYPE type ==================================================================

APP LEVEL_CORE::APP_Alloc  ) 
 

Allocate new APP, some initialization

BOOL LEVEL_CORE::APP_allocated APP  x  ) 
 

APP object is allocated

VOID LEVEL_CORE::APP_Free APP  app  ) 
 

Free APP - must be unlinked and not contain any other objects

VOID LEVEL_CORE::APP_GarbageCollect  ) 
 

APP garbage collector, currently not used

APP LEVEL_CORE::APP_INVALID  ) 
 

returns an invalid APP object

INT32 LEVEL_CORE::APP_no APP  x  ) 
 

return unique number of APP object

BOOL LEVEL_CORE::APP_valid APP  x  ) 
 

test validity of APP object

ARRAYBASE LEVEL_CORE::AppArrayBase "app pool"  ,
1024 
 

The root for all APP stripes

STRIPE<APP_STRUCT_BASE> LEVEL_CORE::AppStripeBase "app stripe base"  ,
"core"  ,
AppArrayBase
 

The base stripe for APP

const ATTRIBUTE LEVEL_CORE::ATTR_bbl_dynsym "dyn"  ,
"sym"  ,
"bbl_dynsym"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_SYM  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold dynamic SYMs that have this BBL as value

const ATTRIBUTE LEVEL_CORE::ATTR_bbl_regsym "reg"  ,
"sym"  ,
"bbl_regsym"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_SYM  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold SYMs regular that have this BBL as value FIXME: upon deletion of this bbl the symbol value should be set to zero (the last crosslink parameter should be set)

const ATTRIBUTE LEVEL_CORE::ATTR_bbl_rel "rel"  ,
"rel"  ,
"bbl_rel"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_REL  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold RELs that have this BBL as value

const ATTRIBUTE LEVEL_CORE::ATTR_chunk_dynsym "dyn"  ,
"sym"  ,
"chunk_dynsym"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_SYM  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold dynamic SYMs that have this BBL as value

const ATTRIBUTE LEVEL_CORE::ATTR_chunk_regsym "reg"  ,
"sym"  ,
"chunk_regsym"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_SYM  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold SYMs regular that have this BBL as value FIXME: upon deletion of this bbl the symbol value should be set to zero (the last crosslink parameter should be set)

const ATTRIBUTE LEVEL_CORE::ATTR_chunk_rel "rel"  ,
"rel"  ,
"chunk_rel"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_REL  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold RELs that have this CHUNKS as value

const ATTRIBUTE LEVEL_CORE::ATTR_ins_delete "ins_delete"  ,
"inst"  ,
"ins_delete"  ,
EXT_ATTR_MODE_SINGLE  ,
VAL_TYPE_NONE  ,
FALSE  ,
FALSE  ,
"Delete instruction" 
 

x

const ATTRIBUTE LEVEL_CORE::ATTR_ins_rel "rel"  ,
"rel"  ,
"ins_rel"  ,
EXT_ATTR_MODE_MULTIPLE  ,
VAL_TYPE_REL  ,
B_CROSSLINK  ,
FALSE  ,
"" 
 

attribute to hold RELs that have this INS as value

const ATTRIBUTE LEVEL_CORE::AttrComment "comment:"  ,
"core"  ,
"comment"  ,
EXT_ATTR_MODE_SINGLE  ,
VAL_TYPE_STRING  ,
FALSE  ,
FALSE  ,
"comment" 
 

Attribute for attaching comments to data structures

VOID LEVEL_CORE::BBL_AddLinkEdge BBL  bbl,
INS  call
 

Add a link edge to a call BBL

BBL LEVEL_CORE::BBL_Alloc  ) 
 

Allocate new BBL, some initialization

UINT32 LEVEL_CORE::BBL_AllowableSuccEdgCount BBL  bbl,
UINT32  max
 

verify that number of successor EDGs is compatible with originating BBL type

VOID LEVEL_CORE::BBL_Append BBL  bbl,
RTN  parent
 

Append a BBL to RTN

UINT32 LEVEL_CORE::BBL_ByteSize BBL  bbl  ) 
 

size of a bbl in bytes

BOOL LEVEL_CORE::BBL_CanBeEntryPoint BBL  bbl,
BOOL  switch_ok
 

Check whether BBL can be routine entry point

VOID LEVEL_CORE::BBL_Check BBL  bbl  ) 
 

check consistency

VOID LEVEL_CORE::BBL_CheckFree  ) 
 

ASSERT if an BBL has not been freed. This function is expensive so it cannot be called for normal runs.

BOOL LEVEL_CORE::BBL_CheckSuccEdgType BBL  bbl,
EDG_TYPE  et
 

verify that successor EDG is compatible with originating BBL type

BBL LEVEL_CORE::BBL_Clone BBL  bbl  ) 
 

Make an exact copy of all the instructions in a bbl and return the bbl

BOOL LEVEL_CORE::BBL_ContainsCall BBL  bbl  ) 
 

Check whether BBL is call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsConditionalCall BBL  bbl  ) 
 

Check whether BBL is conditional call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsConditionalControlTransfer BBL  bbl  ) 
 

Check whether BBL is conditional call/branch (based on outgoing EDG info) equivalent to a BBL having an outgoing FALSE edge

BOOL LEVEL_CORE::BBL_ContainsDirectCall BBL  bbl  ) 
 

Check whether BBL is a direct call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsDirectControlTransfer BBL  bbl  ) 
 

BOOL LEVEL_CORE::BBL_ContainsIndirectCall BBL  bbl  ) 
 

Check whether BBL is indirect call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsIndirectControlTransfer BBL  bbl  ) 
 

BOOL LEVEL_CORE::BBL_ContainsReturn BBL  bbl  ) 
 

Check whether BBL is a return (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsUnconditionalCall BBL  bbl  ) 
 

Check whether BBL is unconditional call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsUnresolvedIndirectJump BBL  bbl  ) 
 

Check whether BBL has indirect jumps to unknown locations, i.e. not a switch and not a return - this may not be 100% accurate (based on BBL_TYPE)

CHUNK LEVEL_CORE::BBL_DataChunk BBL  bbl  ) 
 

return data CHUNK associated with a data BBL

VOID LEVEL_CORE::BBL_DataLinkWithChunk BBL  bbl,
CHUNK  chunk
 

cross link a data bbl with a data chunck

VOID LEVEL_CORE::BBL_DataUnlinkChunk BBL  bbl  ) 
 

unlink a data bbl and the corresponding data chunk

VOID LEVEL_CORE::BBL_DeleteIns BBL  bbl  ) 
 

delete all the instructions in a basic block

VOID LEVEL_CORE::BBL_ExtAppend EXT  ext,
BBL  parent
 

VOID LEVEL_CORE::BBL_ExtInsertAfter EXT  ext,
EXT  after,
BBL  parent
 

VOID LEVEL_CORE::BBL_ExtPrepend EXT  ext,
BBL  parent
 

VOID LEVEL_CORE::BBL_Free BBL  bbl  ) 
 

Free BBL - must be unlinked and not contain any other objects

VOID LEVEL_CORE::BBL_FreeContents BBL  bbl  ) 
 

Unlink the contents of a code bbl. Does not ulink or free the BBL itself

VOID LEVEL_CORE::BBL_FreePredEdges BBL  bbl  ) 
 

Free the predecessor edges of the bbl

VOID LEVEL_CORE::BBL_FreeSuccEdges BBL  bbl  ) 
 

Free the successor edges of the bbl

VOID LEVEL_CORE::BBL_GarbageCollect  ) 
 

BBL garbage collector, currently not used

string LEVEL_CORE::BBL_generateDotCFG BBL  bbl  ) 
 

Generate the string describing the CFG rooted at this BBL as a dot graph, suitable for feeding into dot to draw it.

Parameters:
[in] bbl - Root of the CFG tree.
Returns:
Return a string which is a dot representation of the CFG.

OADDR LEVEL_CORE::BBL_GetOaddr BBL  target  ) 
 

get BBL OADDR (based on pos stripe)

BOOL LEVEL_CORE::BBL_HasUnmodeledPredEdges BBL  bbl,
BOOL  switch_ok
 

Has unknown incoming flow which is not modeled by edges if switch_ok is true: relocations stemming from switch tables are ignored

BOOL LEVEL_CORE::BBL_HasUnmodeledSuccEdges BBL  bbl  ) 
 

Check whether BBL has ougoing flow not modeled by EDGs (based on BBL_TYPE)

VOID LEVEL_CORE::BBL_InitOriginal BBL  bbl  ) 
 

initialize a BBL as an original bbl, an original BBL is a BBL that existed in the incoming image as opposed to a BBL that was generated by optimizations

VOID LEVEL_CORE::BBL_InsertAfter BBL  bbl,
BBL  after,
RTN  parent
 

Insert BBL after another BBL within an RTN

Parameters:
bbl block to be inserted after
after block to insert after, if BBL_INVALID, prepend to parent
parent rtn that contains after bbl

VOID LEVEL_CORE::BBL_InsertBefore BBL  bbl,
BBL  before,
RTN  parent
 

Insert BBL before another BBL within an RTN

BOOL LEVEL_CORE::BBL_IsCycle BBL  bbl  ) 
 

Test whether a bbl is part of a single BBL loop

BOOL LEVEL_CORE::BBL_IsImageEntryPoint BBL  bbl  ) 
 

Test whether BBL carries a special marker identifying it as the entry point

BOOL LEVEL_CORE::BBL_IsReturnSite BBL  bbl  ) 
 

Check whether BBL is return site (based on incoming EDG info)

BOOL LEVEL_CORE::BBL_MarkBblStarts BBL  containerBbl  ) 
 

Marks all the instructions in a container bbl that are bbl terminating instructions and returns false if no marks were set to indicate that the container bbl has to be split

VOID LEVEL_CORE::BBL_MoveInsToAfter const BBL  src,
const BBL  dst,
INS  after
 

Move all inss from src to dst following "after"

VOID LEVEL_CORE::BBL_MoveInsToBefore const BBL  src,
const BBL  dst,
INS  before
 

Move all inss from src to dst preceeding "before"

UINT32 LEVEL_CORE::BBL_NumAttrCrosslink BBL  bbl  ) 
 

if a bbl has any of these atributes it cannot be freed

LOCALFUN UINT32 LEVEL_CORE::BBL_NumAttrRegsym BBL  bbl  ) 
 

Number of RELs and other data structures that point to a BBL. If the number is > 1, this means there is potially additional control flow not modeled by EDGs.

UINT32 LEVEL_CORE::BBL_NumExt BBL  parent  ) 
 

x

UINT32 LEVEL_CORE::BBL_NumPreds BBL  bbl  ) 
 

number of predecessor EDGs

UINT32 LEVEL_CORE::BBL_NumPredsInterproc BBL  bbl  ) 
 

number of predecessor EDGs which originate from a different RTN

UINT32 LEVEL_CORE::BBL_NumPredsInterprocNonCall BBL  bbl  ) 
 

number of predecessor EDGs which originate from a different RTN and which are not calls

UINT32 LEVEL_CORE::BBL_NumSuccs BBL  bbl  ) 
 

number of successor EDGs

EDG LEVEL_CORE::BBL_PredEdgFind BBL  dst,
EDG_TYPE  type
 

find successor EDG based on type

VOID LEVEL_CORE::BBL_Prepend BBL  bbl,
RTN  parent
 

Prepend a BBL to RTN

VOID LEVEL_CORE::BBL_RemoveRegsyms BBL  bbl  ) 
 

Remove crosslinked SYM from BBL

VOID LEVEL_CORE::BBL_SetImageEntryPoint BBL  bbl  ) 
 

add special marked identifying BBL as the entry point

BBL LEVEL_CORE::BBL_SplitAtIns BBL  firstBbl,
INS  splitIns
 

Split the bbl in two at a INS. Does not update EDG

Parameters:
[in] firstBbl - BBL to split
[in] splitIns - Move this INS and all that follow into new bbl
Returns:
Return the new BBL

string LEVEL_CORE::BBL_StringLong BBL  bbl  ) 
 

convert a BBL into a printable string - long version

string LEVEL_CORE::BBL_StringLongFancy BBL  bbl  ) 
 

produce string for BBL including INS

string LEVEL_CORE::BBL_StringShort BBL_TYPE  type  ) 
 

convert a BBL type into a printable string - 4 characters

EDG LEVEL_CORE::BBL_SuccEdgFind BBL  src,
BBL  dst
 

find successor EDG based on traget BBL

EDG LEVEL_CORE::BBL_SuccEdgFind BBL  src,
EDG_TYPE  type
 

find successor EDG based on type

EDG LEVEL_CORE::BBL_SuccEdgFindPcRelative BBL  bbl  ) 
 

find successor EDG based on traget BBL

EDG LEVEL_CORE::BBL_SuccEdgFindWithType BBL  src,
BBL  dst,
EDG_TYPE  type
 

find successor EDG based on traget BBL

BBL_TYPE LEVEL_CORE::BBL_TYPE_Unconditionalize BBL_TYPE  type  ) 
 

transform a conditional BBL_TYPE in the corresponding unconditional type

VOID LEVEL_CORE::BBL_TypeSet BBL  bbl,
BBL_TYPE  type
 

change BBL type with extra sanity checks

VOID LEVEL_CORE::BBL_TypifyAndCreateEdgs SEC  sec,
BBL  bbl
 

Set initial type and outgoing edges for bbl. We have to pass in the sec parameter as well to look up branch targets TODO: Do we need to duplicate this function?

VOID LEVEL_CORE::BBL_TypifyAndCreateEdgsFromBblToBbl BBL  src_bbl,
BBL  dst_bbl
 

Set initial type and outgoing edges for a given source bbl to a given destination bbl

BBL LEVEL_CORE::BBL_UniquePredecessor BBL  bbl  ) 
 

return unique predecessor BBL if it exists or BBL_INVALID() otherwise

VOID LEVEL_CORE::BBL_Unlink BBL  bbl  ) 
 

Unlink a BBL from an RTN

VOID LEVEL_CORE::BBL_UnlinkFreeCode BBL  bbl  ) 
 

unlink and free non-data BBL, also unlink free all other objects contained in it

VOID LEVEL_CORE::BBL_UnlinkFreeData BBL  bbl  ) 
 

unlink and free data BBL, also unlink free all other objects contained in it

ARRAYBASE LEVEL_CORE::BblArrayBase "bbl pool"  ,
1024 *  1024
 

The root for all BBL stripes

STRIPE<BBL_STRUCT_BASE> LEVEL_CORE::BblStripeBase "bbl stripe base"  ,
"core"  ,
BblArrayBase
 

The base stripe for BBL

STRIPE<BBL_STRUCT_MAP> LEVEL_CORE::BblStripeMap "bbl stripe map "  ,
"map"  ,
BblArrayBase
 

The map stripe for BBL used to hold information reflecting the out address of the BBL

UINT32 LEVEL_CORE::CallingStd_DefaultArgSize CALLING_STANDARD  cstype  ) 
 

Return a string for the calling standard.

string LEVEL_CORE::CallingStd_String CALLING_STANDARD  cstype  ) 
 

Return a string for the calling standard.

VOID LEVEL_CORE::CheckAll  ) 
 

perform sanity checks on all basic charm objects ever allocated

BOOL LEVEL_CORE::CheckFree  ) 
 

ASSERT if an object has not been freed. This function is expensive so it cannot be called for normal runs.

CHUNK LEVEL_CORE::CHUNK_Alloc  ) 
 

Allocate a new CHUNK and clear some of its fields. FIXME: fields clearing needs to be more extensive

VOID LEVEL_CORE::CHUNK_Append CHUNK  chunk,
SEC  parent
 

append a CHUNK to SEC

USIZE LEVEL_CORE::CHUNK_AppendData CHUNK  chunk,
USIZE  num_bytes
 

allocate extra region at the end of an uncooked SEC and return region start as an offset from the section beginning do not deallocate the old data since someone might be pointing there (string tables).

VOID LEVEL_CORE::CHUNK_ApplyRels CHUNK  chunk  ) 
 

x

VOID LEVEL_CORE::CHUNK_Check CHUNK  chunk  ) 
 

perform sanity checking for given CHUNK

BOOL LEVEL_CORE::CHUNK_ContainsIaddr CHUNK  chunk,
IADDR  iaddr
 

Test whether a CHUNK's virtual address space includes an IADDR

BOOL LEVEL_CORE::CHUNK_ContainsIaddrEndInclusive CHUNK  chunk,
IADDR  iaddr
 

get a piece of data directly from the incoming CHUNK data

BOOL LEVEL_CORE::CHUNK_ContainsOaddr CHUNK  chunk,
OADDR  oaddr
 

Test whether a CHUNK's outgoing virtual address space includes an OADDR

BOOL LEVEL_CORE::CHUNK_ContainsOaddrEndInclusive CHUNK  chunk,
OADDR  oaddr
 

Test whether a CHUNK's outgoing virtual address space includes an OADDR

VOID LEVEL_CORE::CHUNK_ExtInsertAfter EXT  ext,
EXT  after,
CHUNK  parent
 

VOID LEVEL_CORE::CHUNK_ExtPrepend EXT  ext,
CHUNK  parent
 

REL LEVEL_CORE::CHUNK_FindRelForOffset CHUNK  chunk,
UINT32  offset
 

Find REL targeting a given CHUNK and offset, return REL_INVALID() if none can be found

VOID LEVEL_CORE::CHUNK_Free CHUNK  chunk  ) 
 

Free chunk object

VOID LEVEL_CORE::CHUNK_GarbageCollect  ) 
 

The not yet implemented CHUNK garbage collector. It is supposed to add all unallocated CHUNKs to the CHUNK freelist

UINT32 LEVEL_CORE::CHUNK_GetIDataByOffsetUINT32 CHUNK  chunk,
USIZE  offset
 

get a piece of data directly from the incoming CHUNK data

UINT64 LEVEL_CORE::CHUNK_GetIDataByOffsetUINT64 CHUNK  chunk,
USIZE  offset
 

get a piece of data directly from the incoming CHUNK data

UINT32 LEVEL_CORE::CHUNK_GetUnalignedIDataByOffsetUINT32 CHUNK  chunk,
USIZE  offset
 

get an unaligned piece of data directly from the incoming CHUNK data

UINT32 LEVEL_CORE::CHUNK_GetUnalignedIDataByOffsetUINT64 CHUNK  chunk,
USIZE  offset
 

get an unaligned piece of data directly from the incoming CHUNK data

VOID LEVEL_CORE::CHUNK_InitOriginal CHUNK  chunk,
CHUNK_TYPE  type,
IADDR  vaddr,
USIZE  size,
const VOID *  data,
UINT32  alignment
 

initialize an original CHUNK after is has been allocated. An original CHUNK is one the corresponds to a Section in the input Image.

VOID LEVEL_CORE::CHUNK_InsertAfter CHUNK  chunk,
CHUNK  after,
SEC  parent
 

insert CHUNK after another chunk within an SEC

VOID LEVEL_CORE::CHUNK_InsertBefore CHUNK  chunk,
CHUNK  before,
SEC  parent
 

insert CHUNK before another chunk within an SEC

UINT32 LEVEL_CORE::CHUNK_NumExt CHUNK  parent  ) 
 

x

VOID LEVEL_CORE::CHUNK_Prepend CHUNK  chunk,
SEC  parent
 

prepend a CHUNK to SEC

VOID LEVEL_CORE::CHUNK_PutIDataByOffsetUINT32 CHUNK  chunk,
USIZE  offset,
UINT32  value
 

write a piece of data directly do the outgoing CHUNK data

VOID LEVEL_CORE::CHUNK_PutIDataByOffsetUINT64 CHUNK  chunk,
USIZE  offset,
UINT64  value
 

write an unaligned piece of data directly do the outgoing CHUNK data

VOID LEVEL_CORE::CHUNK_PutODataByOffsetUINT32 CHUNK  chunk,
USIZE  offset,
UINT32  value
 

write a piece of data directly to the outgoing CHUNK data

VOID LEVEL_CORE::CHUNK_PutODataByOffsetUINT64 CHUNK  chunk,
USIZE  offset,
UINT64  value
 

write an unaligned piece of data directly to the outgoing CHUNK data

VOID LEVEL_CORE::CHUNK_PutUnalignedIDataByOffsetUINT64 CHUNK  chunk,
USIZE  offset,
UINT64  value
 

write an unaligned piece of data directly do the outgoing CHUNK data

VOID LEVEL_CORE::CHUNK_RemoveRegsyms CHUNK  chunk  ) 
 

Remove crosslinked SYM from CHUNK

VOID LEVEL_CORE::CHUNK_SetNewData CHUNK  chunk,
VOID *  data
 

set CHUNK's new outgoing data, this can be done only once per CHUNK

VOID LEVEL_CORE::CHUNK_SetNewSizeAndAddress CHUNK  chunk,
USIZE  size,
OADDR  oaddr
 

set CHUNK's new outgoing size and address, this can be done only once per CHUNK

VOID LEVEL_CORE::CHUNK_SplitData CHUNK  chunk,
UINT32  offset
 

This is rather ugly and could be avoided by proper meta symbols emited by the tool chain.

string LEVEL_CORE::CHUNK_StringLong CHUNK  chunk  ) 
 

convert a CHUNK into a printable string - short version (no newline)

string LEVEL_CORE::CHUNK_StringShort CHUNK  chunk  ) 
 

convert a CHUNK into a printable string - short version (no newline)

VOID LEVEL_CORE::CHUNK_Unlink CHUNK  chunk  ) 
 

unlink a CHUNK from an IMG

ARRAYBASE LEVEL_CORE::ChunkArrayBase "chunk pool"  ,
128 *  1024
 

The root for all CHUNK stripes

STRIPE<CHUNK_STRUCT_BASE> LEVEL_CORE::ChunkStripeBase "chunk stripe base"  ,
"core"  ,
ChunkArrayBase
 

The base stripe for CHUNK

VOID LEVEL_CORE::CopyCompFpStateToStandard ADDRINT  compFpState,
FPSTATE *  standardFpState,
UINT64  compMask
 

Function to generate standard fpState from compacted fpState using the compacted mask.

Parameters:
[in] compFpState Base pointer of the compacted XSAVE Area.
[out] standardFpState Pointer of the Output FpState.
[in] compMask Compacted mask of the supported bits.

VOID* LEVEL_CORE::CopyImageLoaderInfo VOID *  arg  ) 
 

Copy image loader info used for PINADX debugger to PIN managed buffer

BOOL LEVEL_CORE::DoFlagsSplit  ) 
 

Returns:
if the flags splitting should be done

VOID LEVEL_CORE::DYNSYM_Unlink SYM  sym  ) 
 

unlink a SYM from an IMG

EDG LEVEL_CORE::EDG_Alloc  ) 
 

allocate an EDG, it is not recommended to call this directly

EDG LEVEL_CORE::EDG_AllocAndLink BBL  src,
BBL  dst,
EDG_TYPE  type
 

allocate and link an EDG to the two specified BBLS

VOID LEVEL_CORE::EDG_ExtInsertAfter EXT  ext,
EXT  after,
EDG  parent
 

VOID LEVEL_CORE::EDG_ExtPrepend EXT  ext,
EDG  parent
 

VOID LEVEL_CORE::EDG_Free EDG  edg  ) 
 

deallocate unlinked EDG

VOID LEVEL_CORE::EDG_GarbageCollect  ) 
 

EDG garbage colletor

BOOL LEVEL_CORE::EDG_InterProcedural EDG  e  ) 
 

determing whether EDG is interprocedural. call EDGs are always considered to be interprocedural

BOOL LEVEL_CORE::EDG_IsFallthrough EDG  edg  ) 
 

Determing whether an EDG is a fallthru EDG using the type

VOID LEVEL_CORE::EDG_Link EDG  edg,
BBL  src,
BBL  dst
 

link an EDG to the two specified BBLS

VOID LEVEL_CORE::EDG_MovePredEdges BBL  bbl_from,
BBL  bbl_to
 

Move the predecessor edges from bbl_from to bbl_to

VOID LEVEL_CORE::EDG_MoveSuccEdges BBL  a,
BBL  b
 

Move the successor edges from a to b

UINT32 LEVEL_CORE::EDG_NumExt EDG  parent  ) 
 

x

VOID LEVEL_CORE::EDG_PredInsertAfter EDG  edg,
EDG  after,
BBL  parent
 

Insert predecessor EDG after another such EDG

VOID LEVEL_CORE::EDG_PredPrepend EDG  edg,
BBL  parent
 

Prepend predecessor EDG to list of predecessor EDGs

string LEVEL_CORE::EDG_StringShort EDG  edg  ) 
 

convert a EDG into a printable string - short version

string LEVEL_CORE::EDG_StringShort EDG_TYPE  type  ) 
 

convert a EDG type into a printable string

VOID LEVEL_CORE::EDG_SuccInsertAfter EDG  edg,
EDG  after,
BBL  parent
 

Insert successor EDG after another such EDG

VOID LEVEL_CORE::EDG_SuccPrepend EDG  edg,
BBL  parent
 

Prepend successor EDG to list of predecessor EDGs

VOID LEVEL_CORE::EDG_Unlink EDG  edg  ) 
 

Unlink EDG

LOCALFUN VOID LEVEL_CORE::EDG_UnlinkPred EDG  edg  ) 
 

Unlink EDG from Dst only

VOID LEVEL_CORE::EDG_UnlinkSucc EDG  edg  ) 
 

Unlink EDG from Src only

ARRAYBASE LEVEL_CORE::EdgArrayBase "edg pool"  ,
64 *  1024
 

The root for all EDG stripes

STRIPE<EDG_STRUCT_BASE> LEVEL_CORE::EdgStripeBase "edg stripe base"  ,
"core"  ,
EdgArrayBase
 

The base stripe for REL

EXT LEVEL_CORE::EXT_Alloc  ) 
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblBbl BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
BBL  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblChunk BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
CHUNK  chunk
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblConstPtr BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
const VOID *  ptr
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblFlt64 BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
FLT64  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblGot BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
GOT  got
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblIns BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
INS  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblInt32 BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
INT32  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblNone BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblOpd BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
UINT32  index
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblPltoff BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
UINT32  index
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblRegallochint BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
REG  vreg,
REG  preg,
REGALLOC_HINT_TYPE  hint
 

Link register allocation hint to basic block

EXT LEVEL_CORE::EXT_AllocAndLinkBblRel BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
REL  rel
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblSact BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
SACT  act
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblSym BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
SYM  sym
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkBblUint32 BBL  bbl,
const ATTRIBUTE *  attribute,
UINT32  number,
UINT32  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkChunkGot CHUNK  chunk,
const ATTRIBUTE *  attribute,
UINT32  number,
GOT  got
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkChunkRel CHUNK  chunk,
const ATTRIBUTE *  attribute,
UINT32  number,
REL  rel
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkChunkSym CHUNK  chunk,
const ATTRIBUTE *  attribute,
UINT32  number,
SYM  sym
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkEdgEdg EDG  edg,
const ATTRIBUTE *  attribute,
UINT32  number,
EDG  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkEdgFlt64 EDG  edg,
const ATTRIBUTE *  attribute,
UINT32  number,
FLT64  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsAfunptr INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
AFUNPTR  fptr
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsBbl INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
BBL  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsConstPtr INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
const VOID *  ptr
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsFlt64 INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
FLT64  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsIaddr INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
IADDR  iaddr
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsInt32 INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
INT32  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsNone INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsPtr INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
VOID *  ptr
 

Allocate and initialize an EXT to hold a pointer. Link it to an INS

Returns:
Returns the new EXT

EXT LEVEL_CORE::EXT_AllocAndLinkInsRegallochint INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
REG  vreg,
REG  preg,
REGALLOC_HINT_TYPE  hint
 

Link register allocation hint to instruction

EXT LEVEL_CORE::EXT_AllocAndLinkInsRegInt32 INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
REG  reg,
INT32  use
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsReguse INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
REG  reg,
UINT32  use
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsRel INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
REL  rel
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsSact INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
SACT  act
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsString INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
string *  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsUint32 INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
UINT32  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkInsUint64 INS  ins,
const ATTRIBUTE *  attribute,
UINT32  number,
UINT64  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkRtnBbl RTN  rtn,
const ATTRIBUTE *  attribute,
UINT32  number,
BBL  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkRtnInt32 RTN  rtn,
const ATTRIBUTE *  attribute,
UINT32  number,
int  value
 

x

EXT LEVEL_CORE::EXT_AllocAndLinkRtnSym RTN  rtn,
const ATTRIBUTE *  attribute,
UINT32  number,
SYM  sym
 

x

EXT LEVEL_CORE::EXT_AllocIaddrInt32 const ATTRIBUTE *  attribute,
UINT32  number,
IADDR  iaddr,
INT32  val
 

x

EXT LEVEL_CORE::EXT_AllocInsNone const ATTRIBUTE *  attribute,
UINT32  number
 

x

EXT LEVEL_CORE::EXT_AllocRegInt32 const ATTRIBUTE *  attribute,
UINT32  number,
REG  reg,
INT32  use
 

x

EXT LEVEL_CORE::EXT_AllocVersionCase const ATTRIBUTE *  attribute,
UINT32  number,
REG  reg,
INT32  casev,
ADDRINT  version
 

x

VOID LEVEL_CORE::EXT_BblUnlink EXT  ext,
BBL  parent
 

VOID LEVEL_CORE::EXT_Check EXT  ext  ) 
 

x

VOID LEVEL_CORE::EXT_CheckFree  ) 
 

ASSERT if an EXT has not been freed. This function is expensive so it cannot be called for normal runs.

VOID LEVEL_CORE::EXT_ChunkUnlink EXT  ext,
CHUNK  parent
 

EXT LEVEL_CORE::EXT_Clone EXT  ext  ) 
 

x

VOID LEVEL_CORE::EXT_Copy EXT  ext,
EXT  clone
 

x

VOID LEVEL_CORE::EXT_EdgUnlink EXT  ext,
EDG  parent
 

VOID LEVEL_CORE::EXT_ExtlistUnlink EXT  ext,
EXTLIST  parent
 

EXT LEVEL_CORE::EXT_FindFirst EXT  ext,
const ATTRIBUTE *  attribute
 

x

EXT LEVEL_CORE::EXT_FindNext EXT  ext  ) 
 

x

VOID LEVEL_CORE::EXT_Free EXT  ext  ) 
 

x

VOID LEVEL_CORE::EXT_GarbageCollect  ) 
 

x

VOID LEVEL_CORE::EXT_InsUnlink EXT  ext,
INS  parent
 

string LEVEL_CORE::EXT_ListString EXT  ext  ) 
 

x

VOID LEVEL_CORE::EXT_RtnUnlink EXT  ext,
RTN  parent
 

string LEVEL_CORE::EXT_StringShort EXT  ext,
BOOL  tiny
 

x

ARRAYBASE LEVEL_CORE::ExtArrayBase "ext pool"  ,
32 *  1024
 

x

VOID LEVEL_CORE::EXTLIST_ExtInsertAfter EXT  ext,
EXT  after,
EXTLIST &  parent
 

Insert ext after 'after'

VOID LEVEL_CORE::EXTLIST_ExtPrepend EXT  ext,
EXTLIST &  parent
 

Prepend an EXT to EXTLIST

VOID LEVEL_CORE::EXTLIST_MoveInsExtRev INS  src,
EXTLIST  dst,
const ATTRIBUTE *  attr
 

Move EXT's of a particular attribute to a list with dst as head. The order of the EXT will be reversed.

STRIPE<EXT_STRUCT_BASE> LEVEL_CORE::ExtStripeBase "ext stripe base"  ,
"core"  ,
ExtArrayBase
 

x

FLAGS LEVEL_CORE::FLAGS_And const FLAGS  x,
const FLAGS  y
 

Return the bitwise and of two flags

BOOL LEVEL_CORE::FLAGS_IsSubset const FLAGS  subset,
const FLAGS  superset
 

Return TRUE if "subset" is a subset of "superset"

FLAGS LEVEL_CORE::FLAGS_Or const FLAGS  x,
const FLAGS  y
 

Return the bitwise or of two flags

string LEVEL_CORE::FLAGS_StringShort const FLAGS  x  ) 
 

produce a string for flags

FLAGS LEVEL_CORE::FLAGS_Subtract const FLAGS  x,
const FLAGS  y
 

Return the flags that are in x but not in y

VOID LEVEL_CORE::FreeImageLoaderInfo VOID *  arg  ) 
 

Free image loader info used for PINADX debugger

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_base_reg UINT  i,
REGWIDTH  reg_width
 

x

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_index_reg UINT  i,
REGWIDTH  reg_width
 

x

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_reg UINT  i,
REGWIDTH  reg_width
 

x

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_reg_native UINT  i  ) 
 

x

PINVM::PINSYNC_RWLOCK* LEVEL_CORE::GetINSResizeLock  ) 
 

Returns the readers-writer lock of the INS stripe.

LOCALFUN UINT8 LEVEL_CORE::GetLegalByteWidthsBitmapForEaWidth INT32  ea_width  ) 
 

Get the appropriate legal_bytewidths_bitmap, which determines the legal size for displacements, given the effective address width.

LOCALFUN xed_encoder_operand_t LEVEL_CORE::GetShortestWidthSignedImmediate UINT64  immed,
UINT32  legal_immed_bytewidths_bitmap,
UINT32  extendedSize = 8*sizeof(ADDRINT),
UINT32  destination_bit_size = 0
[inline]
 

returns an immediate operand to the instruction. Find the shortest possible immediate representation. Assume that the immediate will be sign extended to an ADDRINT by the instruction.

Parameters:
immed Value of immediate
legal_immed_bytewidths_bitmap Legal immediate field widths (bitmap)
extendedSize Size (in bits) the immediate is expanded to.
destination_bit_size size of the destination operand in bits

BOOL LEVEL_CORE::GetSysCallArgMem INT32  ith_arg,
MEM_ADDR_EXP *  pExp,
SYSCALL_STANDARD  std = NativeSysCallStd()
 

Return expression for calculating memory address of the specified argument of a system call.

Parameters:
[in] ith_arg argument number (0 - first argument).
[out] pExp pointer to variable that receives expression for calculating memory address of the argument.
[in] std syscall standard.
Returns:
TRUE - success, FALSE - argument is not located in memory

BOOL LEVEL_CORE::HasSpecialOffsetForGotPcAccess RTN  rtn  ) 
 

x

IMG LEVEL_CORE::IMG_Alloc  ) 
 

x

SYM LEVEL_CORE::IMG_AllocAndAppendNewBblDynsym IMG  img,
const string &  name,
BBL  bbl
 

x

SYM LEVEL_CORE::IMG_AllocAndAppendNewChunkDynsym IMG  img,
const string &  name,
CHUNK  chunk,
UINT32  chunk_offset
 

x

SYM LEVEL_CORE::IMG_AllocAndAppendNewChunkRegsym IMG  img,
const string &  name,
CHUNK  chunk,
UINT32  chunk_offset
 

x

SYM LEVEL_CORE::IMG_AllocAndAppendNewRtnRegsym IMG  img,
const string &  name,
BBL  bbl
 

x

SYM LEVEL_CORE::IMG_AllocAndAppendNewUndefDynsym IMG  img,
const string &  name
 

x

VOID LEVEL_CORE::IMG_Append IMG  img,
APP  parent
 

Append an IMG to APP

VOID LEVEL_CORE::IMG_Check IMG  img  ) 
 

x

VOID LEVEL_CORE::IMG_ChunkifySecs IMG  img  ) 
 

subdivide SECs into chunks

VOID LEVEL_CORE::IMG_ComputeNewSecDataExec IMG  img  ) 
 

x

VOID LEVEL_CORE::IMG_ComputeNewSecDataUncooked IMG  img  ) 
 

Compute new section data for uncooked sections regardless whether they are mapped or not. This is simple since the new data is equal to the old one except for some changes due to relocations which is done in a separate step

VOID LEVEL_CORE::IMG_ComputeNewSecSizeExecAndAddressMapping IMG  img  ) 
 

Iterate over executable section and compute the addresses for the instructions

VOID LEVEL_CORE::IMG_ComputeNewSecSizeUncooked IMG  img  ) 
 

Compute new section sizes for uncooked sections regardless whether they are mapped or not. This is simple since the new sizes are equal to the old ones

VOID LEVEL_CORE::IMG_ConvertWeirdBranches IMG  img  ) 
 

x

VOID LEVEL_CORE::IMG_CookExecutableSections IMG  img  ) 
 

x

SYM LEVEL_CORE::IMG_FindDynsymByOriginalIndex IMG  img,
UINT32  index
 

x

SYM LEVEL_CORE::IMG_FindRegsymByName IMG  img,
const CHAR *  name
 

Find regular symbol by name

SYM LEVEL_CORE::IMG_FindRegsymByOriginalIndex IMG  img,
UINT32  index
 

x

SEC LEVEL_CORE::IMG_FindSecByIaddr IMG  img,
IADDR  iaddr
 

x

SEC LEVEL_CORE::IMG_FindSecByIaddrEndInclusive IMG  img,
IADDR  iaddr
 

x

SEC LEVEL_CORE::IMG_FindSecByName IMG  img,
const string &  name
 

x

SEC LEVEL_CORE::IMG_FindSecByNameWithType IMG  img,
const string &  name,
SEC_TYPE  type
 

x

SEC LEVEL_CORE::IMG_FindSecByOaddr IMG  img,
OADDR  oaddr
 

Find section containing the gived OADDR. Can only be invoked after addresses have been recomputed and the map family of stripes is active

SEC LEVEL_CORE::IMG_FindSecByOaddrEndInclusive IMG  img,
OADDR  oaddr
 

Find section containing the gived OADDR. Can only be invoked after addresses have been recomputed and the map family of stripes is active

SEC LEVEL_CORE::IMG_FindSecByOriginalIndex IMG  img,
UINT32  index
 

x

VOID LEVEL_CORE::IMG_Free IMG  img  ) 
 

x

VOID LEVEL_CORE::IMG_InitOriginalImg IMG  img,
const string &  filename,
const void *  start,
USIZE  size
 

x

VOID LEVEL_CORE::IMG_InsertAfter IMG  img,
IMG  after,
APP  parent
 

Insert IMG after another IMG within an APP

Parameters:
img block to be inserted after
after block to insert after, if IMG_INVALID, prepend to parent
parent rtn that contains after bbl

VOID LEVEL_CORE::IMG_InsertBefore IMG  img,
IMG  before,
APP  parent
 

Insert IMG before another IMG within an APP

Parameters:
img block to be inserted before
before to insert after, if IMG_INVALID, prepend to parent
parent rtn that contains after bbl

BOOL LEVEL_CORE::IMG_IsAddressInImage IMG  img,
ADDRINT  addr
 

Check if address is within image addresses

Parameters:
addr address to check.

BOOL LEVEL_CORE::IMG_IsMainImage IMG  img  ) 
 

Check if img is a main image

VOID LEVEL_CORE::IMG_LinkDynsymWithTarget IMG  img  ) 
 

Crosslink dynamic SYMs with the objects they're describing

VOID LEVEL_CORE::IMG_LinkRegsymWithTarget IMG  img  ) 
 

Crosslink regular SYMs with the objects they're describing

void LEVEL_CORE::IMG_load_offset_propagate IMG  img,
void *  loaderInfo
 

Propagate the load offset from the supplied loader info to PIN reported load offset.

VOID LEVEL_CORE::IMG_MarkPcRelativeControlFlow IMG  img  ) 
 

mark targets of pc relative branches as BBL and RTN beginning

UINT32 LEVEL_CORE::IMG_NumDynsym IMG  img  ) 
 

Return the number of dynamic symbols in the image

UINT32 LEVEL_CORE::IMG_NumRegsym IMG  img  ) 
 

Return the number of regulsr symbols in the image

UINT32 LEVEL_CORE::IMG_NumSec IMG  img  ) 
 

Return the number of SECs in an IMG

string LEVEL_CORE::IMG_PrintRegSyms IMG  img  ) 
 

Put all regular symbols in img

VOID LEVEL_CORE::IMG_RetypifyBbls IMG  img  ) 
 

the initial BBL typidication may be a little corse. For exaple we can sometimes not distinguish between an indirect junp and a return. This routine tries to refine the BBL types.

VOID LEVEL_CORE::IMG_SetNewChunkSizesAndAddresses IMG  img  ) 
 

Set new (outgoing) size and address of all CHUNKS in image. this can be done only once. NB: only data chunks are considered, because the code chunks have become irrelevant after INS creation

VOID LEVEL_CORE::IMG_SortSecsByVaddr IMG  img  ) 
 

x

string LEVEL_CORE::IMG_StringLong IMG  img  ) 
 

produce string for IMG

VOID LEVEL_CORE::IMG_TypifyBblsAndCreateEdgs IMG  img  ) 
 

determing BBL type based on last INS and create sucessor EDGs

VOID LEVEL_CORE::IMG_Unlink IMG  img  ) 
 

Unlink an IMG from the APP

VOID LEVEL_CORE::IMG_VerifyFallthroughs IMG  img  ) 
 

Verify that all LINK, FALSE, and NORMAL EDGs are pointing to the next BBL Includes ugly hackery for two (conditional) calls in one bundle

ARRAYBASE LEVEL_CORE::ImgArrayBase "img pool"  ,
1024 
 

x

STRIPE<IMG_STRUCT_BASE> LEVEL_CORE::ImgStripeBase "img stripe base"  ,
"core"  ,
ImgArrayBase
 

x

VOID LEVEL_CORE::InitializeINSSupplementaryResizeLock PINVM::ILOCK *  lock  ) 
 

Initialize the resize lock for the INS stripe

VOID LEVEL_CORE::InitializeStripes  ) 
 

Initialize the stripes

BOOL LEVEL_CORE::INS_AccessesManyFPRegisters INS  ins  ) 
 

Several instructions touch big swaths of the FPstate. These FP registers are not modeled in regr/regw of the INS

INS LEVEL_CORE::INS_Alloc  ) 
 

Allocate new INS, some initialization

INS LEVEL_CORE::INS_AllocLocked  ) 
 

Allocate new INS, some initialization The readers lock for the INS stripe is acquired when this function returns. This guarantees the validity of the INS object in a MT environment when the VM lock is not held by the calling thread. It is the responsibility of the caller to unlock the INS stripe readers lock after he's calling INS_Free() on the allocated INS.

Note:
Use this function to allocate an instruction without holding the VM lock.

VOID LEVEL_CORE::INS_Append INS  ins,
BBL  parent
 

x

VOID LEVEL_CORE::INS_AttachComment const INS  ins,
string  comment
 

Attach a comment to an ins. Should only be called if KnobAttachComment is TRUE.

Parameters:
[in] ins Attach comment to this INS
[in] comment Makes copy of this string for comment

BBL LEVEL_CORE::INS_bbl INS  x  ) 
 

return BBL containing the INS, an invalid BBL indicates that the INS is unlinked

UINT32 LEVEL_CORE::INS_BranchDisplacementWidthBits INS  ins  ) 
 

Return width of branch offset in BITS

UINT32 LEVEL_CORE::INS_BranchDisplacementWidthBytes INS  ins  ) 
 

Return width of branch offset in BYTES.

REG LEVEL_CORE::INS_CallOrBranchGetIndirectRegister INS  ins  ) 
 

assert that this is a Branch or call indirect though register: get the register

BOOL LEVEL_CORE::INS_CallOrBranchIsMemoryIndirect INS  ins  ) 
 

Returns:
true if this branch or call indirect through memory

BOOL LEVEL_CORE::INS_CallOrBranchIsRegisterIndirect INS  ins  ) 
 

Returns:
true if the instruction is a branch or call indirect through a register.

IADDR LEVEL_CORE::INS_CallRetIaddr INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_ChangeOperandToImmediate INS  ins,
UINT32  operandIndex,
REG  regBeingReplaced,
UINT64  immediate
 

Replace an operand with an immediate. Caller is responsible for checking that the ISA allows an immediate as this operand and that the immediate fits.

Parameters:
[in] ins Instruction
[in] operandIndex Index of operand to change
[in] immediate Value of immediate

BOOL LEVEL_CORE::INS_ChangeStackPtr INS  ins  ) 
 

Change stack pointers:

REG_STACK_PTR -> REG_PIN_STACK_PTR REG_PIN_BRIDGE_ORIG_SP -> REG_STACK_PTR

Returns:
Returns true if at least one register was changed

REG LEVEL_CORE::INS_ChangeToPinFlagsReg const INS  ins,
const BOOL  as_read
 

Change all occurrences of types of the flags register to be the corresponding pin flags register in the r/w sets of the ins. Return the pin register used in the replacement.

BOOL LEVEL_CORE::INS_ChangeToUsePinFlags const INS  ins  ) 
 

Change all occurrences of app flags to corresponding pin flags in ins. Return TRUE if at least one occurrence changed.

VOID LEVEL_CORE::INS_Check INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_CheckFree  ) 
 

ASSERT if an INS has not been freed. This function is expensive so it cannot be called for normal runs.

VOID LEVEL_CORE::INS_ClearDirtyG INS  ins  ) 
 

Global version of INS_DirtyG(). Used for accessing the dirty bits from another file.

string LEVEL_CORE::INS_Comment INS  ins  ) 
 

Get the comment string from an instruction.

Parameters:
[in] ins INS whose comment string is wanted.

VOID LEVEL_CORE::INS_ConvertCallToBranch INS  ins  ) 
 

Convert a call instruction to a branch

INS LEVEL_CORE::INS_ConvertLoadToMoveHack INS  jmp  ) 
 

Convert a JMP/CALL indirect through memory to a load(mov) of the value indicated by the jmp memop to REG_PIN_INDIRREG

VOID LEVEL_CORE::INS_ConvertToIndirectJumpHack INS  ins  ) 
 

Convert Jump/call through memory to a jump/call indirect through register (REG_PIN_INDIREG).

VOID LEVEL_CORE::INS_Copy INS  ins,
INS  clone
 

Copy ins to clone. Allocate and create new rel for clone if necessary.

VOID LEVEL_CORE::INS_CopyArchFields INS  ins,
INS  clone
 

Copy everything to the clone.

VOID LEVEL_CORE::INS_CopyComment INS  toIns,
INS  fromIns
 

Copy any comment on fromIns to toIns.

Parameters:
in/out] toIns
[in] fromIns 

VOID LEVEL_CORE::INS_CopyXlateAttributes INS  insNew,
INS  insOrig
 

This method is used when Pin translates an original application instruction into a different instruction or into a sequence of instructions. It copies attributes from the original INS to the new (translated) INS.

Parameters:
[out] insNew The new instruction that Pin generates (receives the new attributes).
[in] insOrig The original application instruction.

REG LEVEL_CORE::INS_CountRegister INS  ins  ) 
 

Returns:
register used as the counter by this instruction The instruction can be a loop instruction, a REP prefixed instruction, or a jecxz instruction. If it is any other instruction the result is REG_INVALID()

INSDECODE LEVEL_CORE::INS_DecodeIns INS  ins,
const VOID **  address,
UINT32  size,
EXCEPTION_CODE excCode
 

Forward declaration of the Intel(R) X86 Encoder Decoder decoding function. It must be declared in this file to resolve references in the following inline functions.

IADDR LEVEL_CORE::INS_DirectBranchOrCallTargetIaddr INS  ins  ) 
 

Compute the target of an ip relative jmp

IADDR LEVEL_CORE::INS_DirectBranchOrCallTargetIaddr INS  ins,
IADDR  iaddr
 

Compute the target of an ip relative jmp

OADDR LEVEL_CORE::INS_DirectBranchOrCallTargetOaddr INS  ins,
OADDR  oaddr
 

Compute the target of an ip relative jmp

BOOL LEVEL_CORE::INS_DirtyG INS  ins  ) 
 

Global version of INS_DirtyG(). Used for accessing the dirty bits from another file.

VOID LEVEL_CORE::INS_DisableSegmentPrefix INS  ins  ) 
 

INS_DisableSegmentPrefix() - remove segment prefix

VOID LEVEL_CORE::INS_EmbedValue INS  ins,
VOID *  valuePtr,
UINT32  valueSize
 

Embed an immediate value into the code as an INS

USIZE LEVEL_CORE::INS_EncodeAtAddr INS  ins,
ADDRINT  address
 

Encode an instruction at a given address

UINT8* LEVEL_CORE::INS_EncodeBufferG INS  ins  ) 
 

Make the INS_EncodeBuffer available for external use

UINT32 LEVEL_CORE::INS_EncodeIns INS  ins,
VOID *  buffer
 

Returns:
size of instruction

UINT32 LEVEL_CORE::INS_EncodeSizeG INS  ins  ) 
 

Global version of INS_EncodeSize(). Used for accessing the encode size from another file.

VOID LEVEL_CORE::INS_EncodeSizeSetG INS  ins,
UINT32  size
 

Make the INS_EncodeSizeSet available for external use

BOOL LEVEL_CORE::INS_Equal INS  ins,
INS  ins2
 

x

BOOL LEVEL_CORE::INS_EqualArchFields INS  ins1,
INS  ins2
 

Compare the architecture fields. BEWARE: this is somewhat flaky, since if xed_decoded_inst contains padding, this comparison could fail.

Since the only use of this function is in an assertion which checks that a cloned instruction is the same as its original, (where the copy has been done using INS_CopyArchFields) it's probably OK, but beware if you want to use this elsewhere. It would be safer if Intel(R) X86 Encoder Decoder exposed a comparison function so we can avoid a byte-wise comparison of structures.

VOID LEVEL_CORE::INS_ExtInsertAfter EXT  ext,
EXT  after,
INS  parent
 

VOID LEVEL_CORE::INS_ExtMove INS  src,
INS  dst,
const ATTRIBUTE *  attr
 

x

VOID LEVEL_CORE::INS_ExtMoveRev INS  src,
INS  dst,
const ATTRIBUTE *  attr
 

Move EXT's of a particular attribute to another ins. The order of the EXT will be reversed.

VOID LEVEL_CORE::INS_ExtPrepend EXT  ext,
INS  parent
 

VOID LEVEL_CORE::INS_ExtTransfer INS  src,
INS  dst
 

template<typename FETCHER_>
GLOBALTEMPLATEFUN BOOL LEVEL_CORE::INS_Fetch INS  ins,
const VOID **  address,
const FETCHER_ &  insBytesFetcher,
UINT32  maxSize,
EXCEPTION_INFO pExceptInfo = 0
 

Decode an original instruction and initialize the specified INS object. Use the specified INS_BYTES_FETCHER functor to fetch bytes of the instruction.

Parameters:
[out] ins the instruction object to be initialized
[in] out] address on input: address of the instruction to be decoded on output: address of the instruction immediately following the decoded one [in] insBytesFetcher the INS_BYTES_FETCHER functor to be used for fetching the instruction's bytes
[in] maxSize the maximum size of the instruction to be decoded. MAX_INSTRUCTION_SIZE if the input is 0.
[out] pExceptInfo optional pointer to the structure that receives the exception information if the function fails
Returns:
TRUE for success, FALSE for failure.

VOID LEVEL_CORE::INS_Free INS  ins  ) 
 

Free INS

VOID LEVEL_CORE::INS_FreeLocked INS  ins  ) 
 

Free INS which was allocated by INS_AllocLocked(). This function also releases the INS stripe lock acquired by INS_AllocLocked().

VOID LEVEL_CORE::INS_FreeRel INS  ins  ) 
 

Free INS and possibly attached reloc

VOID LEVEL_CORE::INS_GarbageCollect  ) 
 

INS garbage collector, currently not used

VOID LEVEL_CORE::INS_GenMemImmOpWidth INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
UINT64  immed,
OPCODE  opcode,
UINT8  legal_immed_bytewidths_bitmap,
REGWIDTH  reg_width
 

x

VOID LEVEL_CORE::INS_GenMemRegOpWidth INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  src,
OPCODE  opcode,
REGWIDTH  reg_width,
UINT  store_bytes
 

x

VOID LEVEL_CORE::INS_GenRegMemOpWidth INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  reg,
OPCODE  opcode,
UINT8  legal_displacement_bytewidths_bitmap,
REGWIDTH  reg_width
 

x

VOID LEVEL_CORE::INS_GenRetImm INS  ins,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_GenSizedNop INS  ins,
UINT  requested_length_bytes
 

Create a "nop" instruction witha requested size

UINT8 LEVEL_CORE::INS_get_num_reads INS  x  ) 
 

Returns:
Returns the number of registers read by this instruction

UINT8 LEVEL_CORE::INS_get_num_writes INS  x  ) 
 

Returns:
Returns the number of registers written by this instruction

UINT LEVEL_CORE::INS_get_pos_r INS  x,
UINT  i
 

Returns:
Returns Intel(R) X86 Encoder Decoder operand position of ith read register

UINT LEVEL_CORE::INS_get_pos_w INS  x,
UINT  i
 

Returns:
Returns Intel(R) X86 Encoder Decoder operand position of ith written register

REG LEVEL_CORE::INS_get_reg_r INS  x,
UINT  i
 

Returns:
Returns the ith read register

REG LEVEL_CORE::INS_get_reg_w INS  x,
UINT  i
 

Returns:
Returns the ith written register

xed_operand_enum_t LEVEL_CORE::INS_get_role_r INS  x,
UINT  i
 

x

xed_operand_enum_t LEVEL_CORE::INS_get_role_w INS  x,
UINT  i
 

Returns:
Returns role of ith written register

REG LEVEL_CORE::INS_GetBaseReg INS  ins  ) 
 

Note: this only works for the 1st (0-index) base reg. Not the second base register in string ops & calls

REG LEVEL_CORE::INS_GetBaseRegOne INS  ins  ) 
 

Note: this gets the second base register, only useful for string ops & calls.

ADDRDELTA LEVEL_CORE::INS_GetBranchDisplacement INS  ins  ) 
 

Note:
the displacement is a signed number.

REG LEVEL_CORE::INS_GetFirstAluSourceReg INS  ins  ) 
 

x

ADDRINT LEVEL_CORE::INS_GetImmediate INS  ins  ) 
 

x

REG LEVEL_CORE::INS_GetIndexReg INS  ins  ) 
 

x

ADDRDELTA LEVEL_CORE::INS_GetMemoryDisplacement INS  ins  ) 
 

Return the displacement as a signed integral number in the size of pointer (i.e. ADDRDELTA). This will return 0 if the memory operation does not have a displacement or if the displacement is zero.

ADDRINT LEVEL_CORE::INS_GetMTSafePatchLocation ADDRINT  addr,
USIZE  size
 

Given an original instruction location, get the nearest next address at which this instruction should be placed if it needs to be safely patched

Precondition:
The instruction size should not exceed INS_PATCH_UNIT bytes
Parameters:
[in] addr original address of the instruction This could be an absolute address of the instruction or it could be an offset relative to any INS_PATCH_UNIT-aligned address
[in] size size of the instruction
Returns:
new location for the instruction that needs to be safely patched

OADDR LEVEL_CORE::INS_GetOaddr INS  ins  ) 
 

x

UINT LEVEL_CORE::INS_GetPos INS  ins,
UINT  i,
BOOL  read
 

If read is TRUE, returns the operand position of the ith read register, otherwise the ith written register

REG LEVEL_CORE::INS_GetReg INS  ins,
UINT  i,
BOOL  read
 

If read is TRUE, gets the ith read register, otherwise the ith written register

xed_operand_enum_t LEVEL_CORE::INS_GetRole INS  ins,
UINT  i,
BOOL  read
 

If read is TRUE, returns the role of the ith read register, otherwise the ith written register

LOCALFUN REG LEVEL_CORE::INS_GetRoleReg INS  ins,
xed_operand_enum_t  role
 

Returns:
the read register which fulfils the requested role.

UINT32 LEVEL_CORE::INS_GetScale INS  ins  ) 
 

x

ADDRINT LEVEL_CORE::INS_GetSecondImmediate INS  ins  ) 
 

x

ADDRDELTA LEVEL_CORE::INS_GetSignedImmediate INS  ins  ) 
 

Note:
Return the immediate operand as a sign number.

BOOL LEVEL_CORE::INS_HasFixed8BitBranchDisplacement INS  ins  ) 
 

Return true if the branch has an 8b displacement. Relative/direct branches only! This ignores the Jb branches (opcodes 0x70..0x7F).

BOOL LEVEL_CORE::INS_HasImmediateOperand INS  ins  ) 
 

x

BOOL LEVEL_CORE::INS_HasImplicitFullMask INS  ins  ) 
 

Returns true only if this is k0 masked vector that is ignored (ie. in EVEX instruction) A bit hacky code till better xed API

BOOL LEVEL_CORE::INS_HasImplicitMemoryReference INS  ins  ) 
 

Test if this instruction has an implicit memory operand. We include the memory operand in lea, even though that doesn't access memory.

BOOL LEVEL_CORE::INS_HasImplicitStackReference INS  ins  ) 
 

Test if this instruction has an implicit stack reference.

BOOL LEVEL_CORE::INS_HasMemoryDisplacement INS  ins  ) 
 

Return true if the operation really has a memory displacement.

BOOL LEVEL_CORE::INS_HasRepEqual INS  ins  ) 
 

Returns:
true if this is a REPE

BOOL LEVEL_CORE::INS_HasSegmentRegPrefix INS  ins  ) 
 

Just calls INS_SegmentPrefix()

UINT64 LEVEL_CORE::INS_Id INS  ins  ) 
 

Returns:
Unique identifier of instruction

VOID LEVEL_CORE::INS_InitAAA INS  ins  ) 
 

CPUID

VOID LEVEL_CORE::INS_InitAddCI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitAddCR INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitAddI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitAddR INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitAlignedLoadXMM INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

Load a 128-bit value from an aligned memory location into the given dst register. In case the xmm destination is a partial register (AVX and above), the high bits of the full register will be preserved.

Note:
On AVX and above, a preceding vzeroupper instruction may be needed to avoid performance penalties. It is the caller's responsibility to do so.

The given dst register is expected to be a xmm register.

VOID LEVEL_CORE::INS_InitAlignedLoadZMM INS  ins,
REG  dst,
REG  mask,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitAlignedStoreXMM INS  ins,
REG  src,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

x

VOID LEVEL_CORE::INS_InitAlignedStoreZMM INS  ins,
REG  src,
REG  mask,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitAnd INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitAndI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitAndMI INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
UINT64  immed
 

x

VOID LEVEL_CORE::INS_InitBranch INS  ins,
BBL  target
 

x

VOID LEVEL_CORE::INS_InitBsr INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitCall INS  ins,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitCallIndirectMemory INS  ins,
REG  segment,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

VOID LEVEL_CORE::INS_InitCallIndirectRegister INS  ins,
REG  target
 

x

VOID LEVEL_CORE::INS_InitCld INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitCmov INS  ins,
REG  src,
REG  dst,
PREDICATE_IA32  cond
 

Generate a CMOV for the given predicate.

VOID LEVEL_CORE::INS_InitCmovccFromJcc INS  ins,
INS  jcc,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitCmp INS  ins,
REG  src_reg,
REG  dst_reg
 

x

VOID LEVEL_CORE::INS_InitCmpBI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitCmpI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitCmpMR INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  reg
 

x

VOID LEVEL_CORE::INS_InitCmpWI INS  ins,
REG  reg,
UINT64  imm
 

x

USIZE LEVEL_CORE::INS_InitDirectJmp INS  ins,
ADDRINT  brAddr,
ADDRINT  tgtAddr
 

Initialize an unconditional, direct jump instruction with the 32-bit displacement

Parameters:
[in] ins instruction to be initialized
[in] brAddr address of the branch
[in] tgtAddr target address of the branch
Precondition:
the signed distance between <tgtAddr> and <brAddr> should fit 32 bits.
Returns:
size of the jump instruction

VOID LEVEL_CORE::INS_InitEncodeDecoder  ) 
 

x

VOID LEVEL_CORE::INS_InitFarDirectCall INS  ins,
UINT32  displacement,
UINT16  segment_selector
 

Make a far direct call

VOID LEVEL_CORE::INS_InitFarDirectJmp INS  ins,
UINT32  displacement,
UINT16  segment_selector
 

Make a far direct jump

LOCALFUN VOID LEVEL_CORE::INS_InitFarDirectOp INS  ins,
UINT32  displacement,
UINT16  segment_selector,
xed_iclass_enum_t  iclass
 

Create far jumps and calls

VOID LEVEL_CORE::INS_InitFxrstor INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

VOID LEVEL_CORE::INS_InitFxsave INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

LOCALFUN VOID LEVEL_CORE::INS_InitGPR32XMMOp INS  ins,
REG  dst,
REG  src,
xed_iclass_enum_t  iclass
 

Create an GPR32/ XMM operation

VOID LEVEL_CORE::INS_InitHalt INS  ins  ) 
 

x

LOCALFUN void LEVEL_CORE::INS_Initialize INS  ins  ) 
 

Initializate a newly allocated INS

VOID LEVEL_CORE::INS_InitIncMem INS  ins,
REG  base,
ADDRINT  disp,
BOOL  lock
 

x -- Dynamic profile - produce "inc [base+disp]" INS (with or without lock)

VOID LEVEL_CORE::INS_InitInt INS  ins,
UINT8  imm
 

x

VOID LEVEL_CORE::INS_InitInt3 INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitIntx86 INS  ins,
UINT64  num
 

x

VOID LEVEL_CORE::INS_InitJCXZ INS  ins,
UINT64  imm,
REG  countReg
 

Initialize a JCXZ, ensuring that it accesses the correct register (which must be one of CX,ECX,RCX or their Pin equivalents).

VOID LEVEL_CORE::INS_InitJmpL INS  ins,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitJmpM INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  segreg
 

Indirect unconditional jump through memory

VOID LEVEL_CORE::INS_InitJmpR INS  ins,
REG  src
 

x

VOID LEVEL_CORE::INS_InitJxBLFromOtherIns INS  ins,
INS  other,
UINT64  imm
 

Copy the branch. Change the displacement to 32 bits if the instruction allows it. Convert indirect to direct.

VOID LEVEL_CORE::INS_InitJxMemoryFromOtherIns INS  ins,
INS  other,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

Indirect conditional jump through memory, copying the opcode from another instruction

VOID LEVEL_CORE::INS_InitLAHF INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitLea INS  ins,
REG  dst,
REG  base,
REG  seg
 

Create an lea that uses default address width, with a simple register + SEG register source (useful for string op operands).

VOID LEVEL_CORE::INS_InitLea INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

Create an lea that uses default address width

VOID LEVEL_CORE::INS_InitLeaEaWidth INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
INT32  ea_width,
REGWIDTH  reg_width
 

Create an lea specifying the ea_width (16, 32 or 64) and destination reg_width

VOID LEVEL_CORE::INS_InitLeaEaWidth INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
INT32  ea_width
 

Create an lea specifying the ea_width (16, 32 or 64)

VOID LEVEL_CORE::INS_InitLoad INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitLoadEaWidth INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  seg,
INT32  ea_width
 

x

VOID LEVEL_CORE::INS_InitLoadMaskReg INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
BOOL  exactCopy
 

This function loads the value of a mask register directly from memory.

LOCALFUN VOID LEVEL_CORE::INS_InitLoadMemop INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
xed_iclass_enum_t  iclass,
BOOL  exactCopy,
xed_operand_enum_t  xed_op = XED_OPERAND_MEM0,
UINT8  legal_displacement_bytewidths_bitmap = 5,
REGWIDTH  reg_width = REGWIDTH_NATIVE,
INT32  ea_width = sizeof(VOID*) * 8,
UINT  load_bytes = 0
 

Generate a load memop.

Parameters:
ins The ins we are creating.
[in] dst The register destination.
[in] base The address computation base register
[in] displacement The displacement for the memory address computation
[in] index The index register for the memory address computation
[in] scale The scale value for the memory address computation
[in] pinseg The segment register name for the memory address computation
[in] iclass The instruction iclass of type xed_iclass_enum_t that we want to create.
[in] xed_op Either XED_OPERAND_AGEN (for LEA instructions) or XED_OPERAND_MEM0 for everything else.
[in] legal_displacement_bytewidths_bitmap A bit vector of legal displacment(displacement) widths. bit0=1 byte, bit1=2 bytes, bit2=4 bytes and bit3=8 bytes.
[in] reg_width The width of the operation. This determines the destination register width.
[in] ea_width The width in bits of the effective address computation.
[in] load_bytes If we are doing sign-extending loads, the width of the data is different than the width of the destination register. Here is where one specifies the with of the data if it is not the same as the destination register width. The default is zero implying that the memory operand width is the same as the destination register width. This value is in bytes.

VOID LEVEL_CORE::INS_InitLoadMMX INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

x

VOID LEVEL_CORE::INS_InitLoadMxcsr INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
BOOL  useAvxVersion
 

x

VOID LEVEL_CORE::INS_InitLoadWidth INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  seg,
REGWIDTH  reg_width
 

x

VOID LEVEL_CORE::INS_InitLods INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitMemImmOp INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
OPCODE  op,
UINT64  immed,
UINT8  legal_immed_bytewidths_bitmap,
REGWIDTH  reg_width,
BOOL  exactCopy
 

Operate with an immediate and a memory operand.

Parameters:
[in] ins Instruction to build
[in] base Base register
[in] displacement Constant displacement from base
[in] index Index register
[in] scale Index register multiplier
[in] pinseg Segment register
[in] opcode The operation to be performed
[in] immed The immediate value to use.
[in] legal_immed_bytewidths_bitmap Valid widths for the immediate
[in] reg_width Size of the operation

LOCALFUN VOID LEVEL_CORE::INS_InitMMExtractOpOriginal INS  ins,
REG  mmSrc,
REG  maskReg,
REG  base,
INT32  displacement,
UINT  disp_bytes,
REG  index,
UINT  scale,
REG  seg,
UINT32  imm8,
xed_iclass_enum_t  iclass,
UINT32  operandWidthBits,
BOOL  replaceXedRegs
 

set up the memory resource

LOCALFUN VOID LEVEL_CORE::INS_InitMMInsertOpOriginal INS  ins,
REG  mmDest,
REG  mmSrc,
REG  maskReg,
REG  base,
INT32  displacement,
UINT  disp_bytes,
REG  index,
UINT  scale,
REG  seg,
UINT32  imm8,
xed_iclass_enum_t  iclass,
UINT32  operandWidthBits,
BOOL  replaceXedRegs
 

set up the memory resource

LOCALFUN VOID LEVEL_CORE::INS_InitMMLoad INS  ins,
REG  mmdst,
REG  maskReg,
REG  base,
INT32  displacement,
UINT  disp_bytes,
REG  index,
UINT  scale,
REG  pinseg,
xed_iclass_enum_t  iclass,
UINT32  memop_byte_length,
xed_reg_enum_t  dummy_dst_param,
xed_reg_enum_t  dummy_mask_param,
BOOL  exactCopy
 

Create a MMX/XMM load. The dummy_dst must be an MMX/XMM register as appropriate

LOCALFUN VOID LEVEL_CORE::INS_InitMMRegRegOp INS  ins,
REG  mmdst,
REG  mmsrc,
xed_iclass_enum_t  iclass,
xed_reg_enum_t  dummy_dst,
xed_reg_enum_t  dummy_src,
REGWIDTH  regWidth = REGWIDTH_NATIVE
 

Create a reg/reg operation. This version differs from INS_InitRegRegOp in that it takes the dummy registers in the arg list so you can supply MMX, XMM or GPR registers as dummy registers.

In 64b mode, if you have a 32b GPR as a destination, you should set the regWidth to REGWIDTH_32.

If you have an XMM source/dest the dummy reg should be a valid XMM register such as XED_REG_XMM0. Use different dummy registers for src & dest.

VOID LEVEL_CORE::INS_InitMov INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMov16 INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMov32 INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMov8 INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMovAddrint INS  ins,
ADDRINT  imm,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMOVDQARegReg INS  ins,
REG  dst,
REG  src
 

Create a MOVDQA reg/reg

VOID LEVEL_CORE::INS_InitMovI INS  ins,
UINT64  imm,
REG  dst,
BOOL  denyImm32SignExtension = FALSE
 

Parameters:
[in] denyImm32SignExtension Deny attempt to check if the 32 immediate (if such) can be extended to 64 bit without loosing its value. See Mantis #4323 for more details.

VOID LEVEL_CORE::INS_InitMovMemImmOp INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
UINT64  immed,
UINT8  legal_immed_bytewidths_bitmap,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitMovMemImmOpWidth INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
UINT64  immed,
UINT8  legal_immed_bytewidths_bitmap,
REGWIDTH  reg_width
 

allow non-native reg_width

VOID LEVEL_CORE::INS_InitMovMemReg INS  ins,
REG  segment,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMovRegMem INS  ins,
REG  src,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

VOID LEVEL_CORE::INS_InitMovSW INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitMovsx INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitMovsxMemop INS  ins,
REG  dst,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
UINT32  memWidth
 

x

VOID LEVEL_CORE::INS_InitMovzx INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitNeg INS  ins,
REG  reg
 

Negate the value in the given register.

VOID LEVEL_CORE::INS_InitNop INS  ins  ) 
 

Create a "nop" instruction.

LOCALFUN VOID LEVEL_CORE::INS_InitNoRegOp INS  ins,
xed_iclass_enum_t  iclass
 

x

VOID LEVEL_CORE::INS_InitNot INS  ins,
REG  reg
 

Bitwise not the value in the given register.

VOID LEVEL_CORE::INS_InitOrI INS  ins,
REG  reg,
UINT64  imm
 

x

BOOL LEVEL_CORE::INS_InitOriginalIns INS  ins,
const VOID **  address,
UINT32  maxSize,
EXCEPTION_INFO pExceptInfo = 0
 

Decode an original instruction and initialize the specified INS object.

Parameters:
[out] ins the instruction object to be initialized
[in] out] address on input: address of the instruction to be decoded on output: address of the instruction immediately following the decoded one
[in] maxSize the maximum size of the instruction to be decoded. MAX_INSTRUCTION_SIZE if the input is 0.
[out] pExceptInfo optional pointer to the structure that receives the exception information if the function fails
Returns:
TRUE for success, FALSE for failure.

VOID LEVEL_CORE::INS_InitOrMI INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
UINT64  immed
 

x

VOID LEVEL_CORE::INS_InitPANDRegReg INS  ins,
REG  dst,
REG  src
 

Create a PAND reg/reg

VOID LEVEL_CORE::INS_InitPCMPEQBRegMem INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

Create a PCMPEQB reg, mem

VOID LEVEL_CORE::INS_InitPCMPEQDRegMem INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

Create a PCMPEQD reg, mem

VOID LEVEL_CORE::INS_InitPMOVMSKB INS  ins,
REG  dst,
REG  src
 

Create a PMOVMSKB r32, xmm

VOID LEVEL_CORE::INS_InitPop INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

VOID LEVEL_CORE::INS_InitPop INS  ins,
REG  reg
 

Create a POP instruction that pops a register. The instruction is chosed to suit the size of the register.

Parameters:
[in] ins The instruction, which is constructed as a POP.
[in] reg The register that is popped.

VOID LEVEL_CORE::INS_InitPopAL INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitPopF INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitPORRegMem INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

Create a POR reg, mem

VOID LEVEL_CORE::INS_InitPush INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg
 

x

VOID LEVEL_CORE::INS_InitPush INS  ins,
REG  reg
 

Create a PUSH instruction that pushes a register. The instruction is chosen to suit the size of the register.

Parameters:
[in] ins The instruction, which is constructed as a PUSH.
[in] reg The register that is pushed.

VOID LEVEL_CORE::INS_InitPushAL INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitPushF INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitPushI INS  ins,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitPushWidth INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
REGWIDTH  reg_width
 

x

VOID LEVEL_CORE::INS_InitRdtsc INS  ins  ) 
 

x

LOCALFUN VOID LEVEL_CORE::INS_InitRegRegOp INS  ins,
REG  src,
REG  dst,
xed_iclass_enum_t  iclass,
xed_reg_enum_t  dummy_src = XED_REG_ECX,
xed_reg_enum_t  dummy_dst = XED_REG_EDX,
unsigned int  op_width = 32
 

Generate a register <OP> register operation. If you're trying to generate non-ADDRINT-width operation you need to use one of the higher level functions, or explicitly pass the appropriate widths and dummy registers in the optional arguments.

VOID LEVEL_CORE::INS_InitRepStos INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitRet INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitRetImm INS  ins,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitSAHF INS  ins  ) 
 

x

LOCALFUN VOID LEVEL_CORE::INS_InitSDispOp INS  ins,
INT64  disp,
xed_iclass_enum_t  iclass,
INT32  ea_width = sizeof(VOID*) * 8,
INS  orig = INS_INVALID()
 

Initialize CONTROL TRANSFERS with displacements.

VOID LEVEL_CORE::INS_InitSetCC INS  ins,
REG  reg,
PREDICATE_IA32  cond
 

Generate a SETcc instruction for the given predicate. The register must be a one byte register since those are the only valid register targets for setCC

VOID LEVEL_CORE::INS_InitSeto INS  ins,
REG  reg
 

x

VOID LEVEL_CORE::INS_InitShlI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitShrI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitSizedNop INS  ins,
UINT  requested_length_bytes
 

Create a "nop" instruction witha requested size

VOID LEVEL_CORE::INS_InitStd INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitStore INS  ins,
REG  src,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
BOOL  exactCopy
 

INS_InitStore with the default segment register

VOID LEVEL_CORE::INS_InitStore INS  ins,
REG  src,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitStoreMaskReg INS  ins,
REG  src,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
BOOL  exactCopy
 

This function stores the value of a mask register directly to memory.

VOID LEVEL_CORE::INS_InitStoreMMX INS  ins,
REG  src,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg
 

x

VOID LEVEL_CORE::INS_InitStoreMxcsr INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
BOOL  useAvxVersion
 

x

VOID LEVEL_CORE::INS_InitStoreNTIWidth INS  ins,
REG  src,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
REGWIDTH  reg_width
 

x

VOID LEVEL_CORE::INS_InitStoreWidth INS  ins,
REG  src,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale,
REG  seg,
REGWIDTH  reg_width,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitStos INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitSubI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitSubR INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitTest INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitTestI INS  ins,
REG  reg,
UINT64  imm
 

x

VOID LEVEL_CORE::INS_InitTestMI INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
UINT64  immed
 

x

VOID LEVEL_CORE::INS_InitUD2 INS  ins  ) 
 

x

VOID LEVEL_CORE::INS_InitUnalignedLoadXMM INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

Load a 128-bit value from an unaligned memory location into the given dst register. In case the xmm destination is a partial register (AVX and above), the high bits of the full register will be preserved.

Note:
On AVX and above, a preceding vzeroupper instruction may be needed to avoid performance penalties. It is the caller's responsibility to do so.

The given dst register is expected to be a xmm register.

VOID LEVEL_CORE::INS_InitUnalignedLoadYMM INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

Load a 256-bit value from an unaligned memory location into the given dst register. In case the ymm destination is a partial register (AVX512 and above), the high bits of the full register will be preserved.

Note:
The given dst register is expected to be a ymm register.

VOID LEVEL_CORE::INS_InitUnalignedLoadZMM INS  ins,
REG  dst,
REG  mask,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitUnalignedStoreXMM INS  ins,
REG  src,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitUnalignedStoreXMMUsingAvx INS  ins,
REG  src,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitUnalignedStoreYMM INS  ins,
REG  src,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitUnalignedStoreZMM INS  ins,
REG  src,
REG  mask,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
BOOL  exactCopy
 

x

VOID LEVEL_CORE::INS_InitVxorpd INS  ins,
REG  ymmDest,
REG  ymmSrc1,
REG  ymmSrc2
 

x

VOID LEVEL_CORE::INS_InitVZeroUpper INS  ins  ) 
 

Create a VZEROUPPER instruction

VOID LEVEL_CORE::INS_InitXbegin INS  ins  ) 
 

Generate the Xbegin.

VOID LEVEL_CORE::INS_InitXchg INS  ins,
REG  src_reg,
REG  dst_reg
 

Initialize an xchg instruction

LOCALFUN VOID LEVEL_CORE::INS_InitXMMLoadOp INS  ins,
REG  dst,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
xed_iclass_enum_t  iclass
 

Create a XMM/MEM load-type operation. Assumes you are loading 16B quantities.

LOCALFUN VOID LEVEL_CORE::INS_InitXMMRegRegOp INS  ins,
REG  dst,
REG  src,
xed_iclass_enum_t  iclass
 

Create an XMM reg/reg operation

VOID LEVEL_CORE::INS_InitXor INS  ins,
REG  src,
REG  dst
 

x

VOID LEVEL_CORE::INS_InitXrstor INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

VOID LEVEL_CORE::INS_InitXsave INS  ins,
REG  base,
ADDRINT  displacement,
REG  index,
UINT32  scale
 

x

VOID LEVEL_CORE::INS_InsertAfter INS  ins,
INS  after,
BBL  parent
 

x

VOID LEVEL_CORE::INS_InsertBefore INS  ins,
INS  before,
BBL  parent
 

x

VOID LEVEL_CORE::INS_InvertBr INS  ins  ) 
 

x

IADDR LEVEL_CORE::INS_IpRelTargetIaddr INS  ins  ) 
 

Compute the target of an ip-relative data address

BOOL LEVEL_CORE::INS_IsAdd const INS  ins  ) 
 

returns true if this instruction is an add.

BOOL LEVEL_CORE::INS_IsAnyPopF const INS  ins  ) 
 

Returns:
if ins is any type of popf

BOOL LEVEL_CORE::INS_IsAvx INS  ins  ) 
 

Return TRUE iff the ins is an AVX instruction

BOOL LEVEL_CORE::INS_IsAvxOrXSave INS  ins  ) 
 

Return TRUE iff the ins is an AVX or xsave-family instruction

BOOL LEVEL_CORE::INS_IsBblTerminator INS  ins  ) 
 

x

BOOL LEVEL_CORE::INS_IsBitTest INS  ins  ) 
 

Return TRUE if the INS is a BT, or BT[CRS] instruction. These instructions have the interesting property that if they're operating on memory with a register bit-index, the bit-index can be larger than the number of bits in the memory operand, in which case the high bits are added (with suitable scaling) to the memory address.

BOOL LEVEL_CORE::INS_IsBsr INS  ins  ) 
 

Return TRUE if the INS is a BSR instruction

BOOL LEVEL_CORE::INS_IsCJmp INS  ins  ) 
 

Return TRUE if the INS is a Conditional branch instruction

BOOL LEVEL_CORE::INS_IsCmov INS  ins  ) 
 

Return TRUE if the INS is an integer conditional move instruction

BOOL LEVEL_CORE::INS_IsCmps INS  ins  ) 
 

Return TRUE if the INS is a CMPS

BOOL LEVEL_CORE::INS_IsCondWrite INS  ins  ) 
 

Return TRUE if the INS is does a conditional write.

BOOL LEVEL_CORE::INS_IsCpuid INS  ins  ) 
 

Returns:
true if the instruction is CPUID.

BOOL LEVEL_CORE::INS_IsDec const INS  ins  ) 
 

returns true if this instruction is a decrement.

BOOL LEVEL_CORE::INS_IsEnter INS  ins  ) 
 

Return TRUE if the INS is an ENTER instruction.

BOOL LEVEL_CORE::INS_IsExplicit const INS  ins,
const UINT32  pos
 

Test if a reg read in "ins" at "pos" is explicit (changeable)

BOOL LEVEL_CORE::INS_IsExplicitReadOnly const INS  ins,
const UINT32  pos
 

Test if a reg read in "ins" at "pos" is explicit (changeable) and read only

BOOL LEVEL_CORE::INS_IsFCmov INS  ins  ) 
 

Return TRUE if the INS is a float conditional move instruction

BOOL LEVEL_CORE::INS_IsFloat INS  ins  ) 
 

Return TRUE if the INS is an x87 floating point instruction

BOOL LEVEL_CORE::INS_IsFxrestore INS  ins  ) 
 

Return TRUE if the INS is an fxrstor instruction

BOOL LEVEL_CORE::INS_IsFxsave INS  ins  ) 
 

Return TRUE if the INS is an fxsave instruction

BOOL LEVEL_CORE::INS_IsImplicitRead const INS  ins,
const UINT32  pos
 

Test if a reg read in "ins" at "pos" is implicit (i.e. can't be changed to another reg)

BOOL LEVEL_CORE::INS_IsImplicitWrite const INS  ins,
const UINT32  pos
 

Test if a reg written in "ins" at "pos" is implicit (i.e. can't be changed to another reg)

BOOL LEVEL_CORE::INS_IsInc const INS  ins  ) 
 

returns true if this instruction is a increment.

BOOL LEVEL_CORE::INS_IsIOStringOp INS  ins  ) 
 

returns true if this instruction is an I/O string op.

BOOL LEVEL_CORE::INS_IsIpRelAddr INS  ins  ) 
 

This returns true for RIP-relative memops, NOT relative branches or calls.

BOOL LEVEL_CORE::INS_IsJCXZ INS  ins  ) 
 

Return TRUE if the INS is a JrCXZ instruction.

BOOL LEVEL_CORE::INS_IsJNZ INS  ins  ) 
 

Return TRUE if the INS is a JNZ instruction.

BOOL LEVEL_CORE::INS_IsJZ INS  ins  ) 
 

Return TRUE if the INS is a JZ instruction.

BOOL LEVEL_CORE::INS_IsLeave INS  ins  ) 
 

Return TRUE if the INS is a LEAVE instruction

BOOL LEVEL_CORE::INS_IsLoop INS  ins  ) 
 

Return TRUE if the INS is a LOOP instruction.

BOOL LEVEL_CORE::INS_IsLoope INS  ins  ) 
 

Return TRUE if the INS is a LOOPE instruction.

BOOL LEVEL_CORE::INS_IsLoopne INS  ins  ) 
 

Return TRUE if the INS is a LOOPNE instruction.

BOOL LEVEL_CORE::INS_IsLoopType const INS  ins  ) 
 

Return TRUE if the INS is a LOOP/LOOPE/LOOPNE instruction.

BOOL LEVEL_CORE::INS_IsMmx INS  ins  ) 
 

Return TRUE if the ins is an MMX instruction

BOOL LEVEL_CORE::INS_IsMMXorXMM const INS  ins  ) 
 

This is just for falcon bug compability. called by encoder -> can lead to infinite recursion

BOOL LEVEL_CORE::INS_IsMovImmToReg const INS  ins,
ADDRINT &  imm,
REG reg
 

return true if the mov reads an immediate and writes a register. Also return the immediate in the reference param imm

BOOL LEVEL_CORE::INS_IsMTSafeToPatch ADDRINT  addr,
USIZE  size
 

Check to see if an instruction, located in the specified range can be safely patched. The instruction is considered to be safe for patching if a) it is a one-byte instruction or b) it is fully contained in a single INS_PATCH_UNIT and its address is 2-byte aligned.

Note:
Patching multi-byte instructions involves overwriting the first 2 bytes of the instruction with a short jump to itself. The 2-byte alignment guarantees atomicity of this operation.
Parameters:
[in] addr address of the instruction
[in] size size of the instruction
Returns:
TRUE, if the instruction can be safely patched

BOOL LEVEL_CORE::INS_IsPatchable INS  ins  ) 
 

Return TRUE if the instruction is patchable

BOOL LEVEL_CORE::INS_IsPop const INS  ins  ) 
 

returns true if this instruction is a pop.

BOOL LEVEL_CORE::INS_IsPopAll16 INS  ins  ) 
 

Returns:
TRUE if ins is a 16-bit popa instruction.

BOOL LEVEL_CORE::INS_IsPopAll32 INS  ins  ) 
 

Returns:
TRUE if ins is a 32-bit popa instruction.

BOOL LEVEL_CORE::INS_IsPopF const INS  ins  ) 
 

Returns:
if ins is popf

BOOL LEVEL_CORE::INS_IsPopFD const INS  ins  ) 
 

Returns:
if ins is popfd

BOOL LEVEL_CORE::INS_IsPopFQ const INS  ins  ) 
 

Returns:
if ins is popfd

BOOL LEVEL_CORE::INS_IsPush const INS  ins  ) 
 

returns true if this instruction is a push.

BOOL LEVEL_CORE::INS_IsPushAll16 INS  ins  ) 
 

Returns:
TRUE if ins is a 16-bit pusha instruction.

BOOL LEVEL_CORE::INS_IsPushAll32 INS  ins  ) 
 

Returns:
TRUE if ins is a 32-bit pusha instruction.

BOOL LEVEL_CORE::INS_IsScas INS  ins  ) 
 

Return TRUE if the INS is a SCAS

BOOL LEVEL_CORE::INS_IsSetCC INS  ins  ) 
 

Return TRUE if the INS is a setcc instruction

BOOL LEVEL_CORE::INS_IsShift INS  ins  ) 
 

returns true if this instruction is a shift.

ADDRINT LEVEL_CORE::INS_IsSignedImmediate INS  ins  ) 
 

x

REG LEVEL_CORE::INS_IsSimpleRegIndirectRead INS  ins  ) 
 

Does ins use simple register indirect addressing mode for the read operand?

Returns:
The register being indirected, or REG_INVALID() if the instruction doesn't use a simple register indirect address mode.

REG LEVEL_CORE::INS_IsSimpleRegIndirectWrite INS  ins  ) 
 

ins use simple register indirect addressing mode for its write operand. This is to flag instructions whose EA can be determined with a simple register mov Since this is for the write operand we know that we can't allow pop, since that pre-increments.

Returns:
The register being indirected, or REG_INVALID() if the instruction doesn't use a simple register indirect address mode.

BOOL LEVEL_CORE::INS_IsSimpleStackOffsetRead INS  ins,
INT32 *  offset
 

ins use simple stack indirect plus offset addressing mode

BOOL LEVEL_CORE::INS_IsSimpleStackOffsetWrite INS  ins,
INT32 *  offset
 

ins use simple stack indirect plus offset addressing mode

BOOL LEVEL_CORE::INS_IsSse INS  ins  ) 
 

Return TRUE iff the ins is an SSE instruction

BOOL LEVEL_CORE::INS_IsStringOp INS  ins  ) 
 

returns true if this instruction is a string op.

BOOL LEVEL_CORE::INS_IsUJmp INS  ins  ) 
 

Return TRUE if the INS is a Unconditional branch instruction

BOOL LEVEL_CORE::INS_IsXlat INS  ins  ) 
 

Returns:
true if the instruction is XLAT.

BOOL LEVEL_CORE::INS_IsXrestore INS  ins  ) 
 

Return TRUE if the INS is an xrstor instruction

BOOL LEVEL_CORE::INS_IsXsave INS  ins  ) 
 

Return TRUE if the INS is an xsave instruction

BOOL LEVEL_CORE::INS_IsXsavec INS  ins  ) 
 

Return TRUE if the INS is an xsavec instruction

BOOL LEVEL_CORE::INS_IsXsaveFamily INS  ins  ) 
 

Return TRUE iff the ins is an instruction from the xsave family

BOOL LEVEL_CORE::INS_IsXsaveopt INS  ins  ) 
 

Return TRUE if the INS is an xsaveopt instruction

VOID LEVEL_CORE::INS_MakeAbsolute32Address INS  ins,
IADDR  target
 

rewrite the memory operand to be a memory reference using just a 32b displacement

VOID LEVEL_CORE::INS_MakeBaseAddress INS  ins,
REG  base
 

Rewrite memop to use base register address mode

VOID LEVEL_CORE::INS_MarkBblStart INS  ins  ) 
 

Before BBLs and RTNs are created all INSs are stored in one long list. This routine marks an INS as beginning a new BBL

BOOL LEVEL_CORE::INS_MarkedForDeletion INS  ins  ) 
 

Is this instruction marked for deletion?

VOID LEVEL_CORE::INS_MarkForDeletion INS  ins  ) 
 

Mark this instruction for deletion,

VOID LEVEL_CORE::INS_MarkRtnStart INS  ins  ) 
 

Before BBLs and RTNs are created all INSs are stored in one long list. This routine marks an INS as beginning a new RTN

int LEVEL_CORE::INS_MaxDecodedBytes  ) 
 

return the maximum bytes that are accessed b decoding one instruction

USIZE LEVEL_CORE::INS_MaxProbeSize BOOL  requestRipAndAddrProbe  ) 
 

Returns:
Maximum size in bytes of a probe

BOOL LEVEL_CORE::INS_MayWriteAllMMRegisters INS  ins  ) 
 

Returns true if the ins conditionally writes all the (X/Y)MM registers.

BOOL LEVEL_CORE::INS_MemopDisplacementOnly INS  ins  ) 
 

Only displacement may be in memory operand for this opcode For example, mov eax, gs:0x8

ADDRINT LEVEL_CORE::INS_MemoryDisplacementWidthBytes INS  ins  ) 
 

Return width of memory offset in BYTES

LOCALFUN BOOL LEVEL_CORE::INS_MTSafeOverwrite INS  ins,
ADDRINT  addr,
USIZE  size
 

Safely write (encode) the specified instruction in place of another instruction, while taking in account that other threads may concurrently execute code in this location. These threads will execute either the original instruction or the new one but never fetch a partially updated instruction.

Precondition:
The original instruction should be in a patch-safe location (see INS_IsMTSafeToPatch())

The size of the new instruction should not exceed the size of the original instruction

The new instruction must be an unconditional jump if it overwrites the original instruction partially

Parameters:
[in] ins instruction to be written in place of the original one
[in] addr address of the original instruction
[in] size size of the original instruction
Returns:
TRUE/FALSE - success/failure

BOOL LEVEL_CORE::INS_MTSafePatchBranch OADDR  brAddr,
OADDR  tgtAddr
 

Change the target of a direct branch instruction, while preserving all other instruction attributes (opcode, etc.). This operation is safe, even if another thread is executing the branch while this thread is modifying it. Other threads will jump to either the original address or the new target address but never fetch a partially updated branch.

Precondition:
The instruction should be in a patch-safe location (see INS_IsMTSafeToPatch())
Parameters:
[in] brAddr address of the branch
[in] tgtAddr new target address of the branch
Returns:
TRUE/FALSE - success/failure

BOOL LEVEL_CORE::INS_MTSafeWriteJmp OADDR  insAddr,
OADDR  tgtAddr
 

Safely write (encode) an unconditional direct jump in place of another instruction, while taking in account that other threads may concurrently execute code in this location. These threads will execute either the original instruction or jump to the new target but never fetch a partially updated instruction.

Precondition:
The original instruction should be in a patch-safe location (see INS_IsMTSafeToPatch())

The size of the original instruction should be at least the size of the unconditional direct jump (see INS_SizeOfDirectJmp())

Parameters:
[in] insAddr address of the original instruction
[in] tgtAddr target address of the branch
Returns:
TRUE/FALSE - success/failure

INS LEVEL_CORE::INS_next INS  x  ) 
 

return next INS in the (doubly) linked list of INSs, a common idiom to (forward) iterate over all INSs in BBL is

for(INS ins = BBL_ins_head(bbl); INS_valid(ins); ins = INS_next(ins)

IADDR LEVEL_CORE::INS_NextInsIaddr INS  ins  ) 
 

Compute the address of the next isntruction

OADDR LEVEL_CORE::INS_NextInsOaddr INS  ins,
OADDR  addr
 

x

UINT32 LEVEL_CORE::INS_NumAttrCrosslink INS  ins  ) 
 

if an INS has any of these atributes it cannot be freed

UINT32 LEVEL_CORE::INS_NumExt INS  parent  ) 
 

x

BOOL LEVEL_CORE::INS_OperandIsGsOrFsReg INS  ins  ) 
 

Returns:
TRUE if one of the instruction operands is explicitly FS or GS This does not include access via a segment register prefix used for addressing, even though that does implicitly read the segment register (and so appears in the read register set of the instruction).

UINT32 LEVEL_CORE::INS_orig_size INS  x  ) 
 

Returns:
Returns original size of instruction in bytes

VOID LEVEL_CORE::INS_orig_size_set INS  x,
UINT32  y
 

Sets original size of instruction in bytes

FLAGS LEVEL_CORE::INS_PhyFlagsMayWritten const INS  ins  ) 
 

Return the physical flags (DF, OF, SF, ZF, AF, pf, CF) that this ins must or may write. Even if the ins does not always write one of these flags, it will be set in the returned FLAGS

Parameters:
[in] ins The INS whose phys flags written are to be obtained
Returns:
the FLAGS the ins may or must write

FLAGS LEVEL_CORE::INS_PhyFlagsMustWritten const INS  ins  ) 
 

Return the physical flags (DF, OF, SF, ZF, AF, pf, CF) that this ins always (must) write. If the ins does not always write one of these flags, it will not be set in the returned FLAGS

Parameters:
[in] ins The INS whose phys flags written are to be obtained
Returns:
the FLAGS the ins definitely (must) writes

FLAGS LEVEL_CORE::INS_PhyFlagsRead const INS  ins  ) 
 

Return the physical flags (DF, OF, SF, ZF, AF, pf, CF) that this ins reads.

Parameters:
[in] ins The INS whose phys flags read are to be obtained
Returns:
the FLAGS the ins reads

BOOL LEVEL_CORE::INS_PrefixIsGsOrFsReg INS  ins  ) 
 

Returns:
TRUE if instruction prefix is GS or FS

VOID LEVEL_CORE::INS_Prepend INS  ins,
BBL  parent
 

x

INS LEVEL_CORE::INS_prev INS  x  ) 
 

return previous INS in the (doubly) linked list of INSs, a common idiom to (backward) iterate over all INSs in BBL is

for(INS ins = BBL_ins_tail(bbl); INS_valid(ins); ins = INS_prev(ins)

string LEVEL_CORE::INS_PrintString INS  ins,
ADDRINT  addr
 

x

INT32 LEVEL_CORE::INS_RawEncodeIns INS  ins,
UINT8 *  buffer
 

Returns:
The encoded length in bytes, or 0 on invalid encodings.

LOCALFUN string LEVEL_CORE::INS_RawInstBytes INS  ins  ) 
 

x

BOOL LEVEL_CORE::INS_ReadsAllMMRegisters INS  ins  ) 
 

Returns true if the ins reads all the (X/Y)MM registers.

BOOL LEVEL_CORE::INS_ReadsAllMmxRegisterss INS  ins  ) 
 

Returns true if the ins writes all the mmx registers.

VOID LEVEL_CORE::INS_RegRSet INS  x,
UINT32  k,
REG  r
 

set kth read register of instruction x

BOOL LEVEL_CORE::INS_RegsReadBeforeWritten INS  ins  ) 
 

Return TRUE if all registers read by the ins are read before any register is set. Currently used for optimization, so it is OK to return a false negative.

VOID LEVEL_CORE::INS_RegWSet INS  x,
UINT32  k,
REG  r
 

set kth write register of instruction x

VOID LEVEL_CORE::INS_RemoveRep INS  ins  ) 
 

Remove a (real) rep prefix from an instruction. The instruction better have one, or this will assert!

Parameters:
[in] ins The instruction to change.

VOID LEVEL_CORE::INS_RenameRegsForInlining CALLING_STANDARD  std,
INS  ins
 

Rename application regs to their corresponding pin regs in ins.

FIXME: RM REWRITE TO USE THE REGR/REGW ARRAYS

VOID LEVEL_CORE::INS_ReplaceMemop INS  ins,
unsigned int  operand_index,
REG  base,
ADDRDELTA  displacement,
REG  index,
ADDRINT  scale,
REG  pinseg,
REGWIDTH  ea_width
 

INS_ReplaceMemop() - replace all components of memory operand

VOID LEVEL_CORE::INS_scan_for_memop_info INS  ins,
REG base0,
REG index,
ADDRINT &  offset,
ADDRINT &  scale,
REG base1,
REG seg0,
REG seg1
 

Pull out all the operands of a memory references

UINT8 LEVEL_CORE::INS_set_num_reads INS  x,
UINT  v
 

Sets the number of registers read by this instruction

UINT8 LEVEL_CORE::INS_set_num_writes INS  x,
UINT  v
 

Sets the number of registers written by this instruction

VOID LEVEL_CORE::INS_set_reg_r INS  x,
UINT  i,
REG  r
 

Sets the ith read register. This function uses INS_get_pos_r on the same register, make sure to set it (using INS_set_pos_r) before calling this function.

VOID LEVEL_CORE::INS_set_reg_w INS  x,
UINT  i,
REG  r
 

Sets the ith written register. This function uses INS_get_pos_w on the same register, make sure to set it (using INS_set_pos_w) before calling this function.

VOID LEVEL_CORE::INS_SetBranchDisplacement INS  ins,
ADDRDELTA  disp,
UINT  length_bytes
 

x

VOID LEVEL_CORE::INS_SetDirty INS  ins  ) 
 

mark that the instruction encoding in the cache is not valid

VOID LEVEL_CORE::INS_SetImmediate INS  ins,
ADDRINT  imm
 

Change the immediate field of an instruction. The new immediate value must fit in the existing field's width.

Parameters:
[in] ins The instruction to change.
[in] imm The new immediate value.

VOID LEVEL_CORE::INS_SetIndexRegister INS  ins,
REG  newIndex
 

rewrite the memory operand to use the given index register, rather than whatever was already there.

VOID LEVEL_CORE::INS_SetMemoryDisplacement INS  ins,
ADDRDELTA  disp,
UINT  length_bytes
 

x

VOID LEVEL_CORE::INS_SetReg INS  ins,
UINT  i,
REG  r,
BOOL  read
 

If read is TRUE, sets the ith read register, otherwise the ith written register

VOID LEVEL_CORE::INS_SetRegisterOperand INS  ins,
UINT32  operand,
REG  newReg
 

rewrite a register operand to use the given register.

VOID LEVEL_CORE::INS_SignExtend BBL  bbl,
REG  src,
REG  dst
 

Append code to sign extend src to dst

USIZE LEVEL_CORE::INS_SizeOfDirectJmp  ) 
 

Returns:
size of the unconditional, direct jump instruction with a 32-bit displacement

USIZE LEVEL_CORE::INS_SizeOfIpRelativeMemJmp  ) 
 

Returns:
size of the unconditional, jmp [gip]offset

string LEVEL_CORE::INS_StringLong INS  ins  ) 
 

x

string LEVEL_CORE::INS_StringShort INS  ins  ) 
 

x

string LEVEL_CORE::INS_StringShorter INS  ins  ) 
 

x

string LEVEL_CORE::INS_StringShortFancy INS  ins  ) 
 

produce a string for INS extended by profile and exception information

string LEVEL_CORE::INS_StringXed INS  ins  ) 
 

x

BOOL LEVEL_CORE::INS_SyscallHasFallThrough INS  ins  ) 
 

Returns:
true if specified syscall instruction is modeled as a fallthrough instruction

BOOL LEVEL_CORE::INS_SyscallIsTakenBranch INS  ins  ) 
 

Returns:
true if specified syscall instruction is modeled as a taken branch

LOCALFUN SYSCALL_TYPE LEVEL_CORE::INS_SyscallType INS  ins  ) 
 

Returns:
the syscall type

PREDICATE_IA32 LEVEL_CORE::INS_TestedCondition INS  ins  ) 
 

Returns:
the condition tested by an instruction (should only be used on instructions which do test a condition).

VOID LEVEL_CORE::INS_Unlink INS  ins  ) 
 

Unlink INS from BBL

BOOL LEVEL_CORE::INS_ValidateEncoding const INS  ins  ) 
 

Validate the encoding of ins.

VOID LEVEL_CORE::INS_Vinsertf128FromMem INS  ins,
REG  ymmDest,
REG  ymmSrc1,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
UINT8  imm8
 

Generate a Vinsertf128 from memory.

VOID LEVEL_CORE::INS_Vinsertf32x4FromMem INS  ins,
REG  zmmDest,
REG  zmmSrc1,
REG  maskReg,
REG  base,
INT32  displacement,
REG  index,
UINT  scale,
REG  seg,
UINT8  imm8
 

Generate a Vinsertf32x4 from memory.

BOOL LEVEL_CORE::INS_WritesAllMMRegisters INS  ins  ) 
 

Returns true if the ins writes all the (X/Y)MM registers.

BOOL LEVEL_CORE::INS_WritesAllMmxRegisters INS  ins  ) 
 

Returns true if the ins writes all the mmx registers.

xed_decoded_inst_t* LEVEL_CORE::INS_xed_dec INS  ins  ) 
 

Returns:
This provides the pointer to the decoded Intel(R) X86 Encoder Decoder instruction.

xed_operand_values_t* LEVEL_CORE::INS_xed_operand_values INS  ins  ) 
 

Returns:
This provides the pointer to the decoded Intel(R) X86 Encoder Decoder instruction operand values.

VOID LEVEL_CORE::INS_XED_replace_dummy INS  ins,
xed_reg_enum_t  xedreg,
REG  pin_virt_reg,
xed_operand_enum_t  role,
UINT  xedpos
 

Replace xedreg with pinreg in the flat regs

Returns:
foo

VOID LEVEL_CORE::INS_ZeroExtend BBL  bbl,
REG  src,
REG  dst
 

Append code to zero extend src to dst

ARRAYBASE LEVEL_CORE::InsArrayBase "ins pool"  ,
1024 *  1024
 

The root for all BBL stripes

INS_REUSERS_MANAGER& LEVEL_CORE::InsReusersManager  ) 
 

Return the single instance (object) of the INS_REUSERS_MANAGER class

STRIPE<INS_STRUCT_BASE> LEVEL_CORE::InsStripeBase "ins stripe base"  ,
"core"  ,
InsArrayBase
 

The base stripe for INS

STRIPE<INS_STRUCT_MAP> LEVEL_CORE::InsStripeMap "ins stripe map"  ,
"map"  ,
InsArrayBase
 

x

STRIPE<INS_STRUCT_SPARSE> LEVEL_CORE::InsStripeSparse "ins stripe sparse"  ,
"pincore"  ,
InsArrayBase
 

x

STRIPE<INS_XED_STRUCT_DECODE> LEVEL_CORE::InsStripeXEDDecode "ins stripe Intel(R) X86 Encoder Decoder ia32 decoded"  ,
"core"  ,
InsArrayBase
 

The stripe data structure for Intel(R) X86 Encoder Decoder decoded instructions.

STRIPE<INS_XED_STRUCT_ENCODE> LEVEL_CORE::InsStripeXEDEncode "ins stripe Intel(R) X86 Encoder Decoder ia32 encoded"  ,
"core"  ,
InsArrayBase
 

The stripe data structure for Intel(R) X86 Encoder Decoder encoded instructions.

LOCALFUN INT32 LEVEL_CORE::INT_Immediate xed_decoded_inst_t *  xedd  ) 
 

Return the immediate field of an INT instruction.

Parameters:
[in] xedd The INT instruction
Returns:
Returns the immediate field.

UINT32 LEVEL_CORE::InvalidSysCallNumber  ) 
 

Return integer that represents invalid syscall number

xed_iclass_enum_t LEVEL_CORE::JccIclassToCmovcc INS  ins  ) 
 

Returns:
cmov with equivalent test as jmp

KNOB<BOOL> LEVEL_CORE::knob_cet_mode KNOB_MODE_WRITEONCE  ,
"supported:xed"  ,
"xed_cet_mode"  ,
"0"  ,
"Enable Intel(R) CET instruction decoding" 
 

Determines if Intel(R) CET instructions are enabled: 0 - Some CET instructions decode as NOPs 1 - Some NOPs decode as Intel CET instructions

KNOB<BOOL> LEVEL_CORE::knob_mpx_mode KNOB_MODE_WRITEONCE  ,
"supported:xed"  ,
"xed_mpx_mode"  ,
"0"  ,
"Enable Intel(R) MPX instruction decoding" 
 

Determines if Intel(R) MPX instructions are enabled: 0 - the instructions decode as NOPs 1 - the instructions decode as Intel MPX instructions

KNOB<BOOL> LEVEL_CORE::KnobAttachComment KNOB_MODE_WRITEONCE  ,
"supported"  ,
"comment"  ,
"0"  ,
"Attach comments to data structures" 
 

When TRUE, attach comments to data structures

KNOB<BOOL> LEVEL_CORE::KnobRegFlagsSplit KNOB_MODE_WRITEONCE  ,
"supported:regalloc"  ,
"flags_split"  ,
"1"  ,
"split eflags representation" 
 

Knob to control whether split flags representation into two: DF Other status regs Note - if KnobRegUseSahf is set to 0, then this knob has no effect - and flags reg is NOT split

KNOB<BOOL> LEVEL_CORE::KnobRegUseSahf KNOB_MODE_WRITEONCE  ,
"supported:regalloc"  ,
"use_sahf"  ,
"1"  ,
"use sahf lahf to save restore eflags" 
 

Knob to control whether to use sahf and lahf in flag fill/spill code sequence

KNOB<BOOL> LEVEL_CORE::KnobSegmentEffectiveAddresses KNOB_MODE_WRITEONCE  ,
"supported:region"  ,
"segment_ea"  ,
"1"  ,
"Computation of effective addresses with seg override\n" 
 

Switches on/off support for IARG_MEMORY_{READ,WRITE}_EA for segmented addresses

  • currently supported only on Windows Linux and BSD

KNOB<BOOL> LEVEL_CORE::KnobUseInsReusing KNOB_MODE_WRITEONCE  ,
"supported:regalloc"  ,
"ins_reusing"  ,
"1"  ,
"Enable ins reusing" 
 

x

KNOB<BOOL> LEVEL_CORE::KnobVirtualSegments KNOB_MODE_OVERWRITE  ,
"supported:region"  ,
"virtual_segments"  ,
KNOB_ONLY_ON_UNIX  ,
"Virtual access to segment registers\n" 
 

Switches on/off emulation of GDT/LDT tables and access to memory through segments selectors

PREG LEVEL_CORE::MAKE_PREG INT32  y  ) 
 

Convert integer into PREG

REGVALUE LEVEL_CORE::MAKE_PTR_REGVALUE const VOID *  y  ) 
 

Convert pointer into REGVALUE

REGVALUE LEVEL_CORE::MAKE_REGVALUE ADDRINT  y  ) 
 

Convert integer into REGVALUE

REGVALUE LEVEL_CORE::MemoryLoadRegvalue REGVALUE  address  ) 
 

Read REGVALUE from the specified memory location

REGVALUE128 LEVEL_CORE::MemoryLoadRegvalue128 ADDRINT  address,
UINT32  sizeInBytes
 

Read REGVALUE128 from the specified memory location. Truncate or zero-extend the sequence of bytes, if necessary.

REGVALUE256 LEVEL_CORE::MemoryLoadRegvalue256 ADDRINT  address,
UINT32  sizeInBytes
 

Read REGVALUE256 from the specified memory location. Truncate or zero-extend the sequence of bytes, if necessary.

REGVALUE512 LEVEL_CORE::MemoryLoadRegvalue512 ADDRINT  address,
UINT32  sizeInBytes
 

Read REGVALUE512 from the specified memory location. Truncate or zero-extend the sequence of bytes, if necessary.

VOID LEVEL_CORE::MemoryStoreRegvalue REGVALUE  address,
REGVALUE  value
 

Write the specified REGVALUE into the specified memory location.

VOID LEVEL_CORE::MemoryStoreRegvalue128 ADDRINT  address,
const REGVALUE128 &  value,
UINT32  sizeInBytes
 

Write the specified REGVALUE128 into the specified memory location. Truncate or zero-extend the register value, if necessary.

VOID LEVEL_CORE::MemoryStoreRegvalue256 ADDRINT  address,
const REGVALUE256 &  value,
UINT32  sizeInBytes
 

Write the specified REGVALUE256 into the specified memory location. Truncate or zero-extend the register value, if necessary.

VOID LEVEL_CORE::MemoryStoreRegvalue512 ADDRINT  address,
const REGVALUE512 &  value,
UINT32  sizeInBytes
 

Write the specified REGVALUE512 into the specified memory location. Truncate or zero-extend the register value, if necessary.

LOCALVAR MESSAGE_TYPE LEVEL_CORE::MessageTypeLogEncoding "log_encoding"  ,
""  ,
false  ,
false  ,
false  ,
true  ,
LOGTYPE_LOGFILE  ,
"pin log: encodings" 
 

messages associated with fast buffering API

LOCALVAR MESSAGE_TYPE LEVEL_CORE::MessageTypeLogInsReuse "log_ins_reuse"  ,
""  ,
false  ,
false  ,
false  ,
false  ,
LOGTYPE_LOGFILE  ,
"pin log: ins_reusing" 
 

messages associated with fast buffering API

SYSCALL_STANDARD LEVEL_CORE::NativeSysCallStd  ) 
 

Return (single) system call standard for the current OS and architecture.

REG LEVEL_CORE::PREG_2_REG PREG  pr  ) 
 

Convert a physical register into the corresponding virtual register

BOOL LEVEL_CORE::REG_IsRewrittenSegmentReg REG  reg  ) 
 

Feels as if there should be a better group for this? Is the register a rewritten segment register?

INT32 LEVEL_CORE::REG_NumSysCallArgRegs SYSCALL_STANDARD  std = NativeSysCallStd()  ) 
 

Number of syscall arguments passed in registers.

const UINT64& LEVEL_CORE::REG_ReadKMaskFromFxsave const REG  kmask,
const FPSTATE *  fpstate
 

Read an K mask register value from an 'fxsave' data structure.

Parameters:
[in] kmask The K mask register number.
[in] fpstate The 'fxsave' data structure where the K mask register value is read from.
Returns:
The value of the K mask register.

REGVALUE LEVEL_CORE::REG_ReadPseudo REG  reg  ) 
 

Read the value of a pseudo register.

Parameters:
[in] reg The pseudo register number.
Returns:
The value of the pseudo register.

REGVALUE LEVEL_CORE::REG_ReadShortFpFromFpstate REG  reg,
const FPSTATE *  fpstate
 

Read a short FP register value from an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] fpstate The 'fxsave' data structure where the FP register value is read from.
Returns:
The value of the FP register.

REGVALUE LEVEL_CORE::REG_ReadShortFpFromFxsave REG  reg,
const FXSAVE *  fxsave
 

Read a short FP register value from an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] fpstate The 'fxsave' data structure where the FP register value is read from.
Returns:
The value of the FP register.

const REGVALUE128& LEVEL_CORE::REG_ReadStFromFpstate REG  reg,
const FPSTATE *  fpstate
 

Read a stacked FP register value from an 'fpstate' data structure.

Parameters:
[in] reg The FP register number.
[in] fpstate The 'fpstate' data structure where the FP register value is read from.
Returns:
The value of the FP register.

VOID LEVEL_CORE::REG_ReadStFromFpstate REG  reg,
const FPSTATE *  fpstate,
VOID *  val
 

Read a stacked FP register value from an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] fpstate The 'fxsave' data structure where the FP register value is read from.
[out] val The value of the FP register.

const REGVALUE128& LEVEL_CORE::REG_ReadStFromFxsave REG  reg,
const FXSAVE *  fxsave
 

Read a stacked FP register value from an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] fxsave The legacy 'fxsave' data structure where the FP register value is read from.
Returns:
The value of the FP register.

VOID LEVEL_CORE::REG_ReadStFromFxsave REG  reg,
const FXSAVE *  fxsave,
VOID *  val
 

Read a stacked FP register value from an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] fxsave The legacy 'fxsave' data structure where the FP register value is read from.
[out] val The value of the FP register.

VOID LEVEL_CORE::REG_ReadXmmFromFxsave const REG  xmm,
const FPSTATE *  fpstate,
VOID *  val
 

Read an XMM register value from an 'fxsave' data structure.

Parameters:
[in] xmm The XMM register number.
[in] fpstate The 'fxsave' data structure where the XMM register value is read from.
[out] val The value of the XMM register.

const REGVALUE128& LEVEL_CORE::REG_ReadXmmFromFxsave const REG  xmm,
const FPSTATE *  fpstate
 

Read an XMM register value from an 'fxsave' data structure.

Parameters:
[in] xmm The XMM register number.
[in] fpstate The 'fxsave' data structure where the XMM register value is read from.
Returns:
The value of the XMM register.

REGVALUE256 LEVEL_CORE::REG_ReadYmmFromFxsave const REG  ymm,
const FPSTATE *  fpstate
 

Read an YMM register value from an 'xsave' data structure.

Parameters:
[in] ymm The YMM register number.
[in] fpstate The 'xsave' data structure where the YMM register value is read from.
Returns:
The value of the YMM register.

VOID LEVEL_CORE::REG_ReadYmmFromFxsave const REG  ymm,
const FPSTATE *  fpstate,
VOID *  val
 

Read an YMM register value from an 'xsave' data structure.

Parameters:
[in] ymm The YMM register number.
[in] fpstate The 'xsave' data structure where the YMM register value is read from.
[out] val The value of the YMM register.

const REGVALUE512 LEVEL_CORE::REG_ReadZmmFromFxsave const REG  zmm,
const FPSTATE *  fpstate
 

Read an ZMM register value from an 'fxsave' data structure.

Parameters:
[in] zmm The ZMM register number.
[in] fpstate The 'fxsave' data structure where the ZMM register value is read from.
Returns:
The value of the ZMM register.

VOID LEVEL_CORE::REG_ReadZmmFromFxsave const REG  zmm,
const FPSTATE *  fpstate,
VOID *  val
 

Read an ZMM register value from an 'fxsave' data structure.

Parameters:
[in] zmm The ZMM register number.
[in] fpstate The 'fxsave' data structure where the ZMM register value is read from.
[out] val The value of the ZMM register.

REG LEVEL_CORE::REG_RenameAppReg const REG  reg  ) 
 

Given an application reg return its corresponding pin register

REG LEVEL_CORE::REG_RenamePinReg const REG  reg  ) 
 

Give a pin reg return its corresponding application register

BOOL LEVEL_CORE::REG_ShouldBeRenamed CALLING_STANDARD  std,
REG  reg
 

Find out if reg should be renamed in the inlined analysis routine.

VOID LEVEL_CORE::REG_StoreKMaskToFxsave const REG  kmask,
const UINT64 &  val,
FPSTATE *  fpstate
 

Store an K mask register value to an 'fxsave' data structure.

Parameters:
[in] kmask The K mask register number.
[in] val The value of the K mask register.
[out] fpstate The 'fxsave' data structure which receives the K mask register value.

VOID LEVEL_CORE::REG_StorePseudo REG  reg,
REGVALUE  val
 

Write the value of a pseudo register.

Parameters:
[in] reg The pseudo register number.
[in] val The value.

VOID LEVEL_CORE::REG_StoreShortFpToFpstate REG  reg,
const REGVALUE  val,
FPSTATE *  fpstate
 

Store a short FP register value to an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fpstate The 'fpstate' data structure which receives the FP register value.

VOID LEVEL_CORE::REG_StoreShortFpToFxsave REG  reg,
const REGVALUE  val,
FXSAVE *  fxsave
 

Store a short FP register value to an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fxsave The 'fxsave' data structure which receives the FP register value.

VOID LEVEL_CORE::REG_StoreStToFpstate REG  reg,
const REGVALUE128 &  val,
FPSTATE *  fpstate
 

Store a stacked FP register value to an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fpstate The 'fpstate' data structure which receives the FP register value.

VOID LEVEL_CORE::REG_StoreStToFpstate REG  reg,
const VOID *  val,
FPSTATE *  fpstate
 

Store a stacked FP register value to an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fpstate The 'fpstate' data structure which receives the FP register value.

VOID LEVEL_CORE::REG_StoreStToFxsave REG  reg,
const REGVALUE128 &  val,
FXSAVE *  fxsave
 

Store a stacked FP register value to an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fxsave The 'fxsave' data structure which receives the FP register value.

VOID LEVEL_CORE::REG_StoreStToFxsave REG  reg,
const VOID *  val,
FXSAVE *  fxsave
 

Store a stacked FP register value to an 'fxsave' data structure.

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fxsave The 'fxsave' data structure which receives the FP register value.

VOID LEVEL_CORE::REG_StoreXmmToFxsave const REG  xmm,
const VOID *  val,
FPSTATE *  fpstate
 

Store an XMM register value to an 'fxsave' data structure.

Parameters:
[in] xmm The XMM register number.
[in] val The value of the XMM register.
[out] fpstate The 'fxsave' data structure which receives the XMM register value.

VOID LEVEL_CORE::REG_StoreXmmToFxsave const REG  xmm,
const REGVALUE128 &  val,
FPSTATE *  fpstate
 

Store an XMM register value to an 'fxsave' data structure.

Parameters:
[in] xmm The XMM register number.
[in] val The value of the XMM register.
[out] fpstate The 'fxsave' data structure which receives the XMM register value.

VOID LEVEL_CORE::REG_StoreYmmToFxsave const REG  ymm,
const VOID *  val,
FPSTATE *  fpstate
 

Store an YMM register value to an 'xsave' data structure.

Parameters:
[in] ymm The YMM register number.
[in] val The value of the YMM register.
[out] fpstate The 'xsave' data structure which receives the YMM register value.

VOID LEVEL_CORE::REG_StoreYmmToFxsave const REG  ymm,
const REGVALUE256 &  val,
FPSTATE *  fpstate
 

Store an YMM register value to an 'xsave' data structure.

Parameters:
[in] ymm The YMM register number.
[in] val The value of the YMM register.
[out] fpstate The 'xsave' data structure which receives the YMM register value.

VOID LEVEL_CORE::REG_StoreZmmToFxsave const REG  zmm,
const VOID *  val,
FPSTATE *  fpstate
 

Store an ZMM register value to an 'fxsave' data structure.

Parameters:
[in] zmm The ZMM register number.
[in] val The value of the ZMM register.
[out] fpstate The 'fxsave' data structure which receives the ZMM register value.

VOID LEVEL_CORE::REG_StoreZmmToFxsave const REG  zmm,
const REGVALUE512 &  val,
FPSTATE *  fpstate
 

Store an ZMM register value to an 'fxsave' data structure.

Parameters:
[in] zmm The ZMM register number.
[in] val The value of the ZMM register.
[out] fpstate The 'fxsave' data structure which receives the ZMM register value.

REG LEVEL_CORE::REG_SysCallArgReg INT32  ith_arg,
SYSCALL_STANDARD  std = NativeSysCallStd()
 

Return the register that holds the ith syscall argument

REG LEVEL_CORE::REG_SysCallErrno SYSCALL_STANDARD  std = NativeSysCallStd()  ) 
 

Return the register that holds the errno value from a system call.

REG LEVEL_CORE::REG_SysCallNumber SYSCALL_STANDARD  std = NativeSysCallStd()  ) 
 

Return the register that holds the syscall number

REG LEVEL_CORE::REG_SysCallResult SYSCALL_STANDARD  std = NativeSysCallStd()  ) 
 

Return the register that holds the syscall result

REGSET LEVEL_CORE::REGSET_SyscalleeSavedGr SYSCALL_STANDARD  std = NativeSysCallStd()  ) 
 

Registers saved in syscall

VOID LEVEL_CORE::REGSYM_InsertBefore SYM  sym,
SYM  before,
IMG  parent
 

Insert Before

VOID LEVEL_CORE::REGSYM_Unlink SYM  sym  ) 
 

unlink a SYM from an IMG

REL_TYPE LEVEL_CORE::REL_AddrintRel  ) 
 

rel type for an address

REL LEVEL_CORE::REL_Alloc  ) 
 

Allocate a REL

VOID LEVEL_CORE::REL_Check REL  rel  ) 
 

x

REL LEVEL_CORE::REL_First  ) 
 

VOID LEVEL_CORE::REL_Free REL  rel  ) 
 

Deallocate an unlinked REL

LOCALFUN VOID LEVEL_CORE::REL_LinkChunkoff REL  rel,
CHUNK  parent,
UINT32  offset
 

Unlink REL from CHUNK

VOID LEVEL_CORE::REL_MoveoverBblValues const BBL  src,
const BBL  dst
 

Move over all relocations that have values pointing to src to become pointing to dst.

VOID LEVEL_CORE::REL_MoveoverInsValues const INS  src,
const INS  dst
 

Move over all relocations that have values pointing to src to become pointing to dst.

REL LEVEL_CORE::REL_Next REL  rel  ) 
 

string LEVEL_CORE::REL_StringShort REL  rel  ) 
 

convert a REL into a printable string - short version (no newline)

VOID LEVEL_CORE::REL_TargetSetAndLinkChunkoff REL  rel,
REL_TYPE  type,
CHUNK  parent,
UINT32  offset
 

Append REL to SEC

VOID LEVEL_CORE::REL_TargetSetAndLinkIns REL  rel,
REL_TYPE  type,
INS  ins
 

Initialize the specified relocation element and link it to the specified instruction

Parameters:
[in] rel relocation element to be initialized
[in] type type of the relocation. This must be a REL_TYPE_INS_* type
[in] ins istruction to be patched by the relocation

VOID LEVEL_CORE::REL_UnlinkChunk REL  rel  ) 
 

Unlink REL from CHUNK

BOOL LEVEL_CORE::REL_ValueEqual REL  rel,
REL  master
 

compare the value of two relocations this contains a little hack as we do not want to switch through the value types

VOID LEVEL_CORE::REL_ValueSetBbl REL  rel,
BBL  bbl
 

set the value of a REL (to SYM)

VOID LEVEL_CORE::REL_ValueSetChunk REL  rel,
CHUNK  chunk
 

set the value of a REL (to SYM)

VOID LEVEL_CORE::REL_ValueSetChunkoff REL  rel,
CHUNK  chunk,
USIZE  off
 

set the value of a REL (to SYM) this is the third step after allocating a REL

VOID LEVEL_CORE::REL_ValueSetGot REL  rel,
GOT  got
 

set the value of a REL (to GP)

VOID LEVEL_CORE::REL_ValueSetIns REL  rel,
INS  ins
 

set the value of a REL (to SYM)

VOID LEVEL_CORE::REL_ValueSetLdef REL  rel,
LDEF  ldef
 

set the value of a REL (to GP)

VOID LEVEL_CORE::REL_ValueSetSymoff REL  rel,
SYM  sym,
UINT32  off
 

set the value of a REL (to SEC + offset)

VOID LEVEL_CORE::REL_ValueSetUint32 REL  rel,
UINT32  v
 

set the value of a REL (to 32 bit constant)

VOID LEVEL_CORE::REL_ValueSetUint64 REL  rel,
UINT64  v
 

set the value of a REL (to 64 bit constant)

VOID LEVEL_CORE::REL_ValueSetZero REL  rel  ) 
 

set the value of a REL (to ZERO)

VOID LEVEL_CORE::REL_ValueUnlink REL  rel,
BOOL  relax
 

x

ARRAYBASE LEVEL_CORE::RelArrayBase "rel pool"  ,
1024 *  1024
 

The root for all REL stripes

STRIPE<REL_STRUCT_BASE> LEVEL_CORE::RelStripeBase "rel stripe base"  ,
"core"  ,
RelArrayBase
 

The base stripe for REL

RTN LEVEL_CORE::RTN_Alloc  ) 
 

Allocate a new RTN

VOID LEVEL_CORE::RTN_Append RTN  rtn,
SEC  parent
 

Append RTN to SEC

UINT32 LEVEL_CORE::RTN_ByteSize RTN  rtn  ) 
 

Compute number of static INSs inside RTN

VOID LEVEL_CORE::RTN_ExtInsertAfter EXT  ext,
EXT  after,
RTN  parent
 

VOID LEVEL_CORE::RTN_ExtPrepend EXT  ext,
RTN  parent
 

VOID LEVEL_CORE::RTN_Free RTN  rtn  ) 
 

Deallocate unlinked RTN

VOID LEVEL_CORE::RTN_InsertAfter RTN  rtn,
RTN  after,
SEC  parent
 

Insert RTN after another RTN within a SEC

VOID LEVEL_CORE::RTN_InsertBefore RTN  rtn,
RTN  before,
SEC  parent
 

Insert RTN before another RTN within a SEC

BOOL LEVEL_CORE::RTN_IsLeaf RTN  rtn  ) 
 

Does the given routine have a call? If not it is a 'leaf'. Look for basic block of type BBL_TYPE_CALL*

VOID LEVEL_CORE::RTN_MakeBbls RTN  rtn  ) 
 

Build basic blocks inside routine

VOID LEVEL_CORE::RTN_Mark1Bbls RTN  rtn  ) 
 

Set the First marker on all bbls

VOID LEVEL_CORE::RTN_MoveBbls RTN  src,
RTN  dst
 

Move bbls from one container to another container routine

UINT32 LEVEL_CORE::RTN_NumAttrCrosslink RTN  rtn  ) 
 

if a bbl has any of these atributes it cannot be freed

UINT32 LEVEL_CORE::RTN_NumBbl RTN  rtn  ) 
 

Compute number of static BBLs inside RTN

UINT32 LEVEL_CORE::RTN_NumExt RTN  parent  ) 
 

x

UINT32 LEVEL_CORE::RTN_numIns RTN  rtn  ) 
 

Compute number of static INSs inside RTN

VOID LEVEL_CORE::RTN_Prepend RTN  rtn,
SEC  parent
 

Prepend RTN to SEC

VOID LEVEL_CORE::RTN_RemoveAllExt RTN  rtn  ) 
 

Removes all extensions from the received routine.

VOID LEVEL_CORE::RTN_SetVaddr RTN  rtn,
IADDR  iaddr
 

set the vaddr of the RTN

string LEVEL_CORE::RTN_StringLong RTN  rtn  ) 
 

produce string for RTN

string LEVEL_CORE::RTN_StringLongDataFancy RTN  rtn  ) 
 

produce string for RTN also listing BBLs

string LEVEL_CORE::RTN_StringLongFancy RTN  rtn  ) 
 

produce string for RTN also listing BBLs

VOID LEVEL_CORE::RTN_TypifyBblsAndCreateEdgs RTN  rtn  ) 
 

determing BBL type based on last INS and create sucessor EDGs

VOID LEVEL_CORE::RTN_Unlink RTN  rtn  ) 
 

Unlink RTN from a SEC

VOID LEVEL_CORE::RTN_UnmakeBbls RTN  rtn  ) 
 

Put all routine instructions in one basic block

VOID LEVEL_CORE::RTN_Unmark1Bbls RTN  rtn  ) 
 

Reset all the markers on all the bbls

UINT32 LEVEL_CORE::RTN_VerifyFallthroughs RTN  rtn  ) 
 

Verify that all LINK, FALSE, and NORMAL EDGs are pointing to the next BBL Includes ugly hackery for two (conditional) calls in one bundle

ARRAYBASE LEVEL_CORE::RtnArrayBase "rtn pool"  ,
64 *  1024
 

x

STRIPE<RTN_STRUCT_BASE> LEVEL_CORE::RtnStripeBase "rtn stripe base"  ,
"core"  ,
RtnArrayBase
 

X

SEC LEVEL_CORE::SEC_Alloc  ) 
 

Allocate a new SEC and clear some of its fields. FIXME: fields clearing needs to be more extensive

VOID LEVEL_CORE::SEC_Append SEC  sec,
IMG  parent
 

append a SEC to IMG

VOID LEVEL_CORE::SEC_Check SEC  sec  ) 
 

x

VOID LEVEL_CORE::SEC_ComputeNewSecDataExec SEC  sec,
VOID *  data
 

This function does the final encoding into the code cache

ADDRINT LEVEL_CORE::SEC_ComputeOutputSizeOfExecutableSec SEC  sec,
const ADDRINT  secStart
 

x

BOOL LEVEL_CORE::SEC_ContainsIaddr SEC  sec,
IADDR  iaddr
 

Test whether a SEC's virtual address space includes an IADDR

BOOL LEVEL_CORE::SEC_ContainsIaddrEndInclusive SEC  sec,
IADDR  iaddr
 

get a piece of data directly from the incoming SEC data

BOOL LEVEL_CORE::SEC_ContainsOaddr SEC  sec,
OADDR  oaddr
 

Test whether a SEC's outgoing virtual address space includes an OADDR

BOOL LEVEL_CORE::SEC_ContainsOaddrEndInclusive SEC  sec,
OADDR  oaddr
 

Test whether a SEC's outgoing virtual address space includes an OADDR

VOID LEVEL_CORE::SEC_CreateOriginalIns SEC  sec  ) 
 

x

CHUNK LEVEL_CORE::SEC_FindChunkByIaddr SEC  sec,
IADDR  iaddr
 

Find a particular routine by iaddr in the given section

INS LEVEL_CORE::SEC_FindOriginalTargetIns SEC  sec,
INS  ins
 

x

RTN LEVEL_CORE::SEC_FindRtnByIaddr SEC  sec,
IADDR  iaddr
 

Find a particular routine by iaddr in the given section

RTN LEVEL_CORE::SEC_FindRtnByName SEC  sec,
const string &  name
 

Find a particular routine by name in the given section

BBL LEVEL_CORE::SEC_FindTargetBbl SEC  sec,
INS  ins
 

x

VOID LEVEL_CORE::SEC_Free SEC  sec  ) 
 

x

VOID LEVEL_CORE::SEC_GarbageCollect  ) 
 

The not yet implemented SEC garbage collector. It is supposed to add all unallocated SECs to the SEC freelist

INT32 LEVEL_CORE::SEC_GetIDataByOffsetUINT32 SEC  sec,
UINT64  offset
 

get a piece of data directly from the incoming SEC data

UINT64 LEVEL_CORE::SEC_GetIDataByOffsetUINT64 SEC  sec,
UINT64  offset
 

get a piece of data directly from the incoming SEC data

INT32 LEVEL_CORE::SEC_GetIDataINT32 SEC  sec,
IADDR  iaddr
 

get a piece of data directly from the incoming SEC data

UINT64 LEVEL_CORE::SEC_GetIDataUINT64 SEC  sec,
IADDR  iaddr
 

x

INT32 LEVEL_CORE::SEC_GetUnalignedIDataByOffsetINT32 SEC  sec,
UINT64  offset
 

get an unaligned piece of data directly from the incoming SEC data

UINT64 LEVEL_CORE::SEC_GetUnalignedIDataByOffsetUINT64 SEC  sec,
USIZE  offset
 

get an unaligned piece of data directly from the incoming SEC data

VOID LEVEL_CORE::SEC_IncNewSize SEC  sec,
USIZE  size
 

x

VOID LEVEL_CORE::SEC_InitDynamicCodeSection SEC  newSec,
IADDR  iaddr,
USIZE  size
 

Initialize an dynamic code section after it has been allocated. An dynamic code section contains dynamically created code, e.g. Jitted functions.

VOID LEVEL_CORE::SEC_InitOriginalSec SEC  sec,
const string &  name,
UINT32  index,
IADDR  iaddr,
USIZE  offset,
USIZE  size,
const VOID *  data,
UINT32  alignment,
BOOL  mapped,
BOOL  on_disk,
const VOID *  sectheader
 

initialize an original SEC after it has been allocated. An original SEC is one the corresponds to a Section in the input Image.

VOID LEVEL_CORE::SEC_InsertAfter SEC  sec,
SEC  after,
IMG  parent
 

insert SEC after another sec within an IMG

VOID LEVEL_CORE::SEC_InsertBefore SEC  sec,
SEC  before,
IMG  parent
 

insert SEC before another sec within an IMG

INS LEVEL_CORE::SEC_MapIaddrToOriginalIns SEC  sec,
IADDR  iaddr
 

Map an IADDR to an original INS This routine should only be called up to the point where the Image is being modified

IADDR LEVEL_CORE::SEC_MapOriginalInsToIaddr SEC  sec,
INS  ins
 

Map an original INS to its IADDR.

UINT32 LEVEL_CORE::SEC_NumRtn SEC  sec  ) 
 

return the number of RTNs for SEC

VOID LEVEL_CORE::SEC_Prepend SEC  sec,
IMG  parent
 

prepend a SEC to IMG

VOID LEVEL_CORE::SEC_SetDataCopy SEC  sec  ) 
 

x

VOID LEVEL_CORE::SEC_SetNewAddressAndOffset SEC  sec,
OADDR  oaddr,
USIZE  offset
 

x

VOID LEVEL_CORE::SEC_SetNewData SEC  sec,
VOID *  data
 

x

VOID LEVEL_CORE::SEC_SetNewSize SEC  sec,
USIZE  size
 

x

VOID LEVEL_CORE::SEC_StateSet SEC  sec,
SEC_STATE  state
 

x

string LEVEL_CORE::SEC_String SEC_STATE  state  ) 
 

convert a SEC_STATE into a printable string

string LEVEL_CORE::SEC_String SEC_TYPE  type  ) 
 

convert a SEC_TYPE into a printable string

string LEVEL_CORE::SEC_StringDataDumpI SEC  sec,
UINT32  width
 

convert a SECs incoming data into a printable string

string LEVEL_CORE::SEC_StringDis SEC  sec  ) 
 

x

string LEVEL_CORE::SEC_StringLong SEC  sec  ) 
 

convert a SEC into a printable string

string LEVEL_CORE::SEC_StringLongWithChunks SEC  sec  ) 
 

convert a SEC into a printable string -

VOID LEVEL_CORE::SEC_Unlink SEC  sec  ) 
 

unlink a SEC from an IMG

ARRAYBASE LEVEL_CORE::SecArrayBase "sec pool"  ,
1024 
 

The root for all SEC stripes

STRIPE<SEC_STRUCT_BASE> LEVEL_CORE::SecStripeBase "sec stripe base"  ,
"core"  ,
SecArrayBase
 

The base stripe for SEC

string LEVEL_CORE::SEGMENT_StringShort SEGMENT_TYPE  segment  ) 
 

convert a SEGMENT_TYPE into a printable string

VOID LEVEL_CORE::SetDecoderExceptionInfo EXCEPTION_INFO pExceptInfo,
EXCEPTION_CODE  exceptCode,
ADDRINT  addr,
size_t  size
 

Store the exception information that describes the specified failure in decoding of an instruction.

Parameters:
[out] pExceptInfo pointer to the structure that receives the exception information
[in] exceptCode exception code that specifies the cause of the failure
[in] addr address of the first byte of an invalid/inaccessible instruction
[in] size number of successfully fetched instruction's bytes that were passed to the decoder

ADDRDELTA LEVEL_CORE::SignedOffset ADDRINT  imm  ) 
 

return imm as a signed offset

BBL LEVEL_CORE::SimulateRetPopToMem INS  ret,
ADDRINT  offset
 

Simulate a return for the passed call instruction

BBL LEVEL_CORE::SimulateRetPush INS  call  ) 
 

Simulate a return for the passed call instruction

LOCALFUN string LEVEL_CORE::StrXedEnc const xed_encoder_request_t *  r  ) 
 

Returns:
a string for the encode request

VOID LEVEL_CORE::SYM_AddContainedSymbol SYM  sym,
SYM  contained_sym
 

Concatenates a symbol to the list of contained symbol for this symbol

SYM LEVEL_CORE::SYM_Alloc  ) 
 

Allocate a SYM

VOID LEVEL_CORE::SYM_Check SYM  sym  ) 
 

x

VOID LEVEL_CORE::SYM_Free SYM  sym  ) 
 

Deallocate a SYM

VOID LEVEL_CORE::SYM_GarbageCollect  ) 
 

SYM garbage collector

VOID LEVEL_CORE::SYM_Init SYM  sym,
VAL_TYPE  type,
BOOL  dynamic,
SYM_IFUNC_TYPE  ifunc_type,
const string &  name,
UINT32  index,
IADDR  iaddr,
UINT32  isize,
const VOID *  symbheader,
BOOL  global,
BOOL  original,
UINT32  string_offset
 

Init SYM (does not have to be original)

VOID LEVEL_CORE::SYM_SetSize SYM  sym,
UINT32  size
 

Set the size of an SYM

string LEVEL_CORE::SYM_StringShort SYM  sym  ) 
 

Convert a SYM into a printable string - short version (no newline)

ARRAYBASE LEVEL_CORE::SymArrayBase "sym pool"  ,
128 *  1024
 

The root for all SYM stripes

STRIPE<SYM_STRUCT_BASE> LEVEL_CORE::SymStripeBase "sym stripe base"  ,
"core"  ,
SymArrayBase
 

The base stripe for SYM

USIZE LEVEL_CORE::ThreadAwareInsEncoder INS  ins,
ADDRINT  address
 

Encode an instruction at a given address safely by corrupting the first byte to trap if executed while encoding the instruction backwards Thread safe encoding prototype

VOID LEVEL_CORE::ThreadAwareMemcpy VOID *  dst,
const VOID *  src,
USIZE  size
 

Before writing over a piece of memory, first fill it with trap instructions to fault to a signal handler while the bits are being overwritten from the last byte to the first. This is needed for a threaded program that might fetch the first few bytes of the instruction while another thread is modifying the bits at that same point

BOOL LEVEL_CORE::UseSahfLahfSequence  ) 
 

Returns:
if the lahf/sahf sequence should be used

BOOL LEVEL_CORE::VAL_Equal VAL_TYPE  t1,
const VAL *  v1,
VAL_TYPE  t2,
const VAL *  v2
 

compare two values for equality this is currently a hack which needs some work

OADDR LEVEL_CORE::VAL_Oaddr VAL_TYPE  type,
const VAL *  val,
IMG  img
 

generate new outigoing address/value for val

string LEVEL_CORE::VAL_StringShort VAL_TYPE  type,
const VAL *  val,
BOOL  tiny
 

convert a value component into a printable string - short version (no newline)

REG LEVEL_CORE::XED_BaseOnly INS  ins,
BOOL  filterWrites,
BOOL  filterReads,
BOOL  filterImplicit
 

If the supplied INS is a memory access that is using only base register in the memory Operand, this functin returns this base register, otherwise REG_INVALID() is returned.

Parameters:
[in] ins - the instruction to inspect
[in] filterWrites - filter all operands that are memory write operands
[in] filterReads - filter all operands that are memory read operands
[in] filterImplicit - filter memory operands that are implicit
Returns:
The base register

LOCALFUN VOID LEVEL_CORE::XED_decode_update_stripe INS  ins,
const xed_operand_values_t *  enc_operands,
UINT  itext_buf_len,
UINT  enc_len,
UINT8 *  itext_buf
 

Decode with Intel(R) X86 Encoder Decoder. Then update the stripe

VOID LEVEL_CORE::XED_encode_decode_update_stripe INS  ins,
xed_encoder_request_t *  xed_enc
 

Encode a new instruction with Intel(R) X86 Encoder Decoder. Then decode with Intel(R) XED. Then update the stripe.

xed_reg_enum_t LEVEL_CORE::xed_exact_map_from_pin_reg REG  pin_reg  ) 
 

Returns:
xed reg mapping to pin reg. if no map returns XED_REG_INVALID

REG LEVEL_CORE::xed_exact_map_to_pin_reg xed_reg_enum_t  xed_reg  ) 
 

Returns:
a valid pin register, but never an invalid one

VOID LEVEL_CORE::XED_init  ) 
 

Returns:
Nothing

BOOL LEVEL_CORE::XED_INS_IsMultimedia INS  ins  ) 
 

Checks if instruction is MMX, SSE, SSE2, SSE3, ...

VOID LEVEL_CORE::XED_log_init  ) 
 

Returns:
Nothing

VOID LEVEL_CORE::XED_logger INS  ins,
char *  msg
 

This function allows writing to the Intel(R) X86 Encoder Decoder log from other source files.

Returns:
nothing

REG LEVEL_CORE::xed_map_to_pin_reg xed_reg_enum_t  xed_reg  ) 
 

Returns:
a valid pin register or REG_INVALID().

FLAGS LEVEL_CORE::XED_PhyFlagsRead const xed_decoded_inst_t *  xedd  ) 
 

Return the physical flags (DF, OF, SF, ZF, AF, PF, CF) that are read according to the Intel(R) X86 Encoder Decoder decode info.

Parameters:
[in] xedd The Intel(R) XED decode info
Returns:
the FLAGS read according to the Intel(R) XED decode info

FLAGS LEVEL_CORE::XED_PhyFlagsWritten const xed_decoded_inst_t *  xedd,
BOOL  onlyDefinite
 

Return the physical flags (DF, OF, SF, ZF, AF, PF, CF) that are written according to the Intel(R) X86 Encoder Decoder decode info. Specify whether to return only the flags that are definitely (must) written

Parameters:
[in] xedd The Intel(R) X86 Encoder Decoder decode info
[in] onlyDefinite Specify TRUE if only the flags that are definitely written should be returned
Returns:
the FLAGS written according to the Intel(R) XED decode info, and the onlyDefinite specification

VOID LEVEL_CORE::XED_RAWINS_ReplacePinRegsByAppRegs const INS  ins,
const UINT32  num_pinregs,
REG pin_regs,
REG app_regs
 

x

VOID LEVEL_CORE::XED_RAWINS_ReplaceReg const INS  ins,
const REG  oldreg,
const REG  newreg
 

x

VOID LEVEL_CORE::XED_reencode_decode_update_stripe INS  ins  ) 
 

Reencode modified (previously-decoded) instruction with Intel(R) X86 Encoder Decoder. Then decode with Intel(R) XED. Then update the stripe.

REG LEVEL_CORE::xed_reg_to_pin_reg xed_reg_enum_t  xedreg,
INS  ins
 

Returns:
the PIN register name for a given Intel(R) X86 Encoder Decoder register name

VOID LEVEL_CORE::XED_RegRolePosFromXED INS  ins  ) 
 

Returns:
nothing
Fill in the reg/role/pos arrays in the stripe using information from the Intel(R) X86 Encoder Decoder decoded instruction.

VOID LEVEL_CORE::XED_RegRolePosToXED INS  ins  ) 
 

Returns:
nothing
Take the reg/role/pos arrays from the stripe and pack them back in to Intel(R) X86 Encoder Decoder decoded instruction.

LOCALFUN EXCEPTION_CODE LEVEL_CORE::XedError2ExceptionCode xed_error_enum_t  xed_error  ) 
 

Convert the specified Intel(R) X86 Encoder Decoder error code into the corresponding EXCEPTION_CODE value.

Note:
the XED_ERROR_BUFFER_TOO_SHORT error is converted into EXCEPTCODE_ACCESS_FAULT.


Variable Documentation

GLOBALCONST BOOL LEVEL_CORE::B_CROSSLINK = 1
 

a crosslinked attributed requires extra work during linking and linking since the object addressed by the value of the extension is "crosslinked"

GLOBALCONST BOOL LEVEL_CORE::B_HIDDEN = 1
 

a hidden attribute will be omitted from printing

LOCALCONST xed_state_t LEVEL_CORE::DSTATE
 

Initial value:



 
    { XED_MACHINE_MODE_LEGACY_32, XED_ADDRESS_WIDTH_32b}

LOCALVAR const xed_reg_enum_t LEVEL_CORE::dummy_regs_native_table[MAX_DUMMY_REGS]
 

Initial value:

{


 
    XED_REG_EDX, XED_REG_EBX, XED_REG_ECX

}

LOCALVAR const xed_reg_enum_t LEVEL_CORE::dummy_regs_width_table[MAX_DUMMY_REGS][MAX_DUMMY_REG_WIDTHS]
 

Initial value:

{




 
    { XED_REG_DL, XED_REG_DX, XED_REG_EDX, XED_REG_INVALID},
    { XED_REG_CL, XED_REG_CX, XED_REG_ECX, XED_REG_INVALID},
    { XED_REG_BL, XED_REG_BX, XED_REG_EBX, XED_REG_INVALID}

}

GLOBALCONST USIZE LEVEL_CORE::INS_PATCH_UNIT = 8
 

The size and alignment of a memory range, each patchable instruction must be fully contained in. Usually, instruction patching involves multiple code modifications, while ordering of this modifications in ICACHE is guaranteed only if they are performed in the same cache line. So, all instruction bytes should be located in a single cache line to allow thread-safe patching of the instruction. Taking in account that neither patchable instruction (branch) in Pin exceeds 8 bytes, we use a requirement which is even stronger than the cache line containment: each patchable instruction must be fully contained in a single INS_PATCH_UNIT. When choosing the INS_PATCH_UNIT value, consider the following:

  • INS_PATCH_UNIT should not exceed the cache line size
  • INS_PATCH_UNIT should be large enough to contain any patchable instruction in Pin
  • Larger INS_PATCH_UNIT value may reduce padding for individual instructions but increase alignment requirement for code sections (traces) that contain these instructions

LOCALVAR BBL LEVEL_CORE::last_nonreturning_fun = BBL_INVALID()
 

GLOBALCONST UINT32 LEVEL_CORE::MAX_INSTRUCTION_SIZE = 15
 

Maximum instruction size in IA-32 and Intel(R) 64 architectures.

GLOBALCONST REG LEVEL_CORE::REG_FirstInRegsetPhyContext = REG_PHYSICAL_INTEGER_BASE
 

REG represented by the first bit in the physical context regset vector.

GLOBALCONST REG LEVEL_CORE::REG_LastInRegsetPhyContext = REG_PHYSICAL_INTEGER_END
 

REG represented by the last bit in the physical context regset vector.

const REGSET_CONTEXT LEVEL_CORE::REGSET_CONTEXT_NONE
 

const REGSET LEVEL_CORE::REGSET_NONE
 

LOCALVAR string LEVEL_CORE::reuserTypeStr[]
 

Initial value:

{
    "INS_REUSER_TYPE_MM_INSERT_OP",
    "INS_REUSER_TYPE_MM_EXTRACT_OP",
    "INS_REUSER_TYPE_LOAD_MEM_OP",
    "INS_REUSER_TYPE_STORE_MEM_OP",
    "INS_REUSER_TYPE_REG_REG_OP",
    "INS_REUSER_TYPE_REG_IMM_OP",
    "INS_REUSER_TYPE_REG_OP",
    "INS_REUSER_TYPE_SDISP_OP",
    "INS_REUSER_TYPE_IMM_OP",
    "INS_REUSER_TYPE_NO_REG_OP",
    "INS_REUSER_TYPE_VZEROUPPER",
    "INS_REUSER_TYPE_MEM_IMM_OP",
    "INS_REUSER_TYPE_CHANGE_TO_IMM_OP",
    "INS_REUSER_TYPE_SIZED_NOP",
    "INS_REUSER_TYPE_MM_LOAD",
    "INS_REUSER_TYPE_MM_STORE",
    "INS_REUSER_TYPE_MM_REG_REG_OP",
    "INS_REUSER_TYPE_YMM_REG_OP",
    "INS_REUSER_TYPE_YMM_REG_REG_REG_OP",
    "INS_REUSER_TYPE_RET_IMM",
    "INS_REUSER_TYPE_WIDTH_REG_IMM_OP",
    "INS_REUSER_TYPE_REG_WORD_REG_BYTE_OP",
    "INS_REUSER_TYPE_REG_WIDTH_REG_OP",
    "INS_REUSER_TYPE_LAST"
}

LOCALVAR const SEC_STATE LEVEL_CORE::SEC_StateMachineCooked[]
 

Initial value:

 {SEC_STATE_INVALID, SEC_STATE_RAW_I, SEC_STATE_COOKED,
                                                     SEC_STATE_RAW_O,  SEC_STATE_LAST}

LOCALVAR const SEC_STATE LEVEL_CORE::SEC_StateMachineData[]
 

Initial value:

 {SEC_STATE_INVALID, SEC_STATE_RAW_I, SEC_STATE_CHUNKED_I,
                                                  SEC_STATE_CHUNKED_O, SEC_STATE_RAW_O,  SEC_STATE_LAST}

LOCALVAR const SEC_STATE LEVEL_CORE::SEC_StateMachineExe[]
 

Initial value:

 {SEC_STATE_INVALID, SEC_STATE_RAW_I, SEC_STATE_CHUNKED_I, SEC_STATE_DISASSEMBLED,
                                                  SEC_STATE_CHUNKED_O, SEC_STATE_RAW_O,  SEC_STATE_LAST}

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_MEMOFFSET_PROBE = 7
 

size of the type of the probe

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_OFFSET_PROBE = 5
 

size of the type of the probe

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_RIP_AND_ADDR_PROBE = 14
 

size of the type of the probe

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_RIP_PROBE = 6
 

size of the type of the probe

LOCALVAR USIZE LEVEL_CORE::sizeOfDirectJmp = 0
 

Size of the unconditional, direct jump instruction with a 32-bit displacement

LOCALVAR USIZE LEVEL_CORE::sizeOfIpRelativeMemJmp = 0
 

Size of the unconditional, direct jjmp [gip]offset

LOCALVAR const SYM_STATE LEVEL_CORE::SYM_StateMachine[]
 

Initial value:

{
    SYM_STATE_INVALID,SYM_STATE_RAW,SYM_STATE_LINKED,SYM_STATE_LAST
}


Generated on Sun Jan 28 23:35:40 2018 for Pin by  doxygen 1.4.6