LEVEL_CORE Namespace Reference

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

---

Detailed Description

This file contains APP primitives

---

Typedef Documentation

typedef EXT* LEVEL_CORE::EXTLIST

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

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

A regset type that contains all registers

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

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

Note:

The INS_BYTES_FETCHER type is an example of a generic type <T> that provides the following function-call operator: size_t T::operator() (VOID *buf, const VOID *insAddr, size_t size, EXCEPTION_INFO *pExceptInfo) const; We will use the term "INS_BYTES_FETCHER functor" to denote types that provide this operator.

Parameters:

[out]	buf	A buffer which receives the instruction bytes. This buffer is at least size bytes long.
[in]	insAddr	Address of the first instruction's byte to be read.
[in]	size	The number of bytes to be read
[out]	pExceptInfo	If less than size bytes are fetched, pExceptInfo receives an exception that describes why more bytes could not be fetched. If Pin needs more bytes to decode the next instruction, this exception will be delivered to the application.

Returns:

The number of bytes successfully fetched into the buffer.

typedef ADDRINT LEVEL_CORE::INS_REUSER_HANDLE

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

typedef vector<ADDRINT> LEVEL_CORE::INS_REUSER_ID_VEC

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

typedef ADDRINT LEVEL_CORE::INS_REUSER_STORE_HANDLE

opaque type

typedef class INDEX< 202 > LEVEL_CORE::PREG

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

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

A regset type that contains registers in the physical context

typedef class ADDR< 200 > LEVEL_CORE::REGVALUE

Type that represents a value of an ADDRINT-size register

---

Enumeration Type Documentation

enum LEVEL_CORE::BBL_STATE

bbl state enumeration - not used

enum LEVEL_CORE::BBL_TYPE

BBL types enumeration

Enumerator:

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

enum LEVEL_CORE::CALLING_STANDARD

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

enum LEVEL_CORE::CHUNK_STATE

CHUNK state, to be used for consitency checking

enum LEVEL_CORE::CHUNK_TYPE

CHUNK types

enum LEVEL_CORE::EDG_STATE

EDG state enumeration - not used

enum LEVEL_CORE::EDG_TYPE

EDG type enumeration

Enumerator:

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

enum LEVEL_CORE::EXT_ATTR_MODE

EXT attribute mode

Enumerator:

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

enum LEVEL_CORE::FLAGS

Enumeration type for individual flags

enum LEVEL_CORE::FUNCTION_TYPE

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

enum LEVEL_CORE::IMG_STATE

not used

enum LEVEL_CORE::INS_REUSER_TYPE

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

enum LEVEL_CORE::REL_TYPE

Relocation types

Enumerator:

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

enum LEVEL_CORE::RTN_STATE

not used

enum LEVEL_CORE::RTN_TYPE

RTN type

enum LEVEL_CORE::SACT_TYPE

x

Enumerator:

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

enum LEVEL_CORE::SEC_STATE

SEC state, used for consitency checking

enum LEVEL_CORE::SEGMENT_TYPE

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

Enumerator:

SEGMENT_TYPE_TEXT	text segment
SEGMENT_TYPE_DATA	initialized data segment
SEGMENT_TYPE_BSS	uninitialized data segment

enum LEVEL_CORE::SYM_IFUNC_TYPE

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

enum LEVEL_CORE::SYM_STATE

used for consistency checking

enum LEVEL_CORE::SYSCALL_TYPE

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

Enumerator:

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

enum LEVEL_CORE::VAL_TYPE

VAL types

---

Function Documentation

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

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

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

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

APP LEVEL_CORE::APP_Alloc

(

)

Allocate new APP, some initialization

BOOL LEVEL_CORE::APP_allocated

(

APP

x

)

APP object is allocated

VOID LEVEL_CORE::APP_Free

(

APP

app

)

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

VOID LEVEL_CORE::APP_GarbageCollect

(

)

APP garbage collector, currently not used

APP LEVEL_CORE::APP_INVALID

(

)

returns an invalid APP object

INT32 LEVEL_CORE::APP_no

(

APP

x

)

return unique number of APP object

BOOL LEVEL_CORE::APP_valid

(

APP

x

)

test validity of APP object

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

The root for all APP stripes

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

The base stripe for APP

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

attribute to hold dynamic SYMs that have this BBL as value

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

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

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

attribute to hold RELs that have this BBL as value

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

attribute to hold dynamic SYMs that have this BBL as value

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

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

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

attribute to hold RELs that have this CHUNKS as value

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

x

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

attribute to hold RELs that have this INS as value

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

Attribute for attaching comments to data structures

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

Add a link edge to a call BBL

BBL LEVEL_CORE::BBL_Alloc

(

)

Allocate new BBL, some initialization

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

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

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

Append a BBL to RTN

UINT32 LEVEL_CORE::BBL_ByteSize

(

BBL

bbl

)

size of a bbl in bytes

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

Check whether BBL can be routine entry point

VOID LEVEL_CORE::BBL_Check

(

BBL

bbl

)

check consistency

VOID LEVEL_CORE::BBL_CheckFree

(

)

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

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

verify that successor EDG is compatible with originating BBL type

BBL LEVEL_CORE::BBL_Clone

(

BBL

bbl

)

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

BOOL LEVEL_CORE::BBL_ContainsCall

(

BBL

bbl

)

Check whether BBL is call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsConditionalCall

(

BBL

bbl

)

Check whether BBL is conditional call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsConditionalControlTransfer

(

BBL

bbl

)

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

BOOL LEVEL_CORE::BBL_ContainsDirectCall

(

BBL

bbl

)

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

BOOL LEVEL_CORE::BBL_ContainsDirectControlTransfer

(

BBL

bbl

)

BOOL LEVEL_CORE::BBL_ContainsIndirectCall

(

BBL

bbl

)

Check whether BBL is indirect call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsIndirectControlTransfer

(

BBL

bbl

)

BOOL LEVEL_CORE::BBL_ContainsReturn

(

BBL

bbl

)

Check whether BBL is a return (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsUnconditionalCall

(

BBL

bbl

)

Check whether BBL is unconditional call (based on BBL_TYPE)

BOOL LEVEL_CORE::BBL_ContainsUnresolvedIndirectJump

(

BBL

bbl

)

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

CHUNK LEVEL_CORE::BBL_DataChunk

(

BBL

bbl

)

return data CHUNK associated with a data BBL

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

cross link a data bbl with a data chunck

VOID LEVEL_CORE::BBL_DataUnlinkChunk

(

BBL

bbl

)

unlink a data bbl and the corresponding data chunk

VOID LEVEL_CORE::BBL_DeleteIns

(

BBL

bbl

)

delete all the instructions in a basic block

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

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

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

VOID LEVEL_CORE::BBL_Free

(

BBL

bbl

)

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

VOID LEVEL_CORE::BBL_FreeContents

(

BBL

bbl

)

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

VOID LEVEL_CORE::BBL_FreePredEdges

(

BBL

bbl

)

Free the predecessor edges of the bbl

VOID LEVEL_CORE::BBL_FreeSuccEdges

(

BBL

bbl

)

Free the successor edges of the bbl

VOID LEVEL_CORE::BBL_GarbageCollect

(

)

BBL garbage collector, currently not used

string LEVEL_CORE::BBL_generateDotCFG

(

BBL

bbl

)

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

Parameters:

[in]

bbl

- Root of the CFG tree.

Returns:

Return a string which is a dot representation of the CFG.

OADDR LEVEL_CORE::BBL_GetOaddr

(

BBL

target

)

get BBL OADDR (based on pos stripe)

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

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

BOOL LEVEL_CORE::BBL_HasUnmodeledSuccEdges

(

BBL

bbl

)

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

VOID LEVEL_CORE::BBL_InitOriginal

(

BBL

bbl

)

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

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

Insert BBL after another BBL within an RTN

Parameters:

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

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

Insert BBL before another BBL within an RTN

BOOL LEVEL_CORE::BBL_IsCycle

(

BBL

bbl

)

Test whether a bbl is part of a single BBL loop

BOOL LEVEL_CORE::BBL_IsImageEntryPoint

(

BBL

bbl

)

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

BOOL LEVEL_CORE::BBL_IsReturnSite

(

BBL

bbl

)

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

BOOL LEVEL_CORE::BBL_MarkBblStarts

(

BBL

containerBbl

)

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

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

Move all inss from src to dst following "after"

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

Move all inss from src to dst preceeding "before"

UINT32 LEVEL_CORE::BBL_NumAttrCrosslink

(

BBL

bbl

)

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

LOCALFUN UINT32 LEVEL_CORE::BBL_NumAttrRegsym

(

BBL

bbl

)

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

UINT32 LEVEL_CORE::BBL_NumExt

(

BBL

parent

)

x

UINT32 LEVEL_CORE::BBL_NumPreds

(

BBL

bbl

)

number of predecessor EDGs

UINT32 LEVEL_CORE::BBL_NumPredsInterproc

(

BBL

bbl

)

number of predecessor EDGs which originate from a different RTN

UINT32 LEVEL_CORE::BBL_NumPredsInterprocNonCall

(

BBL

bbl

)

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

UINT32 LEVEL_CORE::BBL_NumSuccs

(

BBL

bbl

)

number of successor EDGs

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

find successor EDG based on type

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

Prepend a BBL to RTN

VOID LEVEL_CORE::BBL_RemoveRegsyms

(

BBL

bbl

)

Remove crosslinked SYM from BBL

VOID LEVEL_CORE::BBL_SetImageEntryPoint

(

BBL

bbl

)

add special marked identifying BBL as the entry point

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

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

Parameters:

[in]	firstBbl	- BBL to split
[in]	splitIns	- Move this INS and all that follow into new bbl

Returns:

Return the new BBL

string LEVEL_CORE::BBL_StringLong

(

BBL

bbl

)

convert a BBL into a printable string - long version

string LEVEL_CORE::BBL_StringLongFancy

(

BBL

bbl

)

produce string for BBL including INS

string LEVEL_CORE::BBL_StringShort

(

BBL_TYPE

type

)

convert a BBL type into a printable string - 4 characters

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

find successor EDG based on traget BBL

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

find successor EDG based on type

EDG LEVEL_CORE::BBL_SuccEdgFindPcRelative

(

BBL

bbl

)

find successor EDG based on traget BBL

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

find successor EDG based on traget BBL

BBL_TYPE LEVEL_CORE::BBL_TYPE_Unconditionalize

(

BBL_TYPE

type

)

transform a conditional BBL_TYPE in the corresponding unconditional type

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

change BBL type with extra sanity checks

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

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

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

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

BBL LEVEL_CORE::BBL_UniquePredecessor

(

BBL

bbl

)

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

VOID LEVEL_CORE::BBL_Unlink

(

BBL

bbl

)

Unlink a BBL from an RTN

VOID LEVEL_CORE::BBL_UnlinkFreeCode

(

BBL

bbl

)

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

VOID LEVEL_CORE::BBL_UnlinkFreeData

(

BBL

bbl

)

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

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

The root for all BBL stripes

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

The base stripe for BBL

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

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

UINT32 LEVEL_CORE::CallingStd_DefaultArgSize

(

CALLING_STANDARD

cstype

)

Return a string for the calling standard.

string LEVEL_CORE::CallingStd_String

(

CALLING_STANDARD

cstype

)

Return a string for the calling standard.

VOID LEVEL_CORE::CheckAll

(

)

perform sanity checks on all basic charm objects ever allocated

BOOL LEVEL_CORE::CheckFree

(

)

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

CHUNK LEVEL_CORE::CHUNK_Alloc

(

)

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

VOID LEVEL_CORE::CHUNK_Append	(	CHUNK	chunk,
		SEC	parent
	)

append a CHUNK to SEC

USIZE LEVEL_CORE::CHUNK_AppendData	(	CHUNK	chunk,
		USIZE	num_bytes
	)

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

VOID LEVEL_CORE::CHUNK_ApplyRels

(

CHUNK

chunk

)

x

VOID LEVEL_CORE::CHUNK_Check

(

CHUNK

chunk

)

perform sanity checking for given CHUNK

BOOL LEVEL_CORE::CHUNK_ContainsIaddr	(	CHUNK	chunk,
		IADDR	iaddr
	)

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

BOOL LEVEL_CORE::CHUNK_ContainsIaddrEndInclusive	(	CHUNK	chunk,
		IADDR	iaddr
	)

get a piece of data directly from the incoming CHUNK data

BOOL LEVEL_CORE::CHUNK_ContainsOaddr	(	CHUNK	chunk,
		OADDR	oaddr
	)

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

BOOL LEVEL_CORE::CHUNK_ContainsOaddrEndInclusive	(	CHUNK	chunk,
		OADDR	oaddr
	)

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

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

VOID LEVEL_CORE::CHUNK_ExtPrepend	(	EXT	ext,
		CHUNK	parent
	)

REL LEVEL_CORE::CHUNK_FindRelForOffset	(	CHUNK	chunk,
		UINT32	offset
	)

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

VOID LEVEL_CORE::CHUNK_Free

(

CHUNK

chunk

)

Free chunk object

VOID LEVEL_CORE::CHUNK_GarbageCollect

(

)

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

UINT32 LEVEL_CORE::CHUNK_GetIDataByOffsetUINT32	(	CHUNK	chunk,
		USIZE	offset
	)

get a piece of data directly from the incoming CHUNK data

UINT64 LEVEL_CORE::CHUNK_GetIDataByOffsetUINT64	(	CHUNK	chunk,
		USIZE	offset
	)

get a piece of data directly from the incoming CHUNK data

UINT32 LEVEL_CORE::CHUNK_GetUnalignedIDataByOffsetUINT32	(	CHUNK	chunk,
		USIZE	offset
	)

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

UINT32 LEVEL_CORE::CHUNK_GetUnalignedIDataByOffsetUINT64	(	CHUNK	chunk,
		USIZE	offset
	)

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

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

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

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

insert CHUNK after another chunk within an SEC

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

insert CHUNK before another chunk within an SEC

UINT32 LEVEL_CORE::CHUNK_NumExt

(

CHUNK

parent

)

x

VOID LEVEL_CORE::CHUNK_Prepend	(	CHUNK	chunk,
		SEC	parent
	)

prepend a CHUNK to SEC

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

write a piece of data directly do the outgoing CHUNK data

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

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

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

write a piece of data directly to the outgoing CHUNK data

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

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

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

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

VOID LEVEL_CORE::CHUNK_RemoveRegsyms

(

CHUNK

chunk

)

Remove crosslinked SYM from CHUNK

VOID LEVEL_CORE::CHUNK_SetNewData	(	CHUNK	chunk,
		VOID *	data
	)

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

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

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

VOID LEVEL_CORE::CHUNK_SplitData	(	CHUNK	chunk,
		UINT32	offset
	)

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

string LEVEL_CORE::CHUNK_StringLong

(

CHUNK

chunk

)

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

string LEVEL_CORE::CHUNK_StringShort

(

CHUNK

chunk

)

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

VOID LEVEL_CORE::CHUNK_Unlink

(

CHUNK

chunk

)

unlink a CHUNK from an IMG

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

The root for all CHUNK stripes

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

The base stripe for CHUNK

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

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

Parameters:

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

VOID* LEVEL_CORE::CopyImageLoaderInfo

(

VOID *

arg

)

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

BOOL LEVEL_CORE::DoFlagsSplit

(

)

Returns:

if the flags splitting should be done

VOID LEVEL_CORE::DYNSYM_Unlink

(

SYM

sym

)

unlink a SYM from an IMG

EDG LEVEL_CORE::EDG_Alloc

(

)

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

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

allocate and link an EDG to the two specified BBLS

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

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

VOID LEVEL_CORE::EDG_Free

(

EDG

edg

)

deallocate unlinked EDG

VOID LEVEL_CORE::EDG_GarbageCollect

(

)

EDG garbage colletor

BOOL LEVEL_CORE::EDG_InterProcedural

(

EDG

e

)

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

BOOL LEVEL_CORE::EDG_IsFallthrough

(

EDG

edg

)

Determing whether an EDG is a fallthru EDG using the type

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

link an EDG to the two specified BBLS

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

Move the predecessor edges from bbl_from to bbl_to

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

Move the successor edges from a to b

UINT32 LEVEL_CORE::EDG_NumExt

(

EDG

parent

)

x

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

Insert predecessor EDG after another such EDG

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

Prepend predecessor EDG to list of predecessor EDGs

string LEVEL_CORE::EDG_StringShort

(

EDG

edg

)

convert a EDG into a printable string - short version

string LEVEL_CORE::EDG_StringShort

(

EDG_TYPE

type

)

convert a EDG type into a printable string

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

Insert successor EDG after another such EDG

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

Prepend successor EDG to list of predecessor EDGs

VOID LEVEL_CORE::EDG_Unlink

(

EDG

edg

)

Unlink EDG

LOCALFUN VOID LEVEL_CORE::EDG_UnlinkPred

(

EDG

edg

)

Unlink EDG from Dst only

VOID LEVEL_CORE::EDG_UnlinkSucc

(

EDG

edg

)

Unlink EDG from Src only

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

The root for all EDG stripes

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

The base stripe for REL

EXT LEVEL_CORE::EXT_Alloc

(

)

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

Link register allocation hint to basic block

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

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

Returns:

Returns the new EXT

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

Link register allocation hint to instruction

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

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

VOID LEVEL_CORE::EXT_Check

(

EXT

ext

)

x

VOID LEVEL_CORE::EXT_CheckFree

(

)

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

VOID LEVEL_CORE::EXT_ChunkUnlink	(	EXT	ext,
		CHUNK	parent
	)

EXT LEVEL_CORE::EXT_Clone

(

EXT

ext

)

x

VOID LEVEL_CORE::EXT_Copy	(	EXT	ext,
		EXT	clone
	)

x

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

VOID LEVEL_CORE::EXT_ExtlistUnlink	(	EXT	ext,
		EXTLIST	parent
	)

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

x

EXT LEVEL_CORE::EXT_FindNext

(

EXT

ext

)

x

VOID LEVEL_CORE::EXT_Free

(

EXT

ext

)

x

VOID LEVEL_CORE::EXT_GarbageCollect

(

)

x

VOID LEVEL_CORE::EXT_InsUnlink	(	EXT	ext,
		INS	parent
	)

string LEVEL_CORE::EXT_ListString

(

EXT

ext

)

x

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

string LEVEL_CORE::EXT_StringShort	(	EXT	ext,
		BOOL	tiny
	)

x

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

x

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

Insert ext after 'after'

VOID LEVEL_CORE::EXTLIST_ExtPrepend	(	EXT	ext,
		EXTLIST &	parent
	)

Prepend an EXT to EXTLIST

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

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

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

x

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

Return the bitwise and of two flags

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

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

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

Return the bitwise or of two flags

string LEVEL_CORE::FLAGS_StringShort

(

const FLAGS

x

)

produce a string for flags

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

Return the flags that are in x but not in y

VOID LEVEL_CORE::FreeImageLoaderInfo

(

VOID *

arg

)

Free image loader info used for PINADX debugger

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_base_reg	(	UINT	i,
		REGWIDTH	reg_width
	)

x

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_index_reg	(	UINT	i,
		REGWIDTH	reg_width
	)

x

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_reg	(	UINT	i,
		REGWIDTH	reg_width
	)

x

LOCALINLINE xed_reg_enum_t LEVEL_CORE::get_dummy_reg_native

(

UINT

i

)

x

PINVM::PINSYNC_RWLOCK* LEVEL_CORE::GetINSResizeLock

(

)

Returns the readers-writer lock of the INS stripe.

LOCALFUN UINT8 LEVEL_CORE::GetLegalByteWidthsBitmapForEaWidth

(

INT32

ea_width

)

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

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

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

Parameters:

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

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

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

Parameters:

[in]	ith_arg	argument number (0 - first argument).
[out]	pExp	pointer to variable that receives expression for calculating memory address of the argument.
[in]	std	syscall standard.

Returns:

TRUE - success, FALSE - argument is not located in memory

BOOL LEVEL_CORE::HasSpecialOffsetForGotPcAccess

(

RTN

rtn

)

x

IMG LEVEL_CORE::IMG_Alloc

(

)

x

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

x

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

x

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

x

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

x

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

x

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

Append an IMG to APP

VOID LEVEL_CORE::IMG_Check

(

IMG

img

)

x

VOID LEVEL_CORE::IMG_ChunkifySecs

(

IMG

img

)

subdivide SECs into chunks

VOID LEVEL_CORE::IMG_ComputeNewSecDataExec

(

IMG

img

)

x

VOID LEVEL_CORE::IMG_ComputeNewSecDataUncooked

(

IMG

img

)

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

VOID LEVEL_CORE::IMG_ComputeNewSecSizeExecAndAddressMapping

(

IMG

img

)

Iterate over executable section and compute the addresses for the instructions

VOID LEVEL_CORE::IMG_ComputeNewSecSizeUncooked

(

IMG

img

)

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

VOID LEVEL_CORE::IMG_ConvertWeirdBranches

(

IMG

img

)

x

VOID LEVEL_CORE::IMG_CookExecutableSections

(

IMG

img

)

x

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

x

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

Find regular symbol by name

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

x

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

x

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

x

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

x

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

x

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

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

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

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

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

x

VOID LEVEL_CORE::IMG_Free

(

IMG

img

)

x

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

x

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

Insert IMG after another IMG within an APP

Parameters:

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

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

Insert IMG before another IMG within an APP

Parameters:

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

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

Check if address is within image addresses

Parameters:

addr

address to check.

BOOL LEVEL_CORE::IMG_IsMainImage

(

IMG

img

)

Check if img is a main image

VOID LEVEL_CORE::IMG_LinkDynsymWithTarget

(

IMG

img

)

Crosslink dynamic SYMs with the objects they're describing

VOID LEVEL_CORE::IMG_LinkRegsymWithTarget

(

IMG

img

)

Crosslink regular SYMs with the objects they're describing

void LEVEL_CORE::IMG_load_offset_propagate	(	IMG	img,
		void *	loaderInfo
	)

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

VOID LEVEL_CORE::IMG_MarkPcRelativeControlFlow

(

IMG

img

)

mark targets of pc relative branches as BBL and RTN beginning

UINT32 LEVEL_CORE::IMG_NumDynsym

(

IMG

img

)

Return the number of dynamic symbols in the image

UINT32 LEVEL_CORE::IMG_NumRegsym

(

IMG

img

)

Return the number of regulsr symbols in the image

UINT32 LEVEL_CORE::IMG_NumSec

(

IMG

img

)

Return the number of SECs in an IMG

string LEVEL_CORE::IMG_PrintRegSyms

(

IMG

img

)

Put all regular symbols in img

VOID LEVEL_CORE::IMG_RetypifyBbls

(

IMG

img

)

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

VOID LEVEL_CORE::IMG_SetNewChunkSizesAndAddresses

(

IMG

img

)

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

VOID LEVEL_CORE::IMG_SortSecsByVaddr

(

IMG

img

)

x

string LEVEL_CORE::IMG_StringLong

(

IMG

img

)

produce string for IMG

VOID LEVEL_CORE::IMG_TypifyBblsAndCreateEdgs

(

IMG

img

)

determing BBL type based on last INS and create sucessor EDGs

VOID LEVEL_CORE::IMG_Unlink

(

IMG

img

)

Unlink an IMG from the APP

VOID LEVEL_CORE::IMG_VerifyFallthroughs

(

IMG

img

)

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

ARRAYBASE LEVEL_CORE::ImgArrayBase	(	"img pool"	,
		1024
	)

x

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

x

VOID LEVEL_CORE::InitializeINSSupplementaryResizeLock

(

PINVM::ILOCK *

lock

)

Initialize the resize lock for the INS stripe

VOID LEVEL_CORE::InitializeStripes

(

)

Initialize the stripes

BOOL LEVEL_CORE::INS_AccessesManyFPRegisters

(

INS

ins

)

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

INS LEVEL_CORE::INS_Alloc

(

)

Allocate new INS, some initialization

INS LEVEL_CORE::INS_AllocLocked

(

)

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

Note:

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

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

x

VOID LEVEL_CORE::INS_AttachComment	(	const INS	ins,
		string	comment
	)

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

Parameters:

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

BBL LEVEL_CORE::INS_bbl

(

INS

x

)

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

UINT32 LEVEL_CORE::INS_BranchDisplacementWidthBits

(

INS

ins

)

Return width of branch offset in BITS

UINT32 LEVEL_CORE::INS_BranchDisplacementWidthBytes

(

INS

ins

)

Return width of branch offset in BYTES.

REG LEVEL_CORE::INS_CallOrBranchGetIndirectRegister

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_CallOrBranchIsMemoryIndirect

(

INS

ins

)

Returns:

true if this branch or call indirect through memory

BOOL LEVEL_CORE::INS_CallOrBranchIsRegisterIndirect

(

INS

ins

)

Returns:

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

IADDR LEVEL_CORE::INS_CallRetIaddr

(

INS

ins

)

x

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

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

Parameters:

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

BOOL LEVEL_CORE::INS_ChangeStackPtr

(

INS

ins

)

Change stack pointers:

REG_STACK_PTR -> REG_PIN_STACK_PTR REG_PIN_BRIDGE_ORIG_SP -> REG_STACK_PTR

Returns:

Returns true if at least one register was changed

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

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

BOOL LEVEL_CORE::INS_ChangeToUsePinFlags

(

const INS

ins

)

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

VOID LEVEL_CORE::INS_Check

(

INS

ins

)

x

VOID LEVEL_CORE::INS_CheckFree

(

)

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

VOID LEVEL_CORE::INS_ClearDirtyG

(

INS

ins

)

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

string LEVEL_CORE::INS_Comment

(

INS

ins

)

Get the comment string from an instruction.

Parameters:

[in]

ins

INS whose comment string is wanted.

VOID LEVEL_CORE::INS_ConvertCallToBranch

(

INS

ins

)

Convert a call instruction to a branch

INS LEVEL_CORE::INS_ConvertLoadToMoveHack

(

INS

jmp

)

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

VOID LEVEL_CORE::INS_ConvertToIndirectJumpHack

(

INS

ins

)

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

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

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

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

Copy everything to the clone.

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

Copy any comment on fromIns to toIns.

Parameters:

	in/out]	toIns
[in]	fromIns

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

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

Parameters:

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

REG LEVEL_CORE::INS_CountRegister

(

INS

ins

)

Returns:

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

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

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

IADDR LEVEL_CORE::INS_DirectBranchOrCallTargetIaddr

(

INS

ins

)

Compute the target of an ip relative jmp

IADDR LEVEL_CORE::INS_DirectBranchOrCallTargetIaddr	(	INS	ins,
		IADDR	iaddr
	)

Compute the target of an ip relative jmp

OADDR LEVEL_CORE::INS_DirectBranchOrCallTargetOaddr	(	INS	ins,
		OADDR	oaddr
	)

Compute the target of an ip relative jmp

BOOL LEVEL_CORE::INS_DirtyG

(

INS

ins

)

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

VOID LEVEL_CORE::INS_DisableSegmentPrefix

(

INS

ins

)

INS_DisableSegmentPrefix() - remove segment prefix

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

Embed an immediate value into the code as an INS

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

Encode an instruction at a given address

UINT8* LEVEL_CORE::INS_EncodeBufferG

(

INS

ins

)

Make the INS_EncodeBuffer available for external use

UINT32 LEVEL_CORE::INS_EncodeIns	(	INS	ins,
		VOID *	buffer
	)

Returns:

size of instruction

UINT32 LEVEL_CORE::INS_EncodeSizeG

(

INS

ins

)

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

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

Make the INS_EncodeSizeSet available for external use

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

x

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

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

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

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

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

x

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

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

VOID LEVEL_CORE::INS_ExtPrepend	(	EXT	ext,
		INS	parent
	)

VOID LEVEL_CORE::INS_ExtTransfer	(	INS	src,
		INS	dst
	)

template<typename FETCHER_>

GLOBALTEMPLATEFUN BOOL LEVEL_CORE::INS_Fetch	(	INS	ins,
		const VOID **	address,
		const FETCHER_ &	insBytesFetcher,
		UINT32	maxSize,
		EXCEPTION_INFO *	pExceptInfo = 0
	)

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

Parameters:

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

Returns:

TRUE for success, FALSE for failure.

VOID LEVEL_CORE::INS_Free

(

INS

ins

)

Free INS

VOID LEVEL_CORE::INS_FreeLocked

(

INS

ins

)

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

VOID LEVEL_CORE::INS_FreeRel

(

INS

ins

)

Free INS and possibly attached reloc

VOID LEVEL_CORE::INS_GarbageCollect

(

)

INS garbage collector, currently not used

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

x

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

x

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

x

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

x

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

Create a "nop" instruction witha requested size

UINT8 LEVEL_CORE::INS_get_num_reads

(

INS

x

)

Returns:

Returns the number of registers read by this instruction

UINT8 LEVEL_CORE::INS_get_num_writes

(

INS

x

)

Returns:

Returns the number of registers written by this instruction

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

Returns:

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

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

Returns:

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

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

Returns:

Returns the ith read register

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

Returns:

Returns the ith written register

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

x

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

Returns:

Returns role of ith written register

REG LEVEL_CORE::INS_GetBaseReg

(

INS

ins

)

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

REG LEVEL_CORE::INS_GetBaseRegOne

(

INS

ins

)

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

ADDRDELTA LEVEL_CORE::INS_GetBranchDisplacement

(

INS

ins

)

Note:

the displacement is a signed number.

REG LEVEL_CORE::INS_GetFirstAluSourceReg

(

INS

ins

)

x

ADDRINT LEVEL_CORE::INS_GetImmediate

(

INS

ins

)

x

REG LEVEL_CORE::INS_GetIndexReg

(

INS

ins

)

x

ADDRDELTA LEVEL_CORE::INS_GetMemoryDisplacement

(

INS

ins

)

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

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

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

Precondition:

The instruction size should not exceed INS_PATCH_UNIT bytes

Parameters:

[in]	addr	original address of the instruction This could be an absolute address of the instruction or it could be an offset relative to any INS_PATCH_UNIT-aligned address
[in]	size	size of the instruction

Returns:

new location for the instruction that needs to be safely patched

OADDR LEVEL_CORE::INS_GetOaddr

(

INS

ins

)

x

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

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

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

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

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

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

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

Returns:

the read register which fulfils the requested role.

UINT32 LEVEL_CORE::INS_GetScale

(

INS

ins

)

x

ADDRINT LEVEL_CORE::INS_GetSecondImmediate

(

INS

ins

)

x

ADDRDELTA LEVEL_CORE::INS_GetSignedImmediate

(

INS

ins

)

Note:

Return the immediate operand as a sign number.

BOOL LEVEL_CORE::INS_HasFixed8BitBranchDisplacement

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_HasImmediateOperand

(

INS

ins

)

x

BOOL LEVEL_CORE::INS_HasImplicitFullMask

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_HasImplicitMemoryReference

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_HasImplicitStackReference

(

INS

ins

)

Test if this instruction has an implicit stack reference.

BOOL LEVEL_CORE::INS_HasMemoryDisplacement

(

INS

ins

)

Return true if the operation really has a memory displacement.

BOOL LEVEL_CORE::INS_HasRepEqual

(

INS

ins

)

Returns:

true if this is a REPE

BOOL LEVEL_CORE::INS_HasSegmentRegPrefix

(

INS

ins

)

Just calls INS_SegmentPrefix()

UINT64 LEVEL_CORE::INS_Id

(

INS

ins

)

Returns:

Unique identifier of instruction

VOID LEVEL_CORE::INS_InitAAA

(

INS

ins

)

CPUID

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

x

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

x

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

x

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

x

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

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

Note:

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

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

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

x

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

x

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

x

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitBranch	(	INS	ins,
		BBL	target
	)

x

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitCallIndirectRegister	(	INS	ins,
		REG	target
	)

x

VOID LEVEL_CORE::INS_InitCld

(

INS

ins

)

x

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

Generate a CMOV for the given predicate.

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

x

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

x

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

x

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

x

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

x

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

x

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

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

Parameters:

[in]	ins	instruction to be initialized
[in]	brAddr	address of the branch
[in]	tgtAddr	target address of the branch

Precondition:

the signed distance between <tgtAddr> and <brAddr> should fit 32 bits.

Returns:

size of the jump instruction

VOID LEVEL_CORE::INS_InitEncodeDecoder

(

)

x

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

Make a far direct call

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

Make a far direct jump

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

Create far jumps and calls

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

x

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

x

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

Create an GPR32/ XMM operation

VOID LEVEL_CORE::INS_InitHalt

(

INS

ins

)

x

LOCALFUN void LEVEL_CORE::INS_Initialize

(

INS

ins

)

Initializate a newly allocated INS

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

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

VOID LEVEL_CORE::INS_InitInt	(	INS	ins,
		UINT8	imm
	)

x

VOID LEVEL_CORE::INS_InitInt3

(

INS

ins

)

x

VOID LEVEL_CORE::INS_InitIntx86	(	INS	ins,
		UINT64	num
	)

x

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

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

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

x

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

Indirect unconditional jump through memory

VOID LEVEL_CORE::INS_InitJmpR	(	INS	ins,
		REG	src
	)

x

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

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

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

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

VOID LEVEL_CORE::INS_InitLAHF

(

INS

ins

)

x

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

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

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

Create an lea that uses default address width

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

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

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

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

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

x

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

x

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

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

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

Generate a load memop.

Parameters:

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

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitLods

(

INS

ins

)

x

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

Operate with an immediate and a memory operand.

Parameters:

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

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

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

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

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

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

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

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

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

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

x

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

x

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

x

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

x

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

x

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

Create a MOVDQA reg/reg

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

Parameters:

[in]

denyImm32SignExtension

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

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

x

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

allow non-native reg_width

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

x

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

x

VOID LEVEL_CORE::INS_InitMovSW

(

INS

ins

)

x

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

x

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

x

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

x

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

Negate the value in the given register.

VOID LEVEL_CORE::INS_InitNop

(

INS

ins

)

Create a "nop" instruction.

LOCALFUN VOID LEVEL_CORE::INS_InitNoRegOp	(	INS	ins,
		xed_iclass_enum_t	iclass
	)

x

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

Bitwise not the value in the given register.

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

x

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

Decode an original instruction and initialize the specified INS object.

Parameters:

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

Returns:

TRUE for success, FALSE for failure.

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

x

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

Create a PAND reg/reg

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

Create a PCMPEQB reg, mem

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

Create a PCMPEQD reg, mem

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

Create a PMOVMSKB r32, xmm

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

x

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

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

Parameters:

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

VOID LEVEL_CORE::INS_InitPopAL

(

INS

ins

)

x

VOID LEVEL_CORE::INS_InitPopF

(

INS

ins

)

x

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

Create a POR reg, mem

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

x

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

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

Parameters:

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

VOID LEVEL_CORE::INS_InitPushAL

(

INS

ins

)

x

VOID LEVEL_CORE::INS_InitPushF

(

INS

ins

)

x

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

x

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

x

VOID LEVEL_CORE::INS_InitRdtsc

(

INS

ins

)

x

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

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

VOID LEVEL_CORE::INS_InitRepStos

(

INS

ins

)

x

VOID LEVEL_CORE::INS_InitRet

(

INS

ins

)

x

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

x

VOID LEVEL_CORE::INS_InitSAHF

(

INS

ins

)

x

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

Initialize CONTROL TRANSFERS with displacements.

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

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

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

x

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

x

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

x

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

Create a "nop" instruction witha requested size

VOID LEVEL_CORE::INS_InitStd

(

INS

ins

)

x

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

INS_InitStore with the default segment register

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

x

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

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

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

x

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitStos

(

INS

ins

)

x

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

x

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

x

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitUD2

(

INS

ins

)

x

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

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

Note:

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

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

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

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

Note:

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

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

x

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

x

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

x

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InitVZeroUpper

(

INS

ins

)

Create a VZEROUPPER instruction

VOID LEVEL_CORE::INS_InitXbegin

(

INS

ins

)

Generate the Xbegin.

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

Initialize an xchg instruction

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

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

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

Create an XMM reg/reg operation

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

x

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

x

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

x

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

x

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

x

VOID LEVEL_CORE::INS_InvertBr

(

INS

ins

)

x

IADDR LEVEL_CORE::INS_IpRelTargetIaddr

(

INS

ins

)

Compute the target of an ip-relative data address

BOOL LEVEL_CORE::INS_IsAdd

(

const INS

ins

)

returns true if this instruction is an add.

BOOL LEVEL_CORE::INS_IsAnyPopF

(

const INS

ins

)

Returns:

if ins is any type of popf

BOOL LEVEL_CORE::INS_IsAvx

(

INS

ins

)

Return TRUE iff the ins is an AVX instruction

BOOL LEVEL_CORE::INS_IsAvxOrXSave

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_IsBblTerminator

(

INS

ins

)

x

BOOL LEVEL_CORE::INS_IsBitTest

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_IsBsr

(

INS

ins

)

Return TRUE if the INS is a BSR instruction

BOOL LEVEL_CORE::INS_IsCJmp

(

INS

ins

)

Return TRUE if the INS is a Conditional branch instruction

BOOL LEVEL_CORE::INS_IsCmov

(

INS

ins

)

Return TRUE if the INS is an integer conditional move instruction

BOOL LEVEL_CORE::INS_IsCmps

(

INS

ins

)

Return TRUE if the INS is a CMPS

BOOL LEVEL_CORE::INS_IsCondWrite

(

INS

ins

)

Return TRUE if the INS is does a conditional write.

BOOL LEVEL_CORE::INS_IsCpuid

(

INS

ins

)

Returns:

true if the instruction is CPUID.

BOOL LEVEL_CORE::INS_IsDec

(

const INS

ins

)

returns true if this instruction is a decrement.

BOOL LEVEL_CORE::INS_IsEnter

(

INS

ins

)

Return TRUE if the INS is an ENTER instruction.

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

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

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

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

BOOL LEVEL_CORE::INS_IsFCmov

(

INS

ins

)

Return TRUE if the INS is a float conditional move instruction

BOOL LEVEL_CORE::INS_IsFloat

(

INS

ins

)

Return TRUE if the INS is an x87 floating point instruction

BOOL LEVEL_CORE::INS_IsFxrestore

(

INS

ins

)

Return TRUE if the INS is an fxrstor instruction

BOOL LEVEL_CORE::INS_IsFxsave

(

INS

ins

)

Return TRUE if the INS is an fxsave instruction

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

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

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

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

BOOL LEVEL_CORE::INS_IsInc

(

const INS

ins

)

returns true if this instruction is a increment.

BOOL LEVEL_CORE::INS_IsIOStringOp

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_IsIpRelAddr

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_IsJCXZ

(

INS

ins

)

Return TRUE if the INS is a JrCXZ instruction.

BOOL LEVEL_CORE::INS_IsJNZ

(

INS

ins

)

Return TRUE if the INS is a JNZ instruction.

BOOL LEVEL_CORE::INS_IsJZ

(

INS

ins

)

Return TRUE if the INS is a JZ instruction.

BOOL LEVEL_CORE::INS_IsLeave

(

INS

ins

)

Return TRUE if the INS is a LEAVE instruction

BOOL LEVEL_CORE::INS_IsLoop

(

INS

ins

)

Return TRUE if the INS is a LOOP instruction.

BOOL LEVEL_CORE::INS_IsLoope

(

INS

ins

)

Return TRUE if the INS is a LOOPE instruction.

BOOL LEVEL_CORE::INS_IsLoopne

(

INS

ins

)

Return TRUE if the INS is a LOOPNE instruction.

BOOL LEVEL_CORE::INS_IsLoopType

(

const INS

ins

)

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

BOOL LEVEL_CORE::INS_IsMmx

(

INS

ins

)

Return TRUE if the ins is an MMX instruction

BOOL LEVEL_CORE::INS_IsMMXorXMM

(

const INS

ins

)

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

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

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

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

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

Note:

Patching multi-byte instructions involves overwriting the first 2 bytes of the instruction with a short jump to itself. The 2-byte alignment guarantees atomicity of this operation.

Parameters:

[in]	addr	address of the instruction
[in]	size	size of the instruction

Returns:

TRUE, if the instruction can be safely patched

BOOL LEVEL_CORE::INS_IsPatchable

(

INS

ins

)

Return TRUE if the instruction is patchable

BOOL LEVEL_CORE::INS_IsPop

(

const INS

ins

)

returns true if this instruction is a pop.

BOOL LEVEL_CORE::INS_IsPopAll16

(

INS

ins

)

Returns:

TRUE if ins is a 16-bit popa instruction.

BOOL LEVEL_CORE::INS_IsPopAll32

(

INS

ins

)

Returns:

TRUE if ins is a 32-bit popa instruction.

BOOL LEVEL_CORE::INS_IsPopF

(

const INS

ins

)

Returns:

if ins is popf

BOOL LEVEL_CORE::INS_IsPopFD

(

const INS

ins

)

Returns:

if ins is popfd

BOOL LEVEL_CORE::INS_IsPopFQ

(

const INS

ins

)

Returns:

if ins is popfd

BOOL LEVEL_CORE::INS_IsPush

(

const INS

ins

)

returns true if this instruction is a push.

BOOL LEVEL_CORE::INS_IsPushAll16

(

INS

ins

)

Returns:

TRUE if ins is a 16-bit pusha instruction.

BOOL LEVEL_CORE::INS_IsPushAll32

(

INS

ins

)

Returns:

TRUE if ins is a 32-bit pusha instruction.

BOOL LEVEL_CORE::INS_IsScas

(

INS

ins

)

Return TRUE if the INS is a SCAS

BOOL LEVEL_CORE::INS_IsSetCC

(

INS

ins

)

Return TRUE if the INS is a setcc instruction

BOOL LEVEL_CORE::INS_IsShift

(

INS

ins

)

returns true if this instruction is a shift.

ADDRINT LEVEL_CORE::INS_IsSignedImmediate

(

INS

ins

)

x

REG LEVEL_CORE::INS_IsSimpleRegIndirectRead

(

INS

ins

)

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

Returns:

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

REG LEVEL_CORE::INS_IsSimpleRegIndirectWrite

(

INS

ins

)

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

Returns:

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

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

ins use simple stack indirect plus offset addressing mode

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

ins use simple stack indirect plus offset addressing mode

BOOL LEVEL_CORE::INS_IsSse

(

INS

ins

)

Return TRUE iff the ins is an SSE instruction

BOOL LEVEL_CORE::INS_IsStringOp

(

INS

ins

)

returns true if this instruction is a string op.

BOOL LEVEL_CORE::INS_IsUJmp

(

INS

ins

)

Return TRUE if the INS is a Unconditional branch instruction

BOOL LEVEL_CORE::INS_IsXlat

(

INS

ins

)

Returns:

true if the instruction is XLAT.

BOOL LEVEL_CORE::INS_IsXrestore

(

INS

ins

)

Return TRUE if the INS is an xrstor instruction

BOOL LEVEL_CORE::INS_IsXsave

(

INS

ins

)

Return TRUE if the INS is an xsave instruction

BOOL LEVEL_CORE::INS_IsXsavec

(

INS

ins

)

Return TRUE if the INS is an xsavec instruction

BOOL LEVEL_CORE::INS_IsXsaveFamily

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_IsXsaveopt

(

INS

ins

)

Return TRUE if the INS is an xsaveopt instruction

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

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

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

Rewrite memop to use base register address mode

VOID LEVEL_CORE::INS_MarkBblStart

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_MarkedForDeletion

(

INS

ins

)

Is this instruction marked for deletion?

VOID LEVEL_CORE::INS_MarkForDeletion

(

INS

ins

)

Mark this instruction for deletion,

VOID LEVEL_CORE::INS_MarkRtnStart

(

INS

ins

)

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

int LEVEL_CORE::INS_MaxDecodedBytes

(

)

return the maximum bytes that are accessed b decoding one instruction

USIZE LEVEL_CORE::INS_MaxProbeSize

(

BOOL

requestRipAndAddrProbe

)

Returns:

Maximum size in bytes of a probe

BOOL LEVEL_CORE::INS_MayWriteAllMMRegisters

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_MemopDisplacementOnly

(

INS

ins

)

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

ADDRINT LEVEL_CORE::INS_MemoryDisplacementWidthBytes

(

INS

ins

)

Return width of memory offset in BYTES

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

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

Precondition:

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

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

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

Parameters:

[in]	ins	instruction to be written in place of the original one
[in]	addr	address of the original instruction
[in]	size	size of the original instruction

Returns:

TRUE/FALSE - success/failure

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

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

Precondition:

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

Parameters:

[in]	brAddr	address of the branch
[in]	tgtAddr	new target address of the branch

Returns:

TRUE/FALSE - success/failure

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

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

Precondition:

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

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

Parameters:

[in]	insAddr	address of the original instruction
[in]	tgtAddr	target address of the branch

Returns:

TRUE/FALSE - success/failure

INS LEVEL_CORE::INS_next

(

INS

x

)

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

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

IADDR LEVEL_CORE::INS_NextInsIaddr

(

INS

ins

)

Compute the address of the next isntruction

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

x

UINT32 LEVEL_CORE::INS_NumAttrCrosslink

(

INS

ins

)

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

UINT32 LEVEL_CORE::INS_NumExt

(

INS

parent

)

x

BOOL LEVEL_CORE::INS_OperandIsGsOrFsReg

(

INS

ins

)

Returns:

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

UINT32 LEVEL_CORE::INS_orig_size

(

INS

x

)

Returns:

Returns original size of instruction in bytes

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

Sets original size of instruction in bytes

FLAGS LEVEL_CORE::INS_PhyFlagsMayWritten

(

const INS

ins

)

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

Parameters:

[in]

ins

The INS whose phys flags written are to be obtained

Returns:

the FLAGS the ins may or must write

FLAGS LEVEL_CORE::INS_PhyFlagsMustWritten

(

const INS

ins

)

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

Parameters:

[in]

ins

The INS whose phys flags written are to be obtained

Returns:

the FLAGS the ins definitely (must) writes

FLAGS LEVEL_CORE::INS_PhyFlagsRead

(

const INS

ins

)

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

Parameters:

[in]

ins

The INS whose phys flags read are to be obtained

Returns:

the FLAGS the ins reads

BOOL LEVEL_CORE::INS_PrefixIsGsOrFsReg

(

INS

ins

)

Returns:

TRUE if instruction prefix is GS or FS

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

x

INS LEVEL_CORE::INS_prev

(

INS

x

)

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

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

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

x

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

Returns:

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

LOCALFUN string LEVEL_CORE::INS_RawInstBytes

(

INS

ins

)

x

BOOL LEVEL_CORE::INS_ReadsAllMMRegisters

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_ReadsAllMmxRegisterss

(

INS

ins

)

Returns true if the ins writes all the mmx registers.

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

set kth read register of instruction x

BOOL LEVEL_CORE::INS_RegsReadBeforeWritten

(

INS

ins

)

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

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

set kth write register of instruction x

VOID LEVEL_CORE::INS_RemoveRep

(

INS

ins

)

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

Parameters:

[in]

ins

The instruction to change.

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

Rename application regs to their corresponding pin regs in ins.

FIXME: RM REWRITE TO USE THE REGR/REGW ARRAYS

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

INS_ReplaceMemop() - replace all components of memory operand

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

Pull out all the operands of a memory references

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

Sets the number of registers read by this instruction

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

Sets the number of registers written by this instruction

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

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

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

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

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

x

VOID LEVEL_CORE::INS_SetDirty

(

INS

ins

)

mark that the instruction encoding in the cache is not valid

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

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

Parameters:

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

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

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

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

x

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

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

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

rewrite a register operand to use the given register.

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

Append code to sign extend src to dst

USIZE LEVEL_CORE::INS_SizeOfDirectJmp

(

)

Returns:

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

USIZE LEVEL_CORE::INS_SizeOfIpRelativeMemJmp

(

)

Returns:

size of the unconditional, jmp [gip]offset

string LEVEL_CORE::INS_StringLong

(

INS

ins

)

x

string LEVEL_CORE::INS_StringShort

(

INS

ins

)

x

string LEVEL_CORE::INS_StringShorter

(

INS

ins

)

x

string LEVEL_CORE::INS_StringShortFancy

(

INS

ins

)

produce a string for INS extended by profile and exception information

string LEVEL_CORE::INS_StringXed

(

INS

ins

)

x

BOOL LEVEL_CORE::INS_SyscallHasFallThrough

(

INS

ins

)

Returns:

true if specified syscall instruction is modeled as a fallthrough instruction

BOOL LEVEL_CORE::INS_SyscallIsTakenBranch

(

INS

ins

)

Returns:

true if specified syscall instruction is modeled as a taken branch

LOCALFUN SYSCALL_TYPE LEVEL_CORE::INS_SyscallType

(

INS

ins

)

Returns:

the syscall type

PREDICATE_IA32 LEVEL_CORE::INS_TestedCondition

(

INS

ins

)

Returns:

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

VOID LEVEL_CORE::INS_Unlink

(

INS

ins

)

Unlink INS from BBL

BOOL LEVEL_CORE::INS_ValidateEncoding

(

const INS

ins

)

Validate the encoding of ins.

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

Generate a Vinsertf128 from memory.

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

Generate a Vinsertf32x4 from memory.

BOOL LEVEL_CORE::INS_WritesAllMMRegisters

(

INS

ins

)

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

BOOL LEVEL_CORE::INS_WritesAllMmxRegisters

(

INS

ins

)

Returns true if the ins writes all the mmx registers.

xed_decoded_inst_t* LEVEL_CORE::INS_xed_dec

(

INS

ins

)

Returns:

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

xed_operand_values_t* LEVEL_CORE::INS_xed_operand_values

(

INS

ins

)

Returns:

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

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

Replace xedreg with pinreg in the flat regs

Returns:

foo

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

Append code to zero extend src to dst

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

The root for all BBL stripes

INS_REUSERS_MANAGER& LEVEL_CORE::InsReusersManager

(

)

Return the single instance (object) of the INS_REUSERS_MANAGER class

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

The base stripe for INS

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

x

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

x

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

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

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

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

LOCALFUN INT32 LEVEL_CORE::INT_Immediate

(

xed_decoded_inst_t *

xedd

)

Return the immediate field of an INT instruction.

Parameters:

[in]

xedd

The INT instruction

Returns:

Returns the immediate field.

UINT32 LEVEL_CORE::InvalidSysCallNumber

(

)

Return integer that represents invalid syscall number

xed_iclass_enum_t LEVEL_CORE::JccIclassToCmovcc

(

INS

ins

)

Returns:

cmov with equivalent test as jmp

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

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

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

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

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

When TRUE, attach comments to data structures

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

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

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

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

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

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

• currently supported only on Windows Linux and BSD

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

x

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

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

PREG LEVEL_CORE::MAKE_PREG

(

INT32

y

)

Convert integer into PREG

REGVALUE LEVEL_CORE::MAKE_PTR_REGVALUE

(

const VOID *

y

)

Convert pointer into REGVALUE

REGVALUE LEVEL_CORE::MAKE_REGVALUE

(

ADDRINT

y

)

Convert integer into REGVALUE

REGVALUE LEVEL_CORE::MemoryLoadRegvalue

(

REGVALUE

address

)

Read REGVALUE from the specified memory location

REGVALUE128 LEVEL_CORE::MemoryLoadRegvalue128	(	ADDRINT	address,
		UINT32	sizeInBytes
	)

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

REGVALUE256 LEVEL_CORE::MemoryLoadRegvalue256	(	ADDRINT	address,
		UINT32	sizeInBytes
	)

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

REGVALUE512 LEVEL_CORE::MemoryLoadRegvalue512	(	ADDRINT	address,
		UINT32	sizeInBytes
	)

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

VOID LEVEL_CORE::MemoryStoreRegvalue	(	REGVALUE	address,
		REGVALUE	value
	)

Write the specified REGVALUE into the specified memory location.

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

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

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

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

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

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

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

messages associated with fast buffering API

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

messages associated with fast buffering API

SYSCALL_STANDARD LEVEL_CORE::NativeSysCallStd

(

)

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

REG LEVEL_CORE::PREG_2_REG

(

PREG

pr

)

Convert a physical register into the corresponding virtual register

BOOL LEVEL_CORE::REG_IsRewrittenSegmentReg

(

REG

reg

)

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

INT32 LEVEL_CORE::REG_NumSysCallArgRegs

(

SYSCALL_STANDARD

std = NativeSysCallStd()

)

Number of syscall arguments passed in registers.

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

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

Parameters:

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

Returns:

The value of the K mask register.

REGVALUE LEVEL_CORE::REG_ReadPseudo

(

REG

reg

)

Read the value of a pseudo register.

Parameters:

[in]

reg

The pseudo register number.

Returns:

The value of the pseudo register.

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

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

Parameters:

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

Returns:

The value of the FP register.

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

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

Parameters:

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

Returns:

The value of the FP register.

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

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

Parameters:

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

Returns:

The value of the FP register.

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

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

Parameters:

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

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

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

Parameters:

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

Returns:

The value of the FP register.

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

Returns:

The value of the XMM register.

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

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

Parameters:

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

Returns:

The value of the YMM register.

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

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

Parameters:

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

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

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

Parameters:

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

Returns:

The value of the ZMM register.

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

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

Parameters:

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

REG LEVEL_CORE::REG_RenameAppReg

(

const REG

reg

)

Given an application reg return its corresponding pin register

REG LEVEL_CORE::REG_RenamePinReg

(

const REG

reg

)

Give a pin reg return its corresponding application register

BOOL LEVEL_CORE::REG_ShouldBeRenamed	(	CALLING_STANDARD	std,
		REG	reg
	)

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

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

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

Parameters:

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

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

Write the value of a pseudo register.

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

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

Parameters:

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

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

Return the register that holds the ith syscall argument

REG LEVEL_CORE::REG_SysCallErrno

(

SYSCALL_STANDARD

std = NativeSysCallStd()

)

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

REG LEVEL_CORE::REG_SysCallNumber

(

SYSCALL_STANDARD

std = NativeSysCallStd()

)

Return the register that holds the syscall number

REG LEVEL_CORE::REG_SysCallResult

(

SYSCALL_STANDARD

std = NativeSysCallStd()

)

Return the register that holds the syscall result

REGSET LEVEL_CORE::REGSET_SyscalleeSavedGr

(

SYSCALL_STANDARD

std = NativeSysCallStd()

)

Registers saved in syscall

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

Insert Before

VOID LEVEL_CORE::REGSYM_Unlink

(

SYM

sym

)

unlink a SYM from an IMG

REL_TYPE LEVEL_CORE::REL_AddrintRel

(

)

rel type for an address

REL LEVEL_CORE::REL_Alloc

(

)

Allocate a REL

VOID LEVEL_CORE::REL_Check

(

REL

rel

)

x

REL LEVEL_CORE::REL_First

(

)

VOID LEVEL_CORE::REL_Free

(

REL

rel

)

Deallocate an unlinked REL

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

Unlink REL from CHUNK

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

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

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

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

REL LEVEL_CORE::REL_Next

(

REL

rel

)

string LEVEL_CORE::REL_StringShort

(

REL

rel

)

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

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

Append REL to SEC

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

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

Parameters:

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

VOID LEVEL_CORE::REL_UnlinkChunk

(

REL

rel

)

Unlink REL from CHUNK

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

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

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

set the value of a REL (to SYM)

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

set the value of a REL (to SYM)

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

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

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

set the value of a REL (to GP)

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

set the value of a REL (to SYM)

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

set the value of a REL (to GP)

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

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

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

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

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

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

VOID LEVEL_CORE::REL_ValueSetZero

(

REL

rel

)

set the value of a REL (to ZERO)

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

x

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

The root for all REL stripes

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

The base stripe for REL

RTN LEVEL_CORE::RTN_Alloc

(

)

Allocate a new RTN

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

Append RTN to SEC

UINT32 LEVEL_CORE::RTN_ByteSize

(

RTN

rtn

)

Compute number of static INSs inside RTN

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

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

VOID LEVEL_CORE::RTN_Free

(

RTN

rtn

)

Deallocate unlinked RTN

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

Insert RTN after another RTN within a SEC

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

Insert RTN before another RTN within a SEC

BOOL LEVEL_CORE::RTN_IsLeaf

(

RTN

rtn

)

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

VOID LEVEL_CORE::RTN_MakeBbls

(

RTN

rtn

)

Build basic blocks inside routine

VOID LEVEL_CORE::RTN_Mark1Bbls

(

RTN

rtn

)

Set the First marker on all bbls

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

Move bbls from one container to another container routine

UINT32 LEVEL_CORE::RTN_NumAttrCrosslink

(

RTN

rtn

)

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

UINT32 LEVEL_CORE::RTN_NumBbl

(

RTN

rtn

)

Compute number of static BBLs inside RTN

UINT32 LEVEL_CORE::RTN_NumExt

(

RTN

parent

)

x

UINT32 LEVEL_CORE::RTN_numIns

(

RTN

rtn

)

Compute number of static INSs inside RTN

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

Prepend RTN to SEC

VOID LEVEL_CORE::RTN_RemoveAllExt

(

RTN

rtn

)

Removes all extensions from the received routine.

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

set the vaddr of the RTN

string LEVEL_CORE::RTN_StringLong

(

RTN

rtn

)

produce string for RTN

string LEVEL_CORE::RTN_StringLongDataFancy

(

RTN

rtn

)

produce string for RTN also listing BBLs

string LEVEL_CORE::RTN_StringLongFancy

(

RTN

rtn

)

produce string for RTN also listing BBLs

VOID LEVEL_CORE::RTN_TypifyBblsAndCreateEdgs

(

RTN

rtn

)

determing BBL type based on last INS and create sucessor EDGs

VOID LEVEL_CORE::RTN_Unlink

(

RTN

rtn

)

Unlink RTN from a SEC

VOID LEVEL_CORE::RTN_UnmakeBbls

(

RTN

rtn

)

Put all routine instructions in one basic block

VOID LEVEL_CORE::RTN_Unmark1Bbls

(

RTN

rtn

)

Reset all the markers on all the bbls

UINT32 LEVEL_CORE::RTN_VerifyFallthroughs

(

RTN

rtn

)

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

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

x

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

X

SEC LEVEL_CORE::SEC_Alloc

(

)

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

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

append a SEC to IMG

VOID LEVEL_CORE::SEC_Check

(

SEC

sec

)

x

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

This function does the final encoding into the code cache

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

x

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

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

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

get a piece of data directly from the incoming SEC data

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

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

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

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

VOID LEVEL_CORE::SEC_CreateOriginalIns

(

SEC

sec

)

x

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

Find a particular routine by iaddr in the given section

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

x

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

Find a particular routine by iaddr in the given section

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

Find a particular routine by name in the given section

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

x

VOID LEVEL_CORE::SEC_Free

(

SEC

sec

)

x

VOID LEVEL_CORE::SEC_GarbageCollect

(

)

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

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

get a piece of data directly from the incoming SEC data

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

get a piece of data directly from the incoming SEC data

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

get a piece of data directly from the incoming SEC data

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

x

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

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

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

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

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

x

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

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

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

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

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

insert SEC after another sec within an IMG

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

insert SEC before another sec within an IMG

INS LEVEL_CORE::SEC_MapIaddrToOriginalIns	(	SEC	sec,
		IADDR	iaddr
	)

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

IADDR LEVEL_CORE::SEC_MapOriginalInsToIaddr	(	SEC	sec,
		INS	ins
	)

Map an original INS to its IADDR.

UINT32 LEVEL_CORE::SEC_NumRtn

(

SEC

sec

)

return the number of RTNs for SEC

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

prepend a SEC to IMG

VOID LEVEL_CORE::SEC_SetDataCopy

(

SEC

sec

)

x

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

x

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

x

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

x

VOID LEVEL_CORE::SEC_StateSet	(	SEC	sec,
		SEC_STATE	state
	)

x

string LEVEL_CORE::SEC_String

(

SEC_STATE

state

)

convert a SEC_STATE into a printable string

string LEVEL_CORE::SEC_String

(

SEC_TYPE

type

)

convert a SEC_TYPE into a printable string

string LEVEL_CORE::SEC_StringDataDumpI	(	SEC	sec,
		UINT32	width
	)

convert a SECs incoming data into a printable string

string LEVEL_CORE::SEC_StringDis

(

SEC

sec

)

x

string LEVEL_CORE::SEC_StringLong

(

SEC

sec

)

convert a SEC into a printable string

string LEVEL_CORE::SEC_StringLongWithChunks

(

SEC

sec

)

convert a SEC into a printable string -

VOID LEVEL_CORE::SEC_Unlink

(

SEC

sec

)

unlink a SEC from an IMG

ARRAYBASE LEVEL_CORE::SecArrayBase	(	"sec pool"	,
		1024
	)

The root for all SEC stripes

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

The base stripe for SEC

string LEVEL_CORE::SEGMENT_StringShort

(

SEGMENT_TYPE

segment

)

convert a SEGMENT_TYPE into a printable string

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

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

Parameters:

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

ADDRDELTA LEVEL_CORE::SignedOffset

(

ADDRINT

imm

)

return imm as a signed offset

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

Simulate a return for the passed call instruction

BBL LEVEL_CORE::SimulateRetPush

(

INS

call

)

Simulate a return for the passed call instruction

LOCALFUN string LEVEL_CORE::StrXedEnc

(

const xed_encoder_request_t *

r

)

Returns:

a string for the encode request

VOID LEVEL_CORE::SYM_AddContainedSymbol	(	SYM	sym,
		SYM	contained_sym
	)

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

SYM LEVEL_CORE::SYM_Alloc

(

)

Allocate a SYM

VOID LEVEL_CORE::SYM_Check

(

SYM

sym

)

x

VOID LEVEL_CORE::SYM_Free

(

SYM

sym

)

Deallocate a SYM

VOID LEVEL_CORE::SYM_GarbageCollect

(

)

SYM garbage collector

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

Init SYM (does not have to be original)

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

Set the size of an SYM

string LEVEL_CORE::SYM_StringShort

(

SYM

sym

)

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

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

The root for all SYM stripes

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

The base stripe for SYM

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

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

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

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

BOOL LEVEL_CORE::UseSahfLahfSequence

(

)

Returns:

if the lahf/sahf sequence should be used

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

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

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

generate new outigoing address/value for val

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

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

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

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

Parameters:

[in]	ins	- the instruction to inspect
[in]	filterWrites	- filter all operands that are memory write operands
[in]	filterReads	- filter all operands that are memory read operands
[in]	filterImplicit	- filter memory operands that are implicit

Returns:

The base register

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

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

VOID LEVEL_CORE::XED_encode_decode_update_stripe	(	INS	ins,
		xed_encoder_request_t *	xed_enc
	)

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

xed_reg_enum_t LEVEL_CORE::xed_exact_map_from_pin_reg

(

REG

pin_reg

)

Returns:

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

REG LEVEL_CORE::xed_exact_map_to_pin_reg

(

xed_reg_enum_t

xed_reg

)

Returns:

a valid pin register, but never an invalid one

VOID LEVEL_CORE::XED_init

(

)

Returns:

Nothing

BOOL LEVEL_CORE::XED_INS_IsMultimedia

(

INS

ins

)

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

VOID LEVEL_CORE::XED_log_init

(

)

Returns:

Nothing

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

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

Returns:

nothing

REG LEVEL_CORE::xed_map_to_pin_reg

(

xed_reg_enum_t

xed_reg

)

Returns:

a valid pin register or REG_INVALID().

FLAGS LEVEL_CORE::XED_PhyFlagsRead

(

const xed_decoded_inst_t *

xedd

)

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

Parameters:

[in]

xedd

The Intel(R) XED decode info

Returns:

the FLAGS read according to the Intel(R) XED decode info

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

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

Parameters:

[in]	xedd	The Intel(R) X86 Encoder Decoder decode info
[in]	onlyDefinite	Specify TRUE if only the flags that are definitely written should be returned

Returns:

the FLAGS written according to the Intel(R) XED decode info, and the onlyDefinite specification

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

x

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

x

VOID LEVEL_CORE::XED_reencode_decode_update_stripe

(

INS

ins

)

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

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

Returns:

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

VOID LEVEL_CORE::XED_RegRolePosFromXED

(

INS

ins

)

Returns:

nothing

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

VOID LEVEL_CORE::XED_RegRolePosToXED

(

INS

ins

)

Returns:

nothing

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

LOCALFUN EXCEPTION_CODE LEVEL_CORE::XedError2ExceptionCode

(

xed_error_enum_t

xed_error

)

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

Note:

the XED_ERROR_BUFFER_TOO_SHORT error is converted into EXCEPTCODE_ACCESS_FAULT.

---

Variable Documentation

GLOBALCONST BOOL LEVEL_CORE::B_CROSSLINK = 1

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

GLOBALCONST BOOL LEVEL_CORE::B_HIDDEN = 1

a hidden attribute will be omitted from printing

LOCALCONST xed_state_t LEVEL_CORE::DSTATE

Initial value:

 
    { XED_MACHINE_MODE_LEGACY_32, XED_ADDRESS_WIDTH_32b}

LOCALVAR const xed_reg_enum_t LEVEL_CORE::dummy_regs_native_table[MAX_DUMMY_REGS]

Initial value:

{


 
    XED_REG_EDX, XED_REG_EBX, XED_REG_ECX

}

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

Initial value:

{




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

}

GLOBALCONST USIZE LEVEL_CORE::INS_PATCH_UNIT = 8

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

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

LOCALVAR BBL LEVEL_CORE::last_nonreturning_fun = BBL_INVALID()

GLOBALCONST UINT32 LEVEL_CORE::MAX_INSTRUCTION_SIZE = 15

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

GLOBALCONST REG LEVEL_CORE::REG_FirstInRegsetPhyContext = REG_PHYSICAL_INTEGER_BASE

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

GLOBALCONST REG LEVEL_CORE::REG_LastInRegsetPhyContext = REG_PHYSICAL_INTEGER_END

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

const REGSET_CONTEXT LEVEL_CORE::REGSET_CONTEXT_NONE

const REGSET LEVEL_CORE::REGSET_NONE

LOCALVAR string LEVEL_CORE::reuserTypeStr[]

Initial value:

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

LOCALVAR const SEC_STATE LEVEL_CORE::SEC_StateMachineCooked[]

Initial value:

 {SEC_STATE_INVALID, SEC_STATE_RAW_I, SEC_STATE_COOKED,
                                                     SEC_STATE_RAW_O,  SEC_STATE_LAST}

LOCALVAR const SEC_STATE LEVEL_CORE::SEC_StateMachineData[]

Initial value:

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

LOCALVAR const SEC_STATE LEVEL_CORE::SEC_StateMachineExe[]

Initial value:

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

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_MEMOFFSET_PROBE = 7

size of the type of the probe

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_OFFSET_PROBE = 5

size of the type of the probe

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_RIP_AND_ADDR_PROBE = 14

size of the type of the probe

GLOBALCONST USIZE LEVEL_CORE::SIZE_OF_RIP_PROBE = 6

size of the type of the probe

LOCALVAR USIZE LEVEL_CORE::sizeOfDirectJmp = 0

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

LOCALVAR USIZE LEVEL_CORE::sizeOfIpRelativeMemJmp = 0

Size of the unconditional, direct jjmp [gip]offset

LOCALVAR const SYM_STATE LEVEL_CORE::SYM_StateMachine[]

Initial value:

{
    SYM_STATE_INVALID,SYM_STATE_RAW,SYM_STATE_LINKED,SYM_STATE_LAST
}

---