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 } |
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_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_ABS64, 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_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_FLAGS { XED_OPERAND_FLAGS_LOCK = 1 } |
enum | XED_OPERAND_NUMBER { XED_OPERAND_NUMBER_0 = 0, XED_OPERAND_NUMBER_1 = 1, XED_OPERAND_NUMBER_2 = 2 } |
enum | INS_REUSER_TYPE { INS_REUSER_TYPE_FIRST, INS_REUSER_TYPE_YMM_INSERT_OP = INS_REUSER_TYPE_FIRST, 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, SYSCALL_TYPE_SYSENTER = 2, SYSCALL_TYPE_FARCALL = 3, SYSCALL_TYPE_INT80 = 4, SYSCALL_TYPE_INT81 = 5, SYSCALL_TYPE_INT82 = 6, 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 () |
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, UINT32 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_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) |
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_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) |
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_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_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_inlined_analysis_code_set (INS x, BOOL y) |
BOOL | INS_inlined_analysis_code (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 () |
INS | INS_Alloc () |
VOID | INS_Free (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 () |
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) |
IADDR * | RTN_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 BOOL | SEC_short_data (SEC x) |
LOCALINLINE VOID | SEC_short_data_set (SEC x, BOOL 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 short_data, 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) |
BOOL | SEC_IsShortData (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) |
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) |
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) |
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) |
UINT32 | INS_EffectiveAddressWidth (INS ins) |
USIZE | INS_MemoryOperandSize (INS ins, UINT32 memoryOp) |
USIZE | INS_MemoryWriteSize (INS ins) |
PREDICATE | INS_GetPredicate (INS ins) |
USIZE | INS_MemoryReadSize (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_IsAvx (INS ins) |
BOOL | INS_IsVgather (INS ins) |
BOOL | INS_IsVscatter (INS ins) |
BOOL | INS_HasMemoryVector (INS ins) |
BOOL | INS_IsSse (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_IsXrestore (INS ins) |
BOOL | INS_IsCmov (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 ®) |
BOOL | INS_IsMMXorXMM (const INS ins) |
BOOL | INS_IsAtomicUpdate (const INS ins) |
BOOL | INS_IsRDTSC (const INS ins) |
BOOL | INS_IsMaskMov (const INS ins) |
BOOL | INS_IsMaskedJump (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 ®) |
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) |
VOID | INS_AddRep (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 XED 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, EXCEPTION_INFO *pExceptInfo=0) |
template<typename FETCHER_> | |
GLOBALTEMPLATEFUN BOOL | INS_Fetch (INS ins, const VOID **address, const FETCHER_ &insBytesFetcher, EXCEPTION_INFO *pExceptInfo=0) |
int | INS_MaxDecodedBytes () |
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_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) |
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 flags, int ea_width) |
LOCALFUN VOID | INS_XedInst0 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width=0, int flags=0, int ea_width=0) |
LOCALFUN VOID | INS_XedInst1 (INS ins, xed_iclass_enum_t iclass, xed_uint_t effective_operand_width, const xed_encoder_operand_t &op0, int flags=0, 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, int flags=0, int ea_width=0) |
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, int flags=0, int ea_width=0) |
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, int flags=0, int ea_width=0) |
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()) |
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, 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, 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, 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, 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_InitYMMInsertOpGetDummyRegs (REG base, xed_reg_enum_t *dummy_base, REG index, xed_reg_enum_t *dummy_index, REG ymm_src, xed_reg_enum_t *dummy_ymmsrc, REG ymm_dst, xed_reg_enum_t *dummy_ymmdst, BOOL exactCopy) |
LOCALFUN VOID | INS_InitYMMInsertOpReplaceDummyRegs (INS ins, REG base, xed_reg_enum_t dummy_base, REG index, xed_reg_enum_t dummy_index, REG ymmsrc, xed_reg_enum_t dummy_src, REG ymmdst, xed_reg_enum_t dummy_dst, const UINT memop_pos, const UINT regop_src_pos, const UINT regop_dst_pos) |
LOCALFUN VOID | INS_InitYMMInsertOpOriginal (INS ins, REG ymmDest, REG ymmSrc, REG base, INT32 displacement, REG index, UINT scale, REG seg, UINT32 imm8, xed_iclass_enum_t iclass, BOOL replaceXedRegs) |
LOCALFUN VOID | INS_InitYMMInsertOp (INS ins, REG ymmDest, REG ymmSrc, REG base, INT32 displacement, REG index, UINT scale, REG seg, UINT32 imm8, xed_iclass_enum_t iclass) |
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) |
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, BOOL lock=false, 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, BOOL lock=false, 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, 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_InitKmov (INS ins, REG src, REG dest) |
VOID | INS_InitKorTest (INS ins, REG src, REG dest) |
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) |
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_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) |
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_InitMOVDQARegMem (INS ins, REG dst, REG base, INT32 displacement, REG index, UINT scale, REG seg) |
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_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_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_InitOrI (INS ins, REG reg, UINT64 imm) |
VOID | INS_InitShlI (INS ins, REG reg, UINT64 imm) |
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_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) |
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", KNOB_ONLY_OFF_MIC,"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: xed ") |
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","XED switches") |
KNOB< BOOL > | knob_mpx_mode (KNOB_MODE_WRITEONCE,"supported:xed","xed_mpx_mode","0","Enable Intel(R) MPX 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","XED reencode test") |
LOCALVAR KNOB< BOOL > | KnobXedReencodeCache (KNOB_MODE_WRITEONCE,"supported","xedreencodecache","1","XED reencode cache") |
LOCALVAR KNOB< BOOL > | KnobXedEncoderTest (KNOB_MODE_WRITEONCE,"supported","xedenc","0","XED encoder testing") |
LOCALVAR KNOB< UINT32 > | KnobXedLog (KNOB_MODE_WRITEONCE,"supported","xedlog","0","XED log messages levels 0-5") |
LOCALVAR KNOB< string > | KnobXedLogfile (KNOB_MODE_WRITEONCE,"supported","xedlogfile","xed.log","The XED 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 xed ia32 decoded","core",&InsArrayBase) |
STRIPE< INS_XED_STRUCT_ENCODE > | InsStripeXEDEncode ("ins stripe xed 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) |
xed_reg_enum_t | xed_exact_map_from_pin_reg_fast (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) |
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) |
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 ®set, REG reg) |
VOID | REGSET_Insert (REGSET ®set, REG reg) |
VOID | REGSET_Remove (REGSET ®set, REG reg) |
VOID | REGSET_Clear (REGSET ®set) |
VOID | REGSET_AddAll (REGSET ®set) |
REG | REGSET_PopNext (REGSET ®set) |
UINT32 | REGSET_PopCount (const REGSET ®set) |
BOOL | REGSET_PopCountIsZero (const REGSET ®set) |
string | REGSET_StringShort (const REGSET ®set) |
string | REGSET_StringList (const REGSET ®set) |
UINT32 | REGSET_HashKey (const REGSET ®set) |
BOOL | REGSET_CONTEXT_Contains (const REGSET_CONTEXT regset, REG reg) |
VOID | REGSET_CONTEXT_Insert (REGSET_CONTEXT ®set, REG reg) |
VOID | REGSET_CONTEXT_Remove (REGSET_CONTEXT ®set, REG reg) |
VOID | REGSET_CONTEXT_Clear (REGSET_CONTEXT ®set) |
REG | REGSET_CONTEXT_PopNext (REGSET_CONTEXT ®set) |
UINT32 | REGSET_CONTEXT_PopCount (const REGSET_CONTEXT ®set) |
BOOL | REGSET_CONTEXT_PopCountIsZero (const REGSET_CONTEXT ®set) |
string | REGSET_CONTEXT_StringShort (const REGSET_CONTEXT ®set) |
string | REGSET_CONTEXT_StringList (const REGSET ®set) |
LOCALINLINE VOID | SetX87Bit (FPSTATE *fpstate) |
LOCALINLINE VOID | SetSseBit (FPSTATE *fpstate) |
LOCALINLINE VOID | SetAvxBit (FPSTATE *fpstate) |
VOID | REG_StoreXmmToFxsave (REG xmm, const VOID *val, FPSTATE *fpstate) |
VOID | REG_StoreXmmToFxsave (REG xmm, const REGVALUE128 &val, FPSTATE *fpstate) |
VOID | REG_StoreYmmToFxsave (REG ymm, const VOID *val, FPSTATE *fpstate) |
VOID | REG_StoreYmmToFxsave (REG ymm, const REGVALUE256 &val, FPSTATE *fpstate) |
VOID | REG_StoreZmmToFxsave (REG zmm, const VOID *val, FPSTATE *fpstate) |
VOID | REG_StoreZmmToFxsave (REG zmm, const REGVALUE512 &val, FPSTATE *fpstate) |
VOID | REG_StoreKMaskToFxsave (REG kmask, const REGVALUE &val, FPSTATE *fpstate) |
VOID | REG_ReadXmmFromFxsave (REG xmm, const FPSTATE *fpstate, VOID *val) |
const REGVALUE128 & | REG_ReadXmmFromFxsave (REG xmm, const FPSTATE *fpstate) |
VOID | REG_ReadYmmFromFxsave (REG ymm, const FPSTATE *fpstate, VOID *val) |
REGVALUE256 | REG_ReadYmmFromFxsave (REG ymm, const FPSTATE *fpstate) |
VOID | REG_ReadZmmFromFxsave (REG zmm, const FPSTATE *fpstate, VOID *val) |
const REGVALUE512 & | REG_ReadZmmFromFxsave (REG zmm, const FPSTATE *fpstate) |
REGVALUE | REG_ReadKMaskFromFxsave (REG kmask, const FPSTATE *fpstate) |
VOID | REG_StoreShortFpToFxsave (REG reg, const REGVALUE val, FPSTATE *fpstate) |
REGVALUE | REG_ReadShortFpFromFxsave (REG reg, const FPSTATE *fpstate) |
VOID | REG_StoreStToFxsave (REG reg, const VOID *val, FPSTATE *fpstate) |
VOID | REG_StoreStToFxsave (REG reg, const REGVALUE128 &val, FPSTATE *fpstate) |
VOID | REG_ReadStFromFxsave (REG reg, const FPSTATE *fpstate, VOID *val) |
const REGVALUE128 & | REG_ReadStFromFxsave (REG reg, const FPSTATE *fpstate) |
REGVALUE | REG_ReadPseudo (REG reg) |
VOID | REG_StorePseudo (REG reg, REGVALUE val) |
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 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 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 | |
} | 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 _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_CONTEXT_BEGIN |
GLOBALCONST REG | REG_LastInRegsetPhyContext = REG_PHYSICAL_CONTEXT_END |
const REGSET | REGSET_NONE |
const REGSET_CONTEXT | REGSET_CONTEXT_NONE |
const FAST_REGSET | FAST_REGSET_NONE |
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.
[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. |
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
bbl state enumeration - not used
enum LEVEL_CORE::BBL_TYPE |
BBL types enumeration
Names of calling standards Following names in Agner Fog's document
CHUNK state, to be used for consitency checking
CHUNK types
EDG state enumeration - not used
enum LEVEL_CORE::EDG_TYPE |
EDG type enumeration
enum LEVEL_CORE::FLAGS |
Enumeration type for individual flags
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.
not used
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 |
not used
enum LEVEL_CORE::RTN_TYPE |
RTN type
SEC state, used for consitency checking
Symbols Ifunc type indicates about the symbol role in resolving ifunc.
used for consistency checking
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.
enum LEVEL_CORE::VAL_TYPE |
VAL types
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.
[in] | bbl | - Root of the CFG tree. |
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
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
[in] | firstBbl | - BBL to split |
[in] | splitIns | - Move this INS and all that follow into 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
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::CopyImageLoaderInfo | ( | VOID * | arg | ) |
Copy image loader info used for PINADX debugger to PIN managed buffer
BOOL LEVEL_CORE::DoFlagsSplit | ( | ) |
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_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
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_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
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.
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.
[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. |
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
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
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
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_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::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
VOID LEVEL_CORE::INS_AddRep | ( | INS | ins | ) |
Add a (real) rep prefix to an instruction.
[in] | ins | The instruction to change. |
INS LEVEL_CORE::INS_Alloc | ( | ) |
Allocate new INS, some initialization
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.
[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 | ) |
BOOL LEVEL_CORE::INS_CallOrBranchIsRegisterIndirect | ( | INS | ins | ) |
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.
[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
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.
[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.
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.
[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 | ) |
INSDECODE LEVEL_CORE::INS_DecodeIns | ( | INS | ins, | |
const VOID ** | address, | |||
UINT32 | size, | |||
EXCEPTION_CODE * | excCode | |||
) |
Forward declaration of the XED 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 | |||
) |
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 achitecture 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 XED 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 | |||
) |
GLOBALTEMPLATEFUN BOOL LEVEL_CORE::INS_Fetch | ( | INS | ins, | |
const VOID ** | address, | |||
const FETCHER_ & | insBytesFetcher, | |||
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.
[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 |
[out] | pExceptInfo | optional pointer to the structure that receives the exception information if the function fails |
VOID LEVEL_CORE::INS_Free | ( | INS | ins | ) |
Free INS
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 | ) |
UINT8 LEVEL_CORE::INS_get_num_writes | ( | INS | x | ) |
UINT LEVEL_CORE::INS_get_pos_r | ( | INS | x, | |
UINT | i | |||
) |
UINT LEVEL_CORE::INS_get_pos_w | ( | INS | x, | |
UINT | i | |||
) |
REG LEVEL_CORE::INS_get_reg_r | ( | INS | x, | |
UINT | i | |||
) |
REG LEVEL_CORE::INS_get_reg_w | ( | INS | x, | |
UINT | i | |||
) |
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 | |||
) |
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 | ) |
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
[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 |
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 | |||
) |
UINT32 LEVEL_CORE::INS_GetScale | ( | INS | ins | ) |
x
ADDRINT LEVEL_CORE::INS_GetSecondImmediate | ( | INS | ins | ) |
x
ADDRDELTA LEVEL_CORE::INS_GetSignedImmediate | ( | INS | ins | ) |
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_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 | ) |
BOOL LEVEL_CORE::INS_HasSegmentRegPrefix | ( | INS | ins | ) |
Just calls INS_SegmentPrefix()
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 | |||
) |
This does the smae thing as INS_InitMOVDQARegMem()
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_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_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
[in] | ins | instruction to be initialized |
[in] | brAddr | address of the branch |
[in] | tgtAddr | target address of the branch |
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
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_InitKmov | ( | INS | ins, | |
REG | src, | |||
REG | dest | |||
) |
X
VOID LEVEL_CORE::INS_InitKorTest | ( | INS | ins, | |
REG | src, | |||
REG | dest | |||
) |
X
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
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.
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.
[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_InitMMLoad | ( | INS | ins, | |
REG | mmdst, | |||
REG | maskReg, | |||
REG | base, | |||
INT32 | displacement, | |||
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_InitMOVDQARegMem | ( | INS | ins, | |
REG | dst, | |||
REG | base, | |||
INT32 | displacement, | |||
REG | index, | |||
UINT | scale, | |||
REG | seg | |||
) |
Create a MOVDQA reg/mem (LOAD)
This does the smae thing as INS_InitAlignedLoadXMM()
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 | |||
) |
x
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, | |||
EXCEPTION_INFO * | pExceptInfo = 0 | |||
) |
Decode an original instruction and initialize the specified INS object.
[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 |
[out] | pExceptInfo | optional pointer to the structure that receives the exception information if the function fails |
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.
[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.
[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_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_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 | |||
) |
x
VOID LEVEL_CORE::INS_InitUnalignedLoadYMM | ( | INS | ins, | |
REG | dst, | |||
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_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
LOCALFUN VOID LEVEL_CORE::INS_InitYMMInsertOpOriginal | ( | INS | ins, | |
REG | ymmDest, | |||
REG | ymmSrc, | |||
REG | base, | |||
INT32 | displacement, | |||
REG | index, | |||
UINT | scale, | |||
REG | seg, | |||
UINT32 | imm8, | |||
xed_iclass_enum_t | iclass, | |||
BOOL | replaceXedRegs | |||
) |
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 | ) |
BOOL LEVEL_CORE::INS_IsAvx | ( | INS | ins | ) |
Return TRUE iff the ins is an AVX 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 | ) |
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_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.
[in] | addr | address of the instruction |
[in] | size | size of the instruction |
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 | ) |
BOOL LEVEL_CORE::INS_IsPopAll32 | ( | INS | ins | ) |
BOOL LEVEL_CORE::INS_IsPopF | ( | const INS | ins | ) |
BOOL LEVEL_CORE::INS_IsPopFD | ( | const INS | ins | ) |
BOOL LEVEL_CORE::INS_IsPopFQ | ( | const INS | ins | ) |
BOOL LEVEL_CORE::INS_IsPush | ( | const INS | ins | ) |
returns true if this instruction is a push.
BOOL LEVEL_CORE::INS_IsPushAll16 | ( | INS | ins | ) |
BOOL LEVEL_CORE::INS_IsPushAll32 | ( | INS | ins | ) |
BOOL LEVEL_CORE::INS_IsScas | ( | INS | ins | ) |
Return TRUE if the INS is a SCAS
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?
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.
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 | ) |
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
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 | ) |
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.
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
[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 |
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.
[in] | brAddr | address of the branch |
[in] | tgtAddr | new target address of the branch |
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.
The size of the original instruction should be at least the size of the unconditional direct jump (see INS_SizeOfDirectJmp())
[in] | insAddr | address of the original instruction |
[in] | tgtAddr | target address of the branch |
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 | ) |
UINT32 LEVEL_CORE::INS_orig_size | ( | INS | x | ) |
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
[in] | ins | The INS whose phys flags written are to be obtained |
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
[in] | ins | The INS whose phys flags written are to be obtained |
FLAGS LEVEL_CORE::INS_PhyFlagsRead | ( | const INS | ins | ) |
Return the physical flags (DF, OF, SF, ZF, AF, pf, CF) that this ins reads.
[in] | ins | The INS whose phys flags read are to be obtained |
BOOL LEVEL_CORE::INS_PrefixIsGsOrFsReg | ( | INS | ins | ) |
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 | |||
) |
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!
[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.
[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 | ( | ) |
USIZE LEVEL_CORE::INS_SizeOfIpRelativeMemJmp | ( | ) |
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 | ) |
BOOL LEVEL_CORE::INS_SyscallIsTakenBranch | ( | INS | ins | ) |
LOCALFUN SYSCALL_TYPE LEVEL_CORE::INS_SyscallType | ( | INS | ins | ) |
PREDICATE_IA32 LEVEL_CORE::INS_TestedCondition | ( | INS | ins | ) |
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.
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 | ) |
xed_operand_values_t* LEVEL_CORE::INS_xed_operand_values | ( | INS | ins | ) |
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
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 xed ia32 decoded" | , | |
"core" | , | |||
& | InsArrayBase | |||
) |
The stripe data structure for XED decoded instructions.
STRIPE<INS_XED_STRUCT_ENCODE> LEVEL_CORE::InsStripeXEDEncode | ( | "ins stripe xed ia32 encoded" | , | |
"core" | , | |||
& | InsArrayBase | |||
) |
The stripe data structure for XED encoded instructions.
LOCALFUN INT32 LEVEL_CORE::INT_Immediate | ( | xed_decoded_inst_t * | xedd | ) |
Return the immediate field of an INT instruction.
[in] | xedd | The INT instruction |
UINT32 LEVEL_CORE::InvalidSysCallNumber | ( | ) |
Return integer that represents invalid syscall number
xed_iclass_enum_t LEVEL_CORE::JccIclassToCmovcc | ( | INS | ins | ) |
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
KNOB<BOOL> LEVEL_CORE::KnobUseInsReusing | ( | KNOB_MODE_WRITEONCE | , | |
"supported:regalloc" | , | |||
"ins_reusing" | , | |||
KNOB_ONLY_OFF_MIC | , | |||
"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.
REGVALUE LEVEL_CORE::REG_ReadKMaskFromFxsave | ( | REG | kmask, | |
const FPSTATE * | fpstate | |||
) |
Read an K mask register value from an 'fxsave' data structure.
[in] | kmask | The K mask register number. |
[in] | fpstate | The 'fxsave' data structure where the K mask register value is read from. |
REGVALUE LEVEL_CORE::REG_ReadPseudo | ( | REG | reg | ) |
Read the value of a pseudo register.
[in] | reg | The pseudo register number. |
REGVALUE LEVEL_CORE::REG_ReadShortFpFromFxsave | ( | REG | reg, | |
const FPSTATE * | fpstate | |||
) |
Read a short FP register value from an 'fxsave' data structure.
[in] | reg | The FP register number. |
[in] | fpstate | The 'fxsave' data structure where the FP register value is read from. |
const REGVALUE128& LEVEL_CORE::REG_ReadStFromFxsave | ( | REG | reg, | |
const FPSTATE * | fpstate | |||
) |
Read a stacked FP register value from an 'fxsave' data structure.
[in] | reg | The FP register number. |
[in] | fpstate | The 'fxsave' data structure where the FP register value is read from. |
VOID LEVEL_CORE::REG_ReadStFromFxsave | ( | REG | reg, | |
const FPSTATE * | fpstate, | |||
VOID * | val | |||
) |
Read a stacked FP register value from an 'fxsave' data structure.
[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_ReadXmmFromFxsave | ( | REG | xmm, | |
const FPSTATE * | fpstate | |||
) |
Read an XMM register value from an 'fxsave' data structure.
[in] | xmm | The XMM register number. |
[in] | fpstate | The 'fxsave' data structure where the XMM register value is read from. |
VOID LEVEL_CORE::REG_ReadXmmFromFxsave | ( | REG | xmm, | |
const FPSTATE * | fpstate, | |||
VOID * | val | |||
) |
Read an XMM register value from an 'fxsave' data structure.
[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. |
REGVALUE256 LEVEL_CORE::REG_ReadYmmFromFxsave | ( | REG | ymm, | |
const FPSTATE * | fpstate | |||
) |
Read an YMM register value from an 'xsave' data structure.
[in] | ymm | The YMM register number. |
[in] | fpstate | The 'xsave' data structure where the YMM register value is read from. |
VOID LEVEL_CORE::REG_ReadYmmFromFxsave | ( | REG | ymm, | |
const FPSTATE * | fpstate, | |||
VOID * | val | |||
) |
Read an YMM register value from an 'xsave' data structure.
[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 | ( | REG | zmm, | |
const FPSTATE * | fpstate | |||
) |
Read an ZMM register value from an 'fxsave' data structure.
[in] | zmm | The ZMM register number. |
[in] | fpstate | The 'fxsave' data structure where the ZMM register value is read from. |
VOID LEVEL_CORE::REG_ReadZmmFromFxsave | ( | REG | zmm, | |
const FPSTATE * | fpstate, | |||
VOID * | val | |||
) |
Read an ZMM register value from an 'fxsave' data structure.
[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 | ) |
Give 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 | ( | REG | kmask, | |
const REGVALUE & | val, | |||
FPSTATE * | fpstate | |||
) |
Store an K mask register value to an 'fxsave' data structure.
[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.
[in] | reg | The pseudo register number. |
[in] | val | The value. |
VOID LEVEL_CORE::REG_StoreShortFpToFxsave | ( | REG | reg, | |
const REGVALUE | val, | |||
FPSTATE * | fpstate | |||
) |
Store a short FP register value to an 'fxsave' data structure.
[in] | reg | The FP register number. |
[in] | val | The value of the FP register. |
[out] | fpstate | The 'fxsave' data structure which receives the FP register value. |
VOID LEVEL_CORE::REG_StoreStToFxsave | ( | REG | reg, | |
const REGVALUE128 & | val, | |||
FPSTATE * | fpstate | |||
) |
Store a stacked FP register value to an 'fxsave' data structure.
[in] | reg | The FP register number. |
[in] | val | The value of the FP register. |
[out] | fpstate | The 'fxsave' data structure which receives the FP register value. |
VOID LEVEL_CORE::REG_StoreStToFxsave | ( | REG | reg, | |
const VOID * | val, | |||
FPSTATE * | fpstate | |||
) |
Store a stacked FP register value to an 'fxsave' data structure.
[in] | reg | The FP register number. |
[in] | val | The value of the FP register. |
[out] | fpstate | The 'fxsave' data structure which receives the FP register value. |
VOID LEVEL_CORE::REG_StoreXmmToFxsave | ( | REG | xmm, | |
const REGVALUE128 & | val, | |||
FPSTATE * | fpstate | |||
) |
Store an XMM register value to an 'fxsave' data structure.
[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 | ( | REG | xmm, | |
const VOID * | val, | |||
FPSTATE * | fpstate | |||
) |
Store an XMM register value to an 'fxsave' data structure.
[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 | ( | REG | ymm, | |
const REGVALUE256 & | val, | |||
FPSTATE * | fpstate | |||
) |
Store an YMM register value to an 'xsave' data structure.
[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 | ( | REG | ymm, | |
const VOID * | val, | |||
FPSTATE * | fpstate | |||
) |
Store an YMM register value to an 'xsave' data structure.
[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 | ( | REG | zmm, | |
const REGVALUE512 & | val, | |||
FPSTATE * | fpstate | |||
) |
Store an ZMM register value to an 'fxsave' data structure.
[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 | ( | REG | zmm, | |
const VOID * | val, | |||
FPSTATE * | fpstate | |||
) |
Store an ZMM register value to an 'fxsave' data structure.
[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
[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 | short_data, | |||
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
BOOL LEVEL_CORE::SEC_IsShortData | ( | SEC | sec | ) |
x
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.
[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 | ) |
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 | ( | ) |
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.
[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 |
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 XED! 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 XED. Then decode with XED. Then update the stripe.
xed_reg_enum_t LEVEL_CORE::xed_exact_map_from_pin_reg | ( | REG | pin_reg | ) |
x
xed_reg_enum_t LEVEL_CORE::xed_exact_map_from_pin_reg_fast | ( | REG | pin_reg | ) |
x
REG LEVEL_CORE::xed_exact_map_to_pin_reg | ( | xed_reg_enum_t | xed_reg | ) |
VOID LEVEL_CORE::XED_init | ( | ) |
BOOL LEVEL_CORE::XED_INS_IsMultimedia | ( | INS | ins | ) |
Checks if instruction is MMX, SSE, SSE2, SSE3, ...
VOID LEVEL_CORE::XED_log_init | ( | ) |
VOID LEVEL_CORE::XED_logger | ( | INS | ins, | |
char * | msg | |||
) |
This function allows writing to the xed log from other source files.
REG LEVEL_CORE::xed_map_to_pin_reg | ( | xed_reg_enum_t | xed_reg | ) |
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 xed decode info.
[in] | xedd | The 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 xed decode info. Specify whether to return only the flags that are definitely (must) written
[in] | xedd | The xed decode info |
[in] | onlyDefinite | Specify TRUE if only the flags that are definitely written should be returned |
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 XED. Then decode with XED. Then update the stripe.
REG LEVEL_CORE::xed_reg_to_pin_reg | ( | xed_reg_enum_t | xedreg, | |
INS | ins | |||
) |
VOID LEVEL_CORE::XED_RegRolePosFromXED | ( | INS | ins | ) |
VOID LEVEL_CORE::XED_RegRolePosToXED | ( | INS | ins | ) |
LOCALFUN EXCEPTION_CODE LEVEL_CORE::XedError2ExceptionCode | ( | xed_error_enum_t | xed_error | ) |
Convert the specified XED error code into the corresponding EXCEPTION_CODE value.
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:
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_CONTEXT_BEGIN |
REG represented by the first bit in the physical context regset vector.
GLOBALCONST REG LEVEL_CORE::REG_LastInRegsetPhyContext = REG_PHYSICAL_CONTEXT_END |
REG represented by the last bit in the physical context regset vector.
LOCALVAR string LEVEL_CORE::reuserTypeStr[] |
Initial value:
{ "INS_REUSER_TYPE_YMM_INSERT_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 }