LEVEL_CORE Namespace Reference


Typedefs

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

Enumerations

enum  BBL_TYPE {
  BBL_TYPE_INVALID,
  BBL_TYPE_UBREAK,
  BBL_TYPE_CBREAK,
  BBL_TYPE_STOP,
  BBL_TYPE_UCALL_UNKNOWN,
  BBL_TYPE_UCALL_FUN,
  BBL_TYPE_UCALL_OS,
  BBL_TYPE_CCALL_OS,
  BBL_TYPE_CCALL_UNKNOWN,
  BBL_TYPE_CCALL_FUN,
  BBL_TYPE_NORMAL,
  BBL_TYPE_CBRANCH,
  BBL_TYPE_UBRANCH,
  BBL_TYPE_COUNTED,
  BBL_TYPE_SWPIPELINED,
  BBL_TYPE_CHECK,
  BBL_TYPE_PREFETCH,
  BBL_TYPE_UJUMP,
  BBL_TYPE_UJUMP_DYNLINK,
  BBL_TYPE_UJUMP_THUNK,
  BBL_TYPE_UJUMP_TRAMPOLINE,
  BBL_TYPE_UBRANCH_TRAMPOLINE,
  BBL_TYPE_CJUMP,
  BBL_TYPE_CJUMP_SWITCH,
  BBL_TYPE_STUB,
  BBL_TYPE_URETURN,
  BBL_TYPE_CRETURN,
  BBL_TYPE_DATA,
  BBL_TYPE_DATA_IADDR,
  BBL_TYPE_DATA_ARGBLOCK,
  BBL_TYPE_DATA_SWITCH1,
  BBL_TYPE_DATA_UNWIND,
  BBL_TYPE_DATA_LAST,
  BBL_TYPE_CONTAINER,
  BBL_TYPE_UNKNOWN,
  BBL_TYPE_VMSVC,
  BBL_TYPE_IBRANCH_LOOKUP,
  BBL_TYPE_EMU_FT,
  BBL_TYPE_UCALL_NATIVE_TARGET,
  BBL_TYPE_LAST
}
enum  BBL_STATE {
  BBL_STATE_INVALID,
  BBL_STATE_LAST
}
enum  CALLING_STANDARD {
  CALLING_STANDARD_INVALID,
  CALLING_STANDARD_IA32_CDECL,
  CALLING_STANDARD_IA32_REGPARM,
  CALLING_STANDARD_IA32E_WINDOWS,
  CALLING_STANDARD_IA32E_UNIX,
  CALLING_STANDARD_IA32_FASTCALL_WINDOWS,
  CALLING_STANDARD_IA32_STDCALL_WINDOWS
}
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 &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 &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 &regset, REG reg)
VOID REGSET_Insert (REGSET &regset, REG reg)
VOID REGSET_Remove (REGSET &regset, REG reg)
VOID REGSET_Clear (REGSET &regset)
VOID REGSET_AddAll (REGSET &regset)
REG REGSET_PopNext (REGSET &regset)
UINT32 REGSET_PopCount (const REGSET &regset)
BOOL REGSET_PopCountIsZero (const REGSET &regset)
string REGSET_StringShort (const REGSET &regset)
string REGSET_StringList (const REGSET &regset)
UINT32 REGSET_HashKey (const REGSET &regset)
BOOL REGSET_CONTEXT_Contains (const REGSET_CONTEXT regset, REG reg)
VOID REGSET_CONTEXT_Insert (REGSET_CONTEXT &regset, REG reg)
VOID REGSET_CONTEXT_Remove (REGSET_CONTEXT &regset, REG reg)
VOID REGSET_CONTEXT_Clear (REGSET_CONTEXT &regset)
REG REGSET_CONTEXT_PopNext (REGSET_CONTEXT &regset)
UINT32 REGSET_CONTEXT_PopCount (const REGSET_CONTEXT &regset)
BOOL REGSET_CONTEXT_PopCountIsZero (const REGSET_CONTEXT &regset)
string REGSET_CONTEXT_StringShort (const REGSET_CONTEXT &regset)
string REGSET_CONTEXT_StringList (const REGSET &regset)
LOCALINLINE VOID SetX87Bit (FPSTATE *fpstate)
LOCALINLINE VOID SetSseBit (FPSTATE *fpstate)
LOCALINLINE VOID SetAvxBit (FPSTATE *fpstate)
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


Detailed Description

This file contains APP primitives


Typedef Documentation

typedef EXT* LEVEL_CORE::EXTLIST

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

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

A regset type that contains all registers

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

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

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

typedef ADDRINT LEVEL_CORE::INS_REUSER_HANDLE

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

typedef vector<ADDRINT> LEVEL_CORE::INS_REUSER_ID_VEC

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

typedef ADDRINT LEVEL_CORE::INS_REUSER_STORE_HANDLE

opaque type

typedef class INDEX< 202 > LEVEL_CORE::PREG

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

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

A regset type that contains registers in the physical context

typedef class ADDR< 200 > LEVEL_CORE::REGVALUE

Type that represents a value of an ADDRINT-size register


Enumeration Type Documentation

enum LEVEL_CORE::BBL_STATE

bbl state enumeration - not used

enum LEVEL_CORE::BBL_TYPE

BBL types enumeration

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

enum LEVEL_CORE::CALLING_STANDARD

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

enum LEVEL_CORE::CHUNK_STATE

CHUNK state, to be used for consitency checking

enum LEVEL_CORE::CHUNK_TYPE

CHUNK types

enum LEVEL_CORE::EDG_STATE

EDG state enumeration - not used

enum LEVEL_CORE::EDG_TYPE

EDG type enumeration

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

enum LEVEL_CORE::EXT_ATTR_MODE

EXT attribute mode

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

enum LEVEL_CORE::FLAGS

Enumeration type for individual flags

enum LEVEL_CORE::FUNCTION_TYPE

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

enum LEVEL_CORE::IMG_STATE

not used

enum LEVEL_CORE::INS_REUSER_TYPE

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

enum LEVEL_CORE::REL_TYPE

Relocation types

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

enum LEVEL_CORE::RTN_STATE

not used

enum LEVEL_CORE::RTN_TYPE

RTN type

enum LEVEL_CORE::SACT_TYPE

x

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

enum LEVEL_CORE::SEC_STATE

SEC state, used for consitency checking

enum LEVEL_CORE::SEGMENT_TYPE

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

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

enum LEVEL_CORE::SYM_IFUNC_TYPE

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

enum LEVEL_CORE::SYM_STATE

used for consistency checking

enum LEVEL_CORE::SYSCALL_TYPE

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

Enumerator:
SYSCALL_TYPE_NONE  not a system call
SYSCALL_TYPE_SYSCALL  system call delivered via syscall
SYSCALL_TYPE_SYSENTER  system call delivered via sysenter
SYSCALL_TYPE_FARCALL  system call delivered via far call (lcall)
SYSCALL_TYPE_INT80  system call delivered via int 0x80
SYSCALL_TYPE_INT81  system call delivered via int 0x81
SYSCALL_TYPE_INT82  system call delivered via int 0x82
SYSCALL_TYPE_INT83  system call delivered via int 0x83

enum LEVEL_CORE::VAL_TYPE

VAL types


Function Documentation

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

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

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

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

APP LEVEL_CORE::APP_Alloc (  ) 

Allocate new APP, some initialization

BOOL LEVEL_CORE::APP_allocated ( APP  x  ) 

APP object is allocated

VOID LEVEL_CORE::APP_Free ( APP  app  ) 

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

VOID LEVEL_CORE::APP_GarbageCollect (  ) 

APP garbage collector, currently not used

APP LEVEL_CORE::APP_INVALID (  ) 

returns an invalid APP object

INT32 LEVEL_CORE::APP_no ( APP  x  ) 

return unique number of APP object

BOOL LEVEL_CORE::APP_valid ( APP  x  ) 

test validity of APP object

ARRAYBASE LEVEL_CORE::AppArrayBase ( "app pool"  ,
1024   
)

The root for all APP stripes

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

The base stripe for APP

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

attribute to hold dynamic SYMs that have this BBL as value

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

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

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

attribute to hold RELs that have this BBL as value

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

attribute to hold dynamic SYMs that have this BBL as value

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

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

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

attribute to hold RELs that have this CHUNKS as value

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

x

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

attribute to hold RELs that have this INS as value

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

Attribute for attaching comments to data structures

VOID LEVEL_CORE::BBL_AddLinkEdge ( BBL  bbl,
INS  call 
)

Add a link edge to a call BBL

BBL LEVEL_CORE::BBL_Alloc (  ) 

Allocate new BBL, some initialization

UINT32 LEVEL_CORE::BBL_AllowableSuccEdgCount ( BBL  bbl,
UINT32  max 
)

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

VOID LEVEL_CORE::BBL_Append ( BBL  bbl,
RTN  parent 
)

Append a BBL to RTN

UINT32 LEVEL_CORE::BBL_ByteSize ( BBL  bbl  ) 

size of a bbl in bytes

BOOL LEVEL_CORE::BBL_CanBeEntryPoint ( BBL  bbl,
BOOL  switch_ok 
)

Check whether BBL can be routine entry point

VOID LEVEL_CORE::BBL_Check ( BBL  bbl  ) 

check consistency

VOID LEVEL_CORE::BBL_CheckFree (  ) 

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

BOOL LEVEL_CORE::BBL_CheckSuccEdgType ( BBL  bbl,
EDG_TYPE  et 
)

verify that successor EDG is compatible with originating BBL type

BBL LEVEL_CORE::BBL_Clone ( BBL  bbl  ) 

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

BOOL LEVEL_CORE::BBL_ContainsCall ( BBL  bbl  ) 

Check whether BBL is call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsConditionalCall ( BBL  bbl  ) 

Check whether BBL is conditional call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsConditionalControlTransfer ( BBL  bbl  ) 

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

BOOL LEVEL_CORE::BBL_ContainsDirectCall ( BBL  bbl  ) 

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

BOOL LEVEL_CORE::BBL_ContainsDirectControlTransfer ( BBL  bbl  ) 

BOOL LEVEL_CORE::BBL_ContainsIndirectCall ( BBL  bbl  ) 

Check whether BBL is indirect call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsIndirectControlTransfer ( BBL  bbl  ) 

BOOL LEVEL_CORE::BBL_ContainsReturn ( BBL  bbl  ) 

Check whether BBL is a return (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsUnconditionalCall ( BBL  bbl  ) 

Check whether BBL is unconditional call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsUnresolvedIndirectJump ( BBL  bbl  ) 

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

CHUNK LEVEL_CORE::BBL_DataChunk ( BBL  bbl  ) 

return data CHUNK associated with a data BBL

VOID LEVEL_CORE::BBL_DataLinkWithChunk ( BBL  bbl,
CHUNK  chunk 
)

cross link a data bbl with a data chunck

VOID LEVEL_CORE::BBL_DataUnlinkChunk ( BBL  bbl  ) 

unlink a data bbl and the corresponding data chunk

VOID LEVEL_CORE::BBL_DeleteIns ( BBL  bbl  ) 

delete all the instructions in a basic block

VOID LEVEL_CORE::BBL_ExtAppend ( EXT  ext,
BBL  parent 
)

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

VOID LEVEL_CORE::BBL_ExtPrepend ( EXT  ext,
BBL  parent 
)

VOID LEVEL_CORE::BBL_Free ( BBL  bbl  ) 

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

VOID LEVEL_CORE::BBL_FreeContents ( BBL  bbl  ) 

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

VOID LEVEL_CORE::BBL_FreePredEdges ( BBL  bbl  ) 

Free the predecessor edges of the bbl

VOID LEVEL_CORE::BBL_FreeSuccEdges ( BBL  bbl  ) 

Free the successor edges of the bbl

VOID LEVEL_CORE::BBL_GarbageCollect (  ) 

BBL garbage collector, currently not used

string LEVEL_CORE::BBL_generateDotCFG ( BBL  bbl  ) 

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

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

OADDR LEVEL_CORE::BBL_GetOaddr ( BBL  target  ) 

get BBL OADDR (based on pos stripe)

BOOL LEVEL_CORE::BBL_HasUnmodeledPredEdges ( BBL  bbl,
BOOL  switch_ok 
)

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

BOOL LEVEL_CORE::BBL_HasUnmodeledSuccEdges ( BBL  bbl  ) 

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

VOID LEVEL_CORE::BBL_InitOriginal ( BBL  bbl  ) 

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

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

Insert BBL after another BBL within an RTN

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

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

Insert BBL before another BBL within an RTN

BOOL LEVEL_CORE::BBL_IsCycle ( BBL  bbl  ) 

Test whether a bbl is part of a single BBL loop

BOOL LEVEL_CORE::BBL_IsImageEntryPoint ( BBL  bbl  ) 

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

BOOL LEVEL_CORE::BBL_IsReturnSite ( BBL  bbl  ) 

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

BOOL LEVEL_CORE::BBL_MarkBblStarts ( BBL  containerBbl  ) 

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

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

Move all inss from src to dst following "after"

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

Move all inss from src to dst preceeding "before"

UINT32 LEVEL_CORE::BBL_NumAttrCrosslink ( BBL  bbl  ) 

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

LOCALFUN UINT32 LEVEL_CORE::BBL_NumAttrRegsym ( BBL  bbl  ) 

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

UINT32 LEVEL_CORE::BBL_NumExt ( BBL  parent  ) 

x

UINT32 LEVEL_CORE::BBL_NumPreds ( BBL  bbl  ) 

number of predecessor EDGs

UINT32 LEVEL_CORE::BBL_NumPredsInterproc ( BBL  bbl  ) 

number of predecessor EDGs which originate from a different RTN

UINT32 LEVEL_CORE::BBL_NumPredsInterprocNonCall ( BBL  bbl  ) 

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

UINT32 LEVEL_CORE::BBL_NumSuccs ( BBL  bbl  ) 

number of successor EDGs

EDG LEVEL_CORE::BBL_PredEdgFind ( BBL  dst,
EDG_TYPE  type 
)

find successor EDG based on type

VOID LEVEL_CORE::BBL_Prepend ( BBL  bbl,
RTN  parent 
)

Prepend a BBL to RTN

VOID LEVEL_CORE::BBL_RemoveRegsyms ( BBL  bbl  ) 

Remove crosslinked SYM from BBL

VOID LEVEL_CORE::BBL_SetImageEntryPoint ( BBL  bbl  ) 

add special marked identifying BBL as the entry point

BBL LEVEL_CORE::BBL_SplitAtIns ( BBL  firstBbl,
INS  splitIns 
)

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

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

string LEVEL_CORE::BBL_StringLong ( BBL  bbl  ) 

convert a BBL into a printable string - long version

string LEVEL_CORE::BBL_StringLongFancy ( BBL  bbl  ) 

produce string for BBL including INS

string LEVEL_CORE::BBL_StringShort ( BBL_TYPE  type  ) 

convert a BBL type into a printable string - 4 characters

EDG LEVEL_CORE::BBL_SuccEdgFind ( BBL  src,
BBL  dst 
)

find successor EDG based on traget BBL

EDG LEVEL_CORE::BBL_SuccEdgFind ( BBL  src,
EDG_TYPE  type 
)

find successor EDG based on type

EDG LEVEL_CORE::BBL_SuccEdgFindPcRelative ( BBL  bbl  ) 

find successor EDG based on traget BBL

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

find successor EDG based on traget BBL

BBL_TYPE LEVEL_CORE::BBL_TYPE_Unconditionalize ( BBL_TYPE  type  ) 

transform a conditional BBL_TYPE in the corresponding unconditional type

VOID LEVEL_CORE::BBL_TypeSet ( BBL  bbl,
BBL_TYPE  type 
)

change BBL type with extra sanity checks

VOID LEVEL_CORE::BBL_TypifyAndCreateEdgs ( SEC  sec,
BBL  bbl 
)

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

VOID LEVEL_CORE::BBL_TypifyAndCreateEdgsFromBblToBbl ( BBL  src_bbl,
BBL  dst_bbl 
)

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

BBL LEVEL_CORE::BBL_UniquePredecessor ( BBL  bbl  ) 

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

VOID LEVEL_CORE::BBL_Unlink ( BBL  bbl  ) 

Unlink a BBL from an RTN

VOID LEVEL_CORE::BBL_UnlinkFreeCode ( BBL  bbl  ) 

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

VOID LEVEL_CORE::BBL_UnlinkFreeData ( BBL  bbl  ) 

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

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

The root for all BBL stripes

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

The base stripe for BBL

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

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

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 (  ) 

Returns:
if the flags splitting should be done

VOID LEVEL_CORE::DYNSYM_Unlink ( SYM  sym  ) 

unlink a SYM from an IMG

EDG LEVEL_CORE::EDG_Alloc (  ) 

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

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

allocate and link an EDG to the two specified BBLS

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

VOID LEVEL_CORE::EDG_ExtPrepend ( EXT  ext,
EDG  parent 
)

VOID LEVEL_CORE::EDG_Free ( EDG  edg  ) 

deallocate unlinked EDG

VOID LEVEL_CORE::EDG_GarbageCollect (  ) 

EDG garbage colletor

BOOL LEVEL_CORE::EDG_InterProcedural ( EDG  e  ) 

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

BOOL LEVEL_CORE::EDG_IsFallthrough ( EDG  edg  ) 

Determing whether an EDG is a fallthru EDG using the type

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

link an EDG to the two specified BBLS

VOID LEVEL_CORE::EDG_MovePredEdges ( BBL  bbl_from,
BBL  bbl_to 
)

Move the predecessor edges from bbl_from to bbl_to

VOID LEVEL_CORE::EDG_MoveSuccEdges ( BBL  a,
BBL  b 
)

Move the successor edges from a to b

UINT32 LEVEL_CORE::EDG_NumExt ( EDG  parent  ) 

x

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

Insert predecessor EDG after another such EDG

VOID LEVEL_CORE::EDG_PredPrepend ( EDG  edg,
BBL  parent 
)

Prepend predecessor EDG to list of predecessor EDGs

string LEVEL_CORE::EDG_StringShort ( EDG  edg  ) 

convert a EDG into a printable string - short version

string LEVEL_CORE::EDG_StringShort ( EDG_TYPE  type  ) 

convert a EDG type into a printable string

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

Insert successor EDG after another such EDG

VOID LEVEL_CORE::EDG_SuccPrepend ( EDG  edg,
BBL  parent 
)

Prepend successor EDG to list of predecessor EDGs

VOID LEVEL_CORE::EDG_Unlink ( EDG  edg  ) 

Unlink EDG

LOCALFUN VOID LEVEL_CORE::EDG_UnlinkPred ( EDG  edg  ) 

Unlink EDG from Dst only

VOID LEVEL_CORE::EDG_UnlinkSucc ( EDG  edg  ) 

Unlink EDG from Src only

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

The root for all EDG stripes

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

The base stripe for REL

EXT LEVEL_CORE::EXT_Alloc (  ) 

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

Link register allocation hint to basic block

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

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

Returns:
Returns the new EXT

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

Link register allocation hint to instruction

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

x

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

x

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

x

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

x

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

x

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

x

EXT LEVEL_CORE::EXT_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.

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

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

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

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

BOOL LEVEL_CORE::HasSpecialOffsetForGotPcAccess ( RTN  rtn  ) 

x

IMG LEVEL_CORE::IMG_Alloc (  ) 

x

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

x

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

x

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

x

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

x

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

x

VOID LEVEL_CORE::IMG_Append ( IMG  img,
APP  parent 
)

Append an IMG to APP

VOID LEVEL_CORE::IMG_Check ( IMG  img  ) 

x

VOID LEVEL_CORE::IMG_ChunkifySecs ( IMG  img  ) 

subdivide SECs into chunks

VOID LEVEL_CORE::IMG_ComputeNewSecDataExec ( IMG  img  ) 

x

VOID LEVEL_CORE::IMG_ComputeNewSecDataUncooked ( IMG  img  ) 

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

VOID LEVEL_CORE::IMG_ComputeNewSecSizeExecAndAddressMapping ( IMG  img  ) 

Iterate over executable section and compute the addresses for the instructions

VOID LEVEL_CORE::IMG_ComputeNewSecSizeUncooked ( IMG  img  ) 

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

VOID LEVEL_CORE::IMG_ConvertWeirdBranches ( IMG  img  ) 

x

VOID LEVEL_CORE::IMG_CookExecutableSections ( IMG  img  ) 

x

SYM LEVEL_CORE::IMG_FindDynsymByOriginalIndex ( IMG  img,
UINT32  index 
)

x

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

Find regular symbol by name

SYM LEVEL_CORE::IMG_FindRegsymByOriginalIndex ( IMG  img,
UINT32  index 
)

x

SEC LEVEL_CORE::IMG_FindSecByIaddr ( IMG  img,
IADDR  iaddr 
)

x

SEC LEVEL_CORE::IMG_FindSecByIaddrEndInclusive ( IMG  img,
IADDR  iaddr 
)

x

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

x

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

x

SEC LEVEL_CORE::IMG_FindSecByOaddr ( IMG  img,
OADDR  oaddr 
)

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

SEC LEVEL_CORE::IMG_FindSecByOaddrEndInclusive ( IMG  img,
OADDR  oaddr 
)

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

SEC LEVEL_CORE::IMG_FindSecByOriginalIndex ( IMG  img,
UINT32  index 
)

x

VOID LEVEL_CORE::IMG_Free ( IMG  img  ) 

x

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

x

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

Insert IMG after another IMG within an APP

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

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

Insert IMG before another IMG within an APP

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

BOOL LEVEL_CORE::IMG_IsAddressInImage ( IMG  img,
ADDRINT  addr 
)

Check if address is within image addresses

Parameters:
addr address to check.

BOOL LEVEL_CORE::IMG_IsMainImage ( IMG  img  ) 

Check if img is a main image

VOID LEVEL_CORE::IMG_LinkDynsymWithTarget ( IMG  img  ) 

Crosslink dynamic SYMs with the objects they're describing

VOID LEVEL_CORE::IMG_LinkRegsymWithTarget ( IMG  img  ) 

Crosslink regular SYMs with the objects they're describing

VOID LEVEL_CORE::IMG_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.

Parameters:
[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.

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

BBL LEVEL_CORE::INS_bbl ( INS  x  ) 

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

UINT32 LEVEL_CORE::INS_BranchDisplacementWidthBits ( INS  ins  ) 

Return width of branch offset in BITS

UINT32 LEVEL_CORE::INS_BranchDisplacementWidthBytes ( INS  ins  ) 

Return width of branch offset in BYTES.

REG LEVEL_CORE::INS_CallOrBranchGetIndirectRegister ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_CallOrBranchIsMemoryIndirect ( INS  ins  ) 

Returns:
true if this branch or call indirect through memory

BOOL LEVEL_CORE::INS_CallOrBranchIsRegisterIndirect ( INS  ins  ) 

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

IADDR LEVEL_CORE::INS_CallRetIaddr ( INS  ins  ) 

x

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

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

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

BOOL LEVEL_CORE::INS_ChangeStackPtr ( INS  ins  ) 

Change stack pointers:

REG_STACK_PTR -> REG_PIN_STACK_PTR REG_PIN_BRIDGE_ORIG_SP -> REG_STACK_PTR

Returns:
Returns true if at least one register was changed

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

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

BOOL LEVEL_CORE::INS_ChangeToUsePinFlags ( const INS  ins  ) 

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

VOID LEVEL_CORE::INS_Check ( INS  ins  ) 

x

VOID LEVEL_CORE::INS_CheckFree (  ) 

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

VOID LEVEL_CORE::INS_ClearDirtyG ( INS  ins  ) 

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

string LEVEL_CORE::INS_Comment ( INS  ins  ) 

Get the comment string from an instruction.

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

VOID LEVEL_CORE::INS_ConvertCallToBranch ( INS  ins  ) 

Convert a call instruction to a branch

INS LEVEL_CORE::INS_ConvertLoadToMoveHack ( INS  jmp  ) 

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

VOID LEVEL_CORE::INS_ConvertToIndirectJumpHack ( INS  ins  ) 

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

VOID LEVEL_CORE::INS_Copy ( INS  ins,
INS  clone 
)

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

VOID LEVEL_CORE::INS_CopyArchFields ( INS  ins,
INS  clone 
)

Copy everything to the clone.

VOID LEVEL_CORE::INS_CopyComment ( INS  toIns,
INS  fromIns 
)

Copy any comment on fromIns to toIns.

Parameters:
in/out] toIns
[in] fromIns 

VOID LEVEL_CORE::INS_CopyXlateAttributes ( INS  insNew,
INS  insOrig 
)

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

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

REG LEVEL_CORE::INS_CountRegister ( INS  ins  ) 

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

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

Forward declaration of the 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 
)

Returns:
size of instruction

UINT32 LEVEL_CORE::INS_EncodeSizeG ( INS  ins  ) 

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

VOID LEVEL_CORE::INS_EncodeSizeSetG ( INS  ins,
UINT32  size 
)

Make the INS_EncodeSizeSet available for external use

BOOL LEVEL_CORE::INS_Equal ( INS  ins,
INS  ins2 
)

x

BOOL LEVEL_CORE::INS_EqualArchFields ( INS  ins1,
INS  ins2 
)

Compare the 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 
)

template<typename FETCHER_>
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.

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

VOID LEVEL_CORE::INS_Free ( INS  ins  ) 

Free INS

VOID LEVEL_CORE::INS_FreeRel ( INS  ins  ) 

Free INS and possibly attached reloc

VOID LEVEL_CORE::INS_GarbageCollect (  ) 

INS garbage collector, currently not used

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

x

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

x

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

x

VOID LEVEL_CORE::INS_GenRetImm ( INS  ins,
UINT64  imm 
)

x

VOID LEVEL_CORE::INS_GenSizedNop ( INS  ins,
UINT  requested_length_bytes 
)

Create a "nop" instruction witha requested size

UINT8 LEVEL_CORE::INS_get_num_reads ( INS  x  ) 

Returns:
Returns the number of registers read by this instruction

UINT8 LEVEL_CORE::INS_get_num_writes ( INS  x  ) 

Returns:
Returns the number of registers written by this instruction

UINT LEVEL_CORE::INS_get_pos_r ( INS  x,
UINT  i 
)

Returns:
Returns xed operand position of ith read register

UINT LEVEL_CORE::INS_get_pos_w ( INS  x,
UINT  i 
)

Returns:
Returns xed operand position of ith written register

REG LEVEL_CORE::INS_get_reg_r ( INS  x,
UINT  i 
)

Returns:
Returns the ith read register

REG LEVEL_CORE::INS_get_reg_w ( INS  x,
UINT  i 
)

Returns:
Returns the ith written register

xed_operand_enum_t LEVEL_CORE::INS_get_role_r ( INS  x,
UINT  i 
)

x

xed_operand_enum_t LEVEL_CORE::INS_get_role_w ( INS  x,
UINT  i 
)

Returns:
Returns role of ith written register

REG LEVEL_CORE::INS_GetBaseReg ( INS  ins  ) 

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

REG LEVEL_CORE::INS_GetBaseRegOne ( INS  ins  ) 

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

ADDRDELTA LEVEL_CORE::INS_GetBranchDisplacement ( INS  ins  ) 

Note:
the displacement is a signed number.

REG LEVEL_CORE::INS_GetFirstAluSourceReg ( INS  ins  ) 

x

ADDRINT LEVEL_CORE::INS_GetImmediate ( INS  ins  ) 

x

REG LEVEL_CORE::INS_GetIndexReg ( INS  ins  ) 

x

ADDRDELTA LEVEL_CORE::INS_GetMemoryDisplacement ( INS  ins  ) 

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

ADDRINT LEVEL_CORE::INS_GetMTSafePatchLocation ( ADDRINT  addr,
USIZE  size 
)

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

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

OADDR LEVEL_CORE::INS_GetOaddr ( INS  ins  ) 

x

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

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

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

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

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

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

LOCALFUN REG LEVEL_CORE::INS_GetRoleReg ( INS  ins,
xed_operand_enum_t  role 
)

Returns:
the read register which fulfils the requested role.

UINT32 LEVEL_CORE::INS_GetScale ( INS  ins  ) 

x

ADDRINT LEVEL_CORE::INS_GetSecondImmediate ( INS  ins  ) 

x

ADDRDELTA LEVEL_CORE::INS_GetSignedImmediate ( INS  ins  ) 

Note:
Return the immediate operand as a sign number.

BOOL LEVEL_CORE::INS_HasFixed8BitBranchDisplacement ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_HasImmediateOperand ( INS  ins  ) 

x

BOOL LEVEL_CORE::INS_HasImplicitMemoryReference ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_HasImplicitStackReference ( INS  ins  ) 

Test if this instruction has an implicit stack reference.

BOOL LEVEL_CORE::INS_HasMemoryDisplacement ( INS  ins  ) 

Return true if the operation really has a memory displacement.

BOOL LEVEL_CORE::INS_HasRepEqual ( INS  ins  ) 

Returns:
true if this is a REPE

BOOL LEVEL_CORE::INS_HasSegmentRegPrefix ( INS  ins  ) 

Just calls INS_SegmentPrefix()

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

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

VOID LEVEL_CORE::INS_InitEncodeDecoder (  ) 

x

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

Make a far direct call

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

Make a far direct jump

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

Create far jumps and calls

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

x

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

x

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

Create an GPR32/ XMM operation

VOID LEVEL_CORE::INS_InitHalt ( INS  ins  ) 

x

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.

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

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitLods ( INS  ins  ) 

x

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

Operate with an immediate and a memory operand.

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

LOCALFUN VOID LEVEL_CORE::INS_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.

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

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

x

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

Create a PAND reg/reg

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

Create a PCMPEQB reg, mem

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

Create a PCMPEQD reg, mem

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

Create a PMOVMSKB r32, xmm

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

x

VOID LEVEL_CORE::INS_InitPop ( INS  ins,
REG  reg 
)

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

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

VOID LEVEL_CORE::INS_InitPopAL ( INS  ins  ) 

x

VOID LEVEL_CORE::INS_InitPopF ( INS  ins  ) 

x

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

Create a POR reg, mem

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

x

VOID LEVEL_CORE::INS_InitPush ( INS  ins,
REG  reg 
)

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

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

VOID LEVEL_CORE::INS_InitPushAL ( INS  ins  ) 

x

VOID LEVEL_CORE::INS_InitPushF ( INS  ins  ) 

x

VOID LEVEL_CORE::INS_InitPushI ( INS  ins,
UINT64  imm 
)

x

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

x

VOID LEVEL_CORE::INS_InitRdtsc ( INS  ins  ) 

x

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

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

VOID LEVEL_CORE::INS_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  ) 

Returns:
if ins is any type of popf

BOOL LEVEL_CORE::INS_IsAvx ( INS  ins  ) 

Return TRUE iff the ins is an AVX instruction

BOOL LEVEL_CORE::INS_IsBblTerminator ( INS  ins  ) 

x

BOOL LEVEL_CORE::INS_IsBitTest ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsBsr ( INS  ins  ) 

Return TRUE if the INS is a BSR instruction

BOOL LEVEL_CORE::INS_IsCJmp ( INS  ins  ) 

Return TRUE if the INS is a Conditional branch instruction

BOOL LEVEL_CORE::INS_IsCmov ( INS  ins  ) 

Return TRUE if the INS is an integer conditional move instruction

BOOL LEVEL_CORE::INS_IsCmps ( INS  ins  ) 

Return TRUE if the INS is a CMPS

BOOL LEVEL_CORE::INS_IsCondWrite ( INS  ins  ) 

Return TRUE if the INS is does a conditional write.

BOOL LEVEL_CORE::INS_IsCpuid ( INS  ins  ) 

Returns:
true if the instruction is CPUID.

BOOL LEVEL_CORE::INS_IsDec ( const INS  ins  ) 

returns true if this instruction is a decrement.

BOOL LEVEL_CORE::INS_IsEnter ( INS  ins  ) 

Return TRUE if the INS is an ENTER instruction.

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

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

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

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

BOOL LEVEL_CORE::INS_IsFCmov ( INS  ins  ) 

Return TRUE if the INS is a float conditional move instruction

BOOL LEVEL_CORE::INS_IsFloat ( INS  ins  ) 

Return TRUE if the INS is an x87 floating point instruction

BOOL LEVEL_CORE::INS_IsFxrestore ( INS  ins  ) 

Return TRUE if the INS is an fxrstor instruction

BOOL LEVEL_CORE::INS_IsFxsave ( INS  ins  ) 

Return TRUE if the INS is an fxsave instruction

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

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

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

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

BOOL LEVEL_CORE::INS_IsInc ( const INS  ins  ) 

returns true if this instruction is a increment.

BOOL LEVEL_CORE::INS_IsIOStringOp ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsIpRelAddr ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsJCXZ ( INS  ins  ) 

Return TRUE if the INS is a JrCXZ instruction.

BOOL LEVEL_CORE::INS_IsJNZ ( INS  ins  ) 

Return TRUE if the INS is a JNZ instruction.

BOOL LEVEL_CORE::INS_IsJZ ( INS  ins  ) 

Return TRUE if the INS is a JZ instruction.

BOOL LEVEL_CORE::INS_IsLeave ( INS  ins  ) 

Return TRUE if the INS is a LEAVE instruction

BOOL LEVEL_CORE::INS_IsLoop ( INS  ins  ) 

Return TRUE if the INS is a LOOP instruction.

BOOL LEVEL_CORE::INS_IsLoope ( INS  ins  ) 

Return TRUE if the INS is a LOOPE instruction.

BOOL LEVEL_CORE::INS_IsLoopne ( INS  ins  ) 

Return TRUE if the INS is a LOOPNE instruction.

BOOL LEVEL_CORE::INS_IsLoopType ( const INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsMMXorXMM ( const INS  ins  ) 

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

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

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

BOOL LEVEL_CORE::INS_IsMTSafeToPatch ( ADDRINT  addr,
USIZE  size 
)

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

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

BOOL LEVEL_CORE::INS_IsPatchable ( INS  ins  ) 

Return TRUE if the instruction is patchable

BOOL LEVEL_CORE::INS_IsPop ( const INS  ins  ) 

returns true if this instruction is a pop.

BOOL LEVEL_CORE::INS_IsPopAll16 ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsPopAll32 ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsPopF ( const INS  ins  ) 

Returns:
if ins is popf

BOOL LEVEL_CORE::INS_IsPopFD ( const INS  ins  ) 

Returns:
if ins is popfd

BOOL LEVEL_CORE::INS_IsPopFQ ( const INS  ins  ) 

Returns:
if ins is popfd

BOOL LEVEL_CORE::INS_IsPush ( const INS  ins  ) 

returns true if this instruction is a push.

BOOL LEVEL_CORE::INS_IsPushAll16 ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsPushAll32 ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_IsScas ( INS  ins  ) 

Return TRUE if the INS is a SCAS

BOOL LEVEL_CORE::INS_IsShift ( INS  ins  ) 

returns true if this instruction is a shift.

ADDRINT LEVEL_CORE::INS_IsSignedImmediate ( INS  ins  ) 

x

REG LEVEL_CORE::INS_IsSimpleRegIndirectRead ( INS  ins  ) 

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

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

REG LEVEL_CORE::INS_IsSimpleRegIndirectWrite ( INS  ins  ) 

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

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

BOOL LEVEL_CORE::INS_IsSimpleStackOffsetRead ( INS  ins,
INT32 *  offset 
)

ins use simple stack indirect plus offset addressing mode

BOOL LEVEL_CORE::INS_IsSimpleStackOffsetWrite ( INS  ins,
INT32 *  offset 
)

ins use simple stack indirect plus offset addressing mode

BOOL LEVEL_CORE::INS_IsSse ( INS  ins  ) 

Return TRUE iff the ins is an SSE instruction

BOOL LEVEL_CORE::INS_IsStringOp ( INS  ins  ) 

returns true if this instruction is a string op.

BOOL LEVEL_CORE::INS_IsUJmp ( INS  ins  ) 

Return TRUE if the INS is a Unconditional branch instruction

BOOL LEVEL_CORE::INS_IsXlat ( INS  ins  ) 

Returns:
true if the instruction is XLAT.

BOOL LEVEL_CORE::INS_IsXrestore ( INS  ins  ) 

Return TRUE if the INS is an xrstor instruction

BOOL LEVEL_CORE::INS_IsXsave ( INS  ins  ) 

Return TRUE if the INS is an xsave instruction

VOID LEVEL_CORE::INS_MakeAbsolute32Address ( INS  ins,
IADDR  target 
)

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

VOID LEVEL_CORE::INS_MakeBaseAddress ( INS  ins,
REG  base 
)

Rewrite memop to use base register address mode

VOID LEVEL_CORE::INS_MarkBblStart ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_MarkedForDeletion ( INS  ins  ) 

Is this instruction marked for deletion?

VOID LEVEL_CORE::INS_MarkForDeletion ( INS  ins  ) 

Mark this instruction for deletion,

VOID LEVEL_CORE::INS_MarkRtnStart ( INS  ins  ) 

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

int LEVEL_CORE::INS_MaxDecodedBytes (  ) 

return the maximum bytes that are accessed b decoding one instruction

USIZE LEVEL_CORE::INS_MaxProbeSize ( BOOL  requestRipAndAddrProbe  ) 

Returns:
Maximum size in bytes of a probe

BOOL LEVEL_CORE::INS_MayWriteAllMMRegisters ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_MemopDisplacementOnly ( INS  ins  ) 

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

ADDRINT LEVEL_CORE::INS_MemoryDisplacementWidthBytes ( INS  ins  ) 

Return width of memory offset in BYTES

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

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

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

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

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

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

BOOL LEVEL_CORE::INS_MTSafePatchBranch ( OADDR  brAddr,
OADDR  tgtAddr 
)

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

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

BOOL LEVEL_CORE::INS_MTSafeWriteJmp ( OADDR  insAddr,
OADDR  tgtAddr 
)

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

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

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

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

INS LEVEL_CORE::INS_next ( INS  x  ) 

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

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

IADDR LEVEL_CORE::INS_NextInsIaddr ( INS  ins  ) 

Compute the address of the next isntruction

OADDR LEVEL_CORE::INS_NextInsOaddr ( INS  ins,
OADDR  addr 
)

x

UINT32 LEVEL_CORE::INS_NumAttrCrosslink ( INS  ins  ) 

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

UINT32 LEVEL_CORE::INS_NumExt ( INS  parent  ) 

x

BOOL LEVEL_CORE::INS_OperandIsGsOrFsReg ( INS  ins  ) 

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

UINT32 LEVEL_CORE::INS_orig_size ( INS  x  ) 

Returns:
Returns original size of instruction in bytes

VOID LEVEL_CORE::INS_orig_size_set ( INS  x,
UINT32  y 
)

Sets original size of instruction in bytes

FLAGS LEVEL_CORE::INS_PhyFlagsMayWritten ( const INS  ins  ) 

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

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

FLAGS LEVEL_CORE::INS_PhyFlagsMustWritten ( const INS  ins  ) 

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

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

FLAGS LEVEL_CORE::INS_PhyFlagsRead ( const INS  ins  ) 

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

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

BOOL LEVEL_CORE::INS_PrefixIsGsOrFsReg ( INS  ins  ) 

Returns:
TRUE if instruction prefix is GS or FS

VOID LEVEL_CORE::INS_Prepend ( INS  ins,
BBL  parent 
)

x

INS LEVEL_CORE::INS_prev ( INS  x  ) 

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

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

string LEVEL_CORE::INS_PrintString ( INS  ins,
ADDRINT  addr 
)

x

INT32 LEVEL_CORE::INS_RawEncodeIns ( INS  ins,
UINT8 *  buffer 
)

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

LOCALFUN string LEVEL_CORE::INS_RawInstBytes ( INS  ins  ) 

x

BOOL LEVEL_CORE::INS_ReadsAllMMRegisters ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_ReadsAllMmxRegisterss ( INS  ins  ) 

Returns true if the ins writes all the mmx registers.

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

set kth read register of instruction x

BOOL LEVEL_CORE::INS_RegsReadBeforeWritten ( INS  ins  ) 

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

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

set kth write register of instruction x

VOID LEVEL_CORE::INS_RemoveRep ( INS  ins  ) 

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

Parameters:
[in] ins The instruction to change.

VOID LEVEL_CORE::INS_RenameRegsForInlining ( CALLING_STANDARD  std,
INS  ins 
)

Rename application regs to their corresponding pin regs in ins.

FIXME: RM REWRITE TO USE THE REGR/REGW ARRAYS

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

INS_ReplaceMemop() - replace all components of memory operand

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

Pull out all the operands of a memory references

UINT8 LEVEL_CORE::INS_set_num_reads ( INS  x,
UINT  v 
)

Sets the number of registers read by this instruction

UINT8 LEVEL_CORE::INS_set_num_writes ( INS  x,
UINT  v 
)

Sets the number of registers written by this instruction

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

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

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

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

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

x

VOID LEVEL_CORE::INS_SetDirty ( INS  ins  ) 

mark that the instruction encoding in the cache is not valid

VOID LEVEL_CORE::INS_SetImmediate ( INS  ins,
ADDRINT  imm 
)

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

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

VOID LEVEL_CORE::INS_SetIndexRegister ( INS  ins,
REG  newIndex 
)

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

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

x

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

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

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

rewrite a register operand to use the given register.

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

Append code to sign extend src to dst

USIZE LEVEL_CORE::INS_SizeOfDirectJmp (  ) 

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

USIZE LEVEL_CORE::INS_SizeOfIpRelativeMemJmp (  ) 

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

string LEVEL_CORE::INS_StringLong ( INS  ins  ) 

x

string LEVEL_CORE::INS_StringShort ( INS  ins  ) 

x

string LEVEL_CORE::INS_StringShorter ( INS  ins  ) 

x

string LEVEL_CORE::INS_StringShortFancy ( INS  ins  ) 

produce a string for INS extended by profile and exception information

string LEVEL_CORE::INS_StringXed ( INS  ins  ) 

x

BOOL LEVEL_CORE::INS_SyscallHasFallThrough ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_SyscallIsTakenBranch ( INS  ins  ) 

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

LOCALFUN SYSCALL_TYPE LEVEL_CORE::INS_SyscallType ( INS  ins  ) 

Returns:
the syscall type

PREDICATE_IA32 LEVEL_CORE::INS_TestedCondition ( INS  ins  ) 

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

VOID LEVEL_CORE::INS_Unlink ( INS  ins  ) 

Unlink INS from BBL

BOOL LEVEL_CORE::INS_ValidateEncoding ( const INS  ins  ) 

Validate the encoding of ins.

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

Generate a Vinsertf128 from memory.

BOOL LEVEL_CORE::INS_WritesAllMMRegisters ( INS  ins  ) 

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

BOOL LEVEL_CORE::INS_WritesAllMmxRegisters ( INS  ins  ) 

Returns true if the ins writes all the mmx registers.

xed_decoded_inst_t* LEVEL_CORE::INS_xed_dec ( INS  ins  ) 

Returns:
This provides the pointer to the decoded xed instruction.

xed_operand_values_t* LEVEL_CORE::INS_xed_operand_values ( INS  ins  ) 

Returns:
This provides the pointer to the decoded xed instruction operand values.

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

Replace xedreg with pinreg in the flat regs

Returns:
foo

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

Append code to zero extend src to dst

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

The root for all BBL stripes

INS_REUSERS_MANAGER& LEVEL_CORE::InsReusersManager (  ) 

Return the single instance (object) of the INS_REUSERS_MANAGER class

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

The base stripe for INS

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

x

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

x

STRIPE<INS_XED_STRUCT_DECODE> LEVEL_CORE::InsStripeXEDDecode ( "ins stripe 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.

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

UINT32 LEVEL_CORE::InvalidSysCallNumber (  ) 

Return integer that represents invalid syscall number

xed_iclass_enum_t LEVEL_CORE::JccIclassToCmovcc ( INS  ins  ) 

Returns:
cmov with equivalent test as jmp

KNOB<BOOL> LEVEL_CORE::knob_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.

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

REGVALUE LEVEL_CORE::REG_ReadPseudo ( REG  reg  ) 

Read the value of a pseudo register.

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

REGVALUE LEVEL_CORE::REG_ReadShortFpFromFxsave ( REG  reg,
const FPSTATE *  fpstate 
)

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

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

const REGVALUE128& LEVEL_CORE::REG_ReadStFromFxsave ( REG  reg,
const FPSTATE *  fpstate 
)

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

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

VOID LEVEL_CORE::REG_ReadStFromFxsave ( REG  reg,
const FPSTATE *  fpstate,
VOID *  val 
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const REGVALUE512& LEVEL_CORE::REG_ReadZmmFromFxsave ( REG  zmm,
const FPSTATE *  fpstate 
)

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

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

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

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

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

REG LEVEL_CORE::REG_RenameAppReg ( const REG  reg  ) 

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.

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

VOID LEVEL_CORE::REG_StorePseudo ( REG  reg,
REGVALUE  val 
)

Write the value of a pseudo register.

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

VOID LEVEL_CORE::REG_StoreShortFpToFxsave ( REG  reg,
const REGVALUE  val,
FPSTATE *  fpstate 
)

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

Parameters:
[in] reg The FP register number.
[in] val The value of the FP register.
[out] fpstate The '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.

Parameters:
[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.

Parameters:
[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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Return the register that holds the ith syscall argument

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

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

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

Return the register that holds the syscall number

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

Return the register that holds the syscall result

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

Registers saved in syscall

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

Insert Before

VOID LEVEL_CORE::REGSYM_Unlink ( SYM  sym  ) 

unlink a SYM from an IMG

REL_TYPE LEVEL_CORE::REL_AddrintRel (  ) 

rel type for an address

REL LEVEL_CORE::REL_Alloc (  ) 

Allocate a REL

VOID LEVEL_CORE::REL_Check ( REL  rel  ) 

x

REL LEVEL_CORE::REL_First (  ) 

VOID LEVEL_CORE::REL_Free ( REL  rel  ) 

Deallocate an unlinked REL

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

Unlink REL from CHUNK

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

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

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

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

REL LEVEL_CORE::REL_Next ( REL  rel  ) 

string LEVEL_CORE::REL_StringShort ( REL  rel  ) 

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

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

Append REL to SEC

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

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

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

VOID LEVEL_CORE::REL_UnlinkChunk ( REL  rel  ) 

Unlink REL from CHUNK

BOOL LEVEL_CORE::REL_ValueEqual ( REL  rel,
REL  master 
)

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

VOID LEVEL_CORE::REL_ValueSetBbl ( REL  rel,
BBL  bbl 
)

set the value of a REL (to SYM)

VOID LEVEL_CORE::REL_ValueSetChunk ( REL  rel,
CHUNK  chunk 
)

set the value of a REL (to SYM)

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

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

VOID LEVEL_CORE::REL_ValueSetGot ( REL  rel,
GOT  got 
)

set the value of a REL (to GP)

VOID LEVEL_CORE::REL_ValueSetIns ( REL  rel,
INS  ins 
)

set the value of a REL (to SYM)

VOID LEVEL_CORE::REL_ValueSetLdef ( REL  rel,
LDEF  ldef 
)

set the value of a REL (to GP)

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

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

VOID LEVEL_CORE::REL_ValueSetUint32 ( REL  rel,
UINT32  v 
)

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

VOID LEVEL_CORE::REL_ValueSetUint64 ( REL  rel,
UINT64  v 
)

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

VOID LEVEL_CORE::REL_ValueSetZero ( REL  rel  ) 

set the value of a REL (to ZERO)

VOID LEVEL_CORE::REL_ValueUnlink ( REL  rel,
BOOL  relax 
)

x

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

The root for all REL stripes

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

The base stripe for REL

RTN LEVEL_CORE::RTN_Alloc (  ) 

Allocate a new RTN

VOID LEVEL_CORE::RTN_Append ( RTN  rtn,
SEC  parent 
)

Append RTN to SEC

UINT32 LEVEL_CORE::RTN_ByteSize ( RTN  rtn  ) 

Compute number of static INSs inside RTN

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

VOID LEVEL_CORE::RTN_ExtPrepend ( EXT  ext,
RTN  parent 
)

VOID LEVEL_CORE::RTN_Free ( RTN  rtn  ) 

Deallocate unlinked RTN

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

Insert RTN after another RTN within a SEC

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

Insert RTN before another RTN within a SEC

BOOL LEVEL_CORE::RTN_IsLeaf ( RTN  rtn  ) 

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

VOID LEVEL_CORE::RTN_MakeBbls ( RTN  rtn  ) 

Build basic blocks inside routine

VOID LEVEL_CORE::RTN_Mark1Bbls ( RTN  rtn  ) 

Set the First marker on all bbls

VOID LEVEL_CORE::RTN_MoveBbls ( RTN  src,
RTN  dst 
)

Move bbls from one container to another container routine

UINT32 LEVEL_CORE::RTN_NumAttrCrosslink ( RTN  rtn  ) 

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

UINT32 LEVEL_CORE::RTN_NumBbl ( RTN  rtn  ) 

Compute number of static BBLs inside RTN

UINT32 LEVEL_CORE::RTN_NumExt ( RTN  parent  ) 

x

UINT32 LEVEL_CORE::RTN_numIns ( RTN  rtn  ) 

Compute number of static INSs inside RTN

VOID LEVEL_CORE::RTN_Prepend ( RTN  rtn,
SEC  parent 
)

Prepend RTN to SEC

VOID LEVEL_CORE::RTN_RemoveAllExt ( RTN  rtn  ) 

Removes all extensions from the received routine.

VOID LEVEL_CORE::RTN_SetVaddr ( RTN  rtn,
IADDR  iaddr 
)

set the vaddr of the RTN

string LEVEL_CORE::RTN_StringLong ( RTN  rtn  ) 

produce string for RTN

string LEVEL_CORE::RTN_StringLongDataFancy ( RTN  rtn  ) 

produce string for RTN also listing BBLs

string LEVEL_CORE::RTN_StringLongFancy ( RTN  rtn  ) 

produce string for RTN also listing BBLs

VOID LEVEL_CORE::RTN_TypifyBblsAndCreateEdgs ( RTN  rtn  ) 

determing BBL type based on last INS and create sucessor EDGs

VOID LEVEL_CORE::RTN_Unlink ( RTN  rtn  ) 

Unlink RTN from a SEC

VOID LEVEL_CORE::RTN_UnmakeBbls ( RTN  rtn  ) 

Put all routine instructions in one basic block

VOID LEVEL_CORE::RTN_Unmark1Bbls ( RTN  rtn  ) 

Reset all the markers on all the bbls

UINT32 LEVEL_CORE::RTN_VerifyFallthroughs ( RTN  rtn  ) 

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

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

x

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

X

SEC LEVEL_CORE::SEC_Alloc (  ) 

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

VOID LEVEL_CORE::SEC_Append ( SEC  sec,
IMG  parent 
)

append a SEC to IMG

VOID LEVEL_CORE::SEC_Check ( SEC  sec  ) 

x

VOID LEVEL_CORE::SEC_ComputeNewSecDataExec ( SEC  sec,
VOID *  data 
)

This function does the final encoding into the code cache

ADDRINT LEVEL_CORE::SEC_ComputeOutputSizeOfExecutableSec ( SEC  sec,
const ADDRINT  secStart 
)

x

BOOL LEVEL_CORE::SEC_ContainsIaddr ( SEC  sec,
IADDR  iaddr 
)

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

BOOL LEVEL_CORE::SEC_ContainsIaddrEndInclusive ( SEC  sec,
IADDR  iaddr 
)

get a piece of data directly from the incoming SEC data

BOOL LEVEL_CORE::SEC_ContainsOaddr ( SEC  sec,
OADDR  oaddr 
)

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

BOOL LEVEL_CORE::SEC_ContainsOaddrEndInclusive ( SEC  sec,
OADDR  oaddr 
)

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

VOID LEVEL_CORE::SEC_CreateOriginalIns ( SEC  sec  ) 

x

CHUNK LEVEL_CORE::SEC_FindChunkByIaddr ( SEC  sec,
IADDR  iaddr 
)

Find a particular routine by iaddr in the given section

INS LEVEL_CORE::SEC_FindOriginalTargetIns ( SEC  sec,
INS  ins 
)

x

RTN LEVEL_CORE::SEC_FindRtnByIaddr ( SEC  sec,
IADDR  iaddr 
)

Find a particular routine by iaddr in the given section

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

Find a particular routine by name in the given section

BBL LEVEL_CORE::SEC_FindTargetBbl ( SEC  sec,
INS  ins 
)

x

VOID LEVEL_CORE::SEC_Free ( SEC  sec  ) 

x

VOID LEVEL_CORE::SEC_GarbageCollect (  ) 

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

INT32 LEVEL_CORE::SEC_GetIDataByOffsetUINT32 ( SEC  sec,
UINT64  offset 
)

get a piece of data directly from the incoming SEC data

UINT64 LEVEL_CORE::SEC_GetIDataByOffsetUINT64 ( SEC  sec,
UINT64  offset 
)

get a piece of data directly from the incoming SEC data

INT32 LEVEL_CORE::SEC_GetIDataINT32 ( SEC  sec,
IADDR  iaddr 
)

get a piece of data directly from the incoming SEC data

UINT64 LEVEL_CORE::SEC_GetIDataUINT64 ( SEC  sec,
IADDR  iaddr 
)

x

INT32 LEVEL_CORE::SEC_GetUnalignedIDataByOffsetINT32 ( SEC  sec,
UINT64  offset 
)

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

UINT64 LEVEL_CORE::SEC_GetUnalignedIDataByOffsetUINT64 ( SEC  sec,
USIZE  offset 
)

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

VOID LEVEL_CORE::SEC_IncNewSize ( SEC  sec,
USIZE  size 
)

x

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

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

VOID LEVEL_CORE::SEC_InitOriginalSec ( SEC  sec,
const string &  name,
UINT32  index,
IADDR  iaddr,
USIZE  offset,
USIZE  size,
const VOID *  data,
UINT32  alignment,
BOOL  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.

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

ADDRDELTA LEVEL_CORE::SignedOffset ( ADDRINT  imm  ) 

return imm as a signed offset

BBL LEVEL_CORE::SimulateRetPopToMem ( INS  ret,
ADDRINT  offset 
)

Simulate a return for the passed call instruction

BBL LEVEL_CORE::SimulateRetPush ( INS  call  ) 

Simulate a return for the passed call instruction

LOCALFUN string LEVEL_CORE::StrXedEnc ( const xed_encoder_request_t *  r  ) 

Returns:
a string for the encode request

SYM LEVEL_CORE::SYM_Alloc (  ) 

Allocate a SYM

VOID LEVEL_CORE::SYM_Check ( SYM  sym  ) 

x

VOID LEVEL_CORE::SYM_Free ( SYM  sym  ) 

Deallocate a SYM

VOID LEVEL_CORE::SYM_GarbageCollect (  ) 

SYM garbage collector

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

Init SYM (does not have to be original)

VOID LEVEL_CORE::SYM_SetSize ( SYM  sym,
UINT32  size 
)

Set the size of an SYM

string LEVEL_CORE::SYM_StringShort ( SYM  sym  ) 

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

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

The root for all SYM stripes

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

The base stripe for SYM

USIZE LEVEL_CORE::ThreadAwareInsEncoder ( INS  ins,
ADDRINT  address 
)

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

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

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

BOOL LEVEL_CORE::UseSahfLahfSequence (  ) 

Returns:
if the lahf/sahf sequence should be used

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

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

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

generate new outigoing address/value for val

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

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

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

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

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

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

decode with 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  ) 

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

VOID LEVEL_CORE::XED_init (  ) 

Returns:
Nothing

BOOL LEVEL_CORE::XED_INS_IsMultimedia ( INS  ins  ) 

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

VOID LEVEL_CORE::XED_log_init (  ) 

Returns:
Nothing

VOID LEVEL_CORE::XED_logger ( INS  ins,
char *  msg 
)

This function allows writing to the xed log from other source files.

Returns:
nothing

REG LEVEL_CORE::xed_map_to_pin_reg ( xed_reg_enum_t  xed_reg  ) 

Returns:
a valid pin register or REG_INVALID().

FLAGS LEVEL_CORE::XED_PhyFlagsRead ( const xed_decoded_inst_t *  xedd  ) 

Return the physical flags (DF, OF, SF, ZF, AF, PF, CF) that are read according to the xed decode info.

Parameters:
[in] xedd The xed decode info
Returns:
the FLAGS read according to 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

Parameters:
[in] xedd The xed decode info
[in] onlyDefinite Specify TRUE if only the flags that are definitely written should be returned
Returns:
the FLAGS written according to the xed decode info, and the onlyDefinite specification

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

x

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

x

VOID LEVEL_CORE::XED_reencode_decode_update_stripe ( INS  ins  ) 

Reencode modified (previously-decoded) instruction with XED. Then decode with XED. Then update the stripe.

REG LEVEL_CORE::xed_reg_to_pin_reg ( xed_reg_enum_t  xedreg,
INS  ins 
)

Returns:
the PIN register name for a given XED register name

VOID LEVEL_CORE::XED_RegRolePosFromXED ( INS  ins  ) 

Returns:
nothing
Fill in the reg/role/pos arrays in the stripe using information from the XED decoded instruction.

VOID LEVEL_CORE::XED_RegRolePosToXED ( INS  ins  ) 

Returns:
nothing
Take the reg/role/pos arrays from the stripe and pack them back in to XED decoded instruction.

LOCALFUN EXCEPTION_CODE LEVEL_CORE::XedError2ExceptionCode ( xed_error_enum_t  xed_error  ) 

Convert the specified XED error code into the corresponding EXCEPTION_CODE value.

Note:
the XED_ERROR_BUFFER_TOO_SHORT error is converted into EXCEPTCODE_ACCESS_FAULT.


Variable Documentation

GLOBALCONST BOOL LEVEL_CORE::B_CROSSLINK = 1

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

GLOBALCONST BOOL LEVEL_CORE::B_HIDDEN = 1

a hidden attribute will be omitted from printing

LOCALCONST xed_state_t LEVEL_CORE::DSTATE

Initial value:




    { XED_MACHINE_MODE_LEGACY_32, XED_ADDRESS_WIDTH_32b}

LOCALVAR const xed_reg_enum_t LEVEL_CORE::dummy_regs_native_table[MAX_DUMMY_REGS]

Initial value:

{



    XED_REG_EDX, XED_REG_EBX, XED_REG_ECX

}

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

Initial value:

{





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

}

GLOBALCONST USIZE LEVEL_CORE::INS_PATCH_UNIT = 8

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

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.

const REGSET_CONTEXT LEVEL_CORE::REGSET_CONTEXT_NONE

const REGSET LEVEL_CORE::REGSET_NONE

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
}


Generated on Wed Jan 21 02:19:21 2015 for Pin by  doxygen 1.5.1-p1