LEVEL_BASE Namespace Reference


Classes

struct  ImageLoaderInfo
struct  LINUX_LOADER_IMAGE_INFO

Typedefs

typedef PINVM::PINSYNC_POD_LOCK PIN_MUTEX
typedef PINVM::PINSYNC_POD_RWLOCK PIN_RWMUTEX
typedef PINVM::PINSYNC_POD_SEMAPHORE PIN_SEMAPHORE
typedef BOOL(* MESSAGE_CALLBACK )(const string &message, PIN_ERRTYPE type, INT32 userType, INT32 severity, INT32 numArgs, va_list ap)
typedef STAT_INTEGRAL< UINT32 > STAT_UINT32
typedef STAT_INTEGRAL< SIZE > STAT_SIZE
typedef STAT_INTEGRAL< UINT64 > STAT_UINT64
typedef STAT_INTEGRAL< INT64 > STAT_INT64
typedef STAT_SINGLE< FLT32 > STAT_FLT32
typedef STAT_SINGLE< FLT64 > STAT_FLT64
typedef STAT_FLT64 STAT1
typedef INT32 TLS_KEY
typedef UINT8 REGTYPE
typedef UINT64 REG_CLASS_BITS
typedef VOID(* AFUNPTR )()
typedef VOID *(* THREAD_STARTROUTINE )(void *)
typedef VOID(* DESTRUCTFUN )(void *)
typedef UINT16 OPCODE
typedef PREDICATE_IA32 PREDICATE

Enumerations

enum  KNOB_MODE {
  KNOB_MODE_INVALID,
  KNOB_MODE_COMMENT,
  KNOB_MODE_WRITEONCE,
  KNOB_MODE_OVERWRITE,
  KNOB_MODE_ACCUMULATE,
  KNOB_MODE_APPEND,
  KNOB_MODE_LAST
}
enum  LOGTYPE {
  LOGTYPE_CONSOLE,
  LOGTYPE_LOGFILE,
  LOGTYPE_CONSOLE_AND_LOGFILE
}
enum  PIN_LOAD_STATUS {
  PIN_LOAD_STATUS_INVALID,
  PIN_LOAD_STATUS_INJECTOR,
  PIN_LOAD_STATUS_ATTACHED,
  PIN_LOAD_STATUS_CLEAR,
  PIN_LOAD_STATUS_CHILD_RUNS_APP,
  PIN_LOAD_STATUS_PARENT_RUNS_APP,
  PIN_LOAD_STATUS_SELF_RUNS_APP,
  PIN_LOAD_STATUS_DETACHED_LITE,
  PIN_LOAD_STATUS_DETACHED_FULL
}
enum  REGALLOC_HINT_TYPE {
  REGALLOC_HINT_INVALID,
  REGALLOC_HINT_FREEBEFORE,
  REGALLOC_HINT_FREEAFTER,
  REGALLOC_HINT_REG_IN_PREG_AFTER,
  REGALLOC_HINT_REG_IN_MEM_AFTER
}
enum  STAT_TYPE {
  STAT_TYPE_INVALID,
  STAT_TYPE_SINGLE,
  STAT_TYPE_SD,
  STAT_TYPE_BA,
  STAT_TYPE_NORM,
  STAT_TYPE_DIST
}
enum  PREDICATE_IA32 {
  PREDICATE_ALWAYS_TRUE,
  PREDICATE_INVALID,
  PREDICATE_BELOW,
  PREDICATE_BELOW_OR_EQUAL,
  PREDICATE_LESS,
  PREDICATE_LESS_OR_EQUAL,
  PREDICATE_NOT_BELOW,
  PREDICATE_NOT_BELOW_OR_EQUAL,
  PREDICATE_NOT_LESS,
  PREDICATE_NOT_LESS_OR_EQUAL,
  PREDICATE_NOT_OVERFLOW,
  PREDICATE_NOT_PARITY,
  PREDICATE_NOT_SIGN,
  PREDICATE_NOT_ZERO,
  PREDICATE_OVERFLOW,
  PREDICATE_PARITY,
  PREDICATE_SIGN,
  PREDICATE_ZERO,
  PREDICATE_CX_NON_ZERO,
  PREDICATE_ECX_NON_ZERO,
  PREDICATE_RCX_NON_ZERO,
  PREDICATE_SAVED_GCX_NON_ZERO,
  PREDICATE_LAST
}
enum  CPU_FEATURE {
  CPU_FEATURE_FIRST = 0,
  CPU_FEATURE_SSE = CPU_FEATURE_FIRST,
  CPU_FEATURE_SSE2,
  CPU_FEATURE_SSE3,
  CPU_FEATURE_EST,
  CPU_FEATURE_PBE,
  CPU_FEATURE_FXSR,
  CPU_FEATURE_CX8,
  CPU_FEATURE_CMOV,
  CPU_FEATURE_LAHF_SAHF,
  CPU_FEATURE_AVX,
  CPU_FEATURE_AVX2,
  CPU_FEATURE_AVX512F,
  CPU_FEATURE_AVX512BW,
  CPU_FEATURE_LAST = CPU_FEATURE_AVX512BW
}
enum  CPU_XFEATURE {
  CPU_XFEATURE_X87 = 0,
  CPU_XFEATURE_SSE = 1,
  CPU_XFEATURE_AVX = 2,
  CPU_XFEATURE_FIRST = CPU_XFEATURE_AVX,
  CPU_XFEATURE_BNDREGS = 3,
  CPU_XFEATURE_BNDCSR = 4,
  CPU_XFEATURE_OPMASK = 5,
  CPU_XFEATURE_ZMM_HI256 = 6,
  CPU_XFEATURE_HI16_ZMM = 7,
  CPU_XFEATURE_LAST = CPU_XFEATURE_ZMM_HI256
}
enum  CPU_XFEATURE_BIT {
  CPU_XFEATURE_BIT_X87 = (1 << CPU_XFEATURE_X87),
  CPU_XFEATURE_BIT_SSE = (1 << CPU_XFEATURE_SSE),
  CPU_XFEATURE_BIT_AVX = (1 << CPU_XFEATURE_AVX),
  CPU_XFEATURE_BIT_BNDREGS = (1 << CPU_XFEATURE_BNDREGS),
  CPU_XFEATURE_BIT_BNDCSR = (1 << CPU_XFEATURE_BNDCSR),
  CPU_XFEATURE_BIT_OPMASK = (1 << CPU_XFEATURE_OPMASK),
  CPU_XFEATURE_BIT_ZMM_HI256 = (1 << CPU_XFEATURE_ZMM_HI256),
  CPU_XFEATURE_BIT_HI16_ZMM = (1 << CPU_XFEATURE_HI16_ZMM),
  CPU_XFEATURE_BIT_AVX512F,
  CPU_XFEATURE_BIT_LEGACY = CPU_XFEATURE_BIT_X87 | CPU_XFEATURE_BIT_SSE,
  CPU_XFEATURE_BIT_ALL
}
enum  VECTOR_REGISTER_SET {
  VECTOR_REGISTER_SET_NONE,
  VECTOR_REGISTER_SET_AVX,
  VECTOR_REGISTER_SET_AVX512
}
enum  REG {
  REG_INVALID_ = 0,
  REG_GR_BASE = REG_RBASE,
  REG_EDI = REG_GR_BASE,
  REG_GDI = REG_EDI,
  REG_ESI,
  REG_GSI = REG_ESI,
  REG_EBP,
  REG_GBP = REG_EBP,
  REG_ESP,
  REG_STACK_PTR = REG_ESP,
  REG_EBX,
  REG_GBX = REG_EBX,
  REG_EDX,
  REG_GDX = REG_EDX,
  REG_ECX,
  REG_GCX = REG_ECX,
  REG_EAX,
  REG_GAX = REG_EAX,
  REG_GR_LAST = REG_EAX,
  REG_SEG_BASE,
  REG_SEG_CS = REG_SEG_BASE,
  REG_SEG_SS,
  REG_SEG_DS,
  REG_SEG_ES,
  REG_SEG_FS,
  REG_SEG_GS,
  REG_SEG_LAST = REG_SEG_GS,
  REG_EFLAGS,
  REG_GFLAGS = REG_EFLAGS,
  REG_EIP,
  REG_INST_PTR = REG_EIP,
  REG_AL,
  REG_AH,
  REG_AX,
  REG_CL,
  REG_CH,
  REG_CX,
  REG_DL,
  REG_DH,
  REG_DX,
  REG_BL,
  REG_BH,
  REG_BX,
  REG_BP,
  REG_SI,
  REG_DI,
  REG_SP,
  REG_FLAGS,
  REG_IP,
  REG_MM_BASE,
  REG_MM0 = REG_MM_BASE,
  REG_MM1,
  REG_MM2,
  REG_MM3,
  REG_MM4,
  REG_MM5,
  REG_MM6,
  REG_MM7,
  REG_MM_LAST = REG_MM7,
  REG_XMM_BASE,
  REG_FIRST_FP_REG = REG_XMM_BASE,
  REG_XMM0 = REG_XMM_BASE,
  REG_XMM1,
  REG_XMM2,
  REG_XMM3,
  REG_XMM4,
  REG_XMM5,
  REG_XMM6,
  REG_XMM7,
  REG_XMM_SSE_LAST = REG_XMM7,
  REG_XMM_AVX_LAST = REG_XMM_SSE_LAST,
  REG_XMM_AVX512_LAST = REG_XMM_AVX_LAST,
  REG_XMM_LAST = REG_XMM_AVX512_LAST,
  REG_YMM_BASE,
  REG_YMM0 = REG_YMM_BASE,
  REG_YMM1,
  REG_YMM2,
  REG_YMM3,
  REG_YMM4,
  REG_YMM5,
  REG_YMM6,
  REG_YMM7,
  REG_YMM_AVX_LAST = REG_YMM7,
  REG_YMM_AVX512_LAST = REG_YMM_AVX_LAST,
  REG_YMM_LAST = REG_YMM_AVX512_LAST,
  REG_ZMM_BASE,
  REG_ZMM0 = REG_ZMM_BASE,
  REG_ZMM1,
  REG_ZMM2,
  REG_ZMM3,
  REG_ZMM4,
  REG_ZMM5,
  REG_ZMM6,
  REG_ZMM7,
  REG_ZMM_AVX512_SPLIT_LAST = REG_ZMM7,
  REG_ZMM_AVX512_LAST = REG_ZMM_AVX512_SPLIT_LAST,
  REG_ZMM_LAST = REG_ZMM_AVX512_LAST,
  REG_K_BASE,
  REG_K0 = REG_K_BASE,
  REG_IMPLICIT_FULL_MASK = REG_K0,
  REG_K1,
  REG_K2,
  REG_K3,
  REG_K4,
  REG_K5,
  REG_K6,
  REG_K7,
  REG_K_LAST = REG_K7,
  REG_MXCSR,
  REG_MXCSRMASK,
  REG_ORIG_EAX,
  REG_ORIG_GAX = REG_ORIG_EAX,
  REG_FPST_BASE,
  REG_FPSTATUS_BASE = REG_FPST_BASE,
  REG_FPCW = REG_FPSTATUS_BASE,
  REG_FPSW,
  REG_FPTAG,
  REG_FPIP_OFF,
  REG_FPIP_SEL,
  REG_FPOPCODE,
  REG_FPDP_OFF,
  REG_FPDP_SEL,
  REG_FPSTATUS_LAST = REG_FPDP_SEL,
  REG_FPTAG_FULL,
  REG_ST_BASE,
  REG_ST0 = REG_ST_BASE,
  REG_ST1,
  REG_ST2,
  REG_ST3,
  REG_ST4,
  REG_ST5,
  REG_ST6,
  REG_ST7,
  REG_ST_LAST = REG_ST7,
  REG_FPST_LAST = REG_ST_LAST,
  REG_DR_BASE,
  REG_DR0 = REG_DR_BASE,
  REG_DR1,
  REG_DR2,
  REG_DR3,
  REG_DR4,
  REG_DR5,
  REG_DR6,
  REG_DR7,
  REG_DR_LAST = REG_DR7,
  REG_CR_BASE,
  REG_CR0 = REG_CR_BASE,
  REG_CR1,
  REG_CR2,
  REG_CR3,
  REG_CR4,
  REG_CR_LAST = REG_CR4,
  REG_TSSR,
  REG_LDTR,
  REG_TR_BASE,
  REG_TR = REG_TR_BASE,
  REG_TR3,
  REG_TR4,
  REG_TR5,
  REG_TR6,
  REG_TR7,
  REG_TR_LAST = REG_TR7,
  REG_SEG_GS_BASE = REG_TOOL_BASE,
  REG_SEG_FS_BASE,
  REG_INST_BASE,
  REG_INST_SCRATCH_BASE = REG_INST_BASE,
  REG_INST_G0 = REG_INST_SCRATCH_BASE,
  REG_INST_G1,
  REG_INST_G2,
  REG_INST_G3,
  REG_INST_G4,
  REG_INST_G5,
  REG_INST_G6,
  REG_INST_G7,
  REG_INST_G8,
  REG_INST_G9,
  REG_INST_G10,
  REG_INST_G11,
  REG_INST_G12,
  REG_INST_G13,
  REG_INST_G14,
  REG_INST_G15,
  REG_INST_G16,
  REG_INST_G17,
  REG_INST_G18,
  REG_INST_G19,
  REG_INST_G20,
  REG_INST_G21,
  REG_INST_G22,
  REG_INST_G23,
  REG_INST_G24,
  REG_INST_G25,
  REG_INST_G26,
  REG_INST_G27,
  REG_INST_G28,
  REG_INST_G29,
  REG_INST_TOOL_FIRST = REG_INST_G0,
  REG_INST_TOOL_LAST = REG_INST_G29,
  REG_BUF_BASE0,
  REG_BUF_BASE1,
  REG_BUF_BASE2,
  REG_BUF_BASE3,
  REG_BUF_BASE4,
  REG_BUF_BASE5,
  REG_BUF_BASE6,
  REG_BUF_BASE7,
  REG_BUF_BASE8,
  REG_BUF_BASE9,
  REG_BUF_BASE_LAST = REG_BUF_BASE9,
  REG_BUF_END0,
  REG_BUF_END1,
  REG_BUF_END2,
  REG_BUF_END3,
  REG_BUF_END4,
  REG_BUF_END5,
  REG_BUF_END6,
  REG_BUF_END7,
  REG_BUF_END8,
  REG_BUF_END9,
  REG_BUF_ENDLAST = REG_BUF_END9,
  REG_BUF_LAST = REG_BUF_ENDLAST,
  REG_INST_SCRATCH_LAST = REG_BUF_LAST,
  REG_TOOL_LAST = REG_BUF_LAST,
  REG_LAST
}
enum  REGNAME { REGNAME_LAST }
enum  REGWIDTH {
  REGWIDTH_8 = 0,
  REGWIDTH_16 = 1,
  REGWIDTH_32 = 2,
  REGWIDTH_64 = 3,
  REGWIDTH_80,
  REGWIDTH_128,
  REGWIDTH_256,
  REGWIDTH_512,
  REGWIDTH_INVALID,
  REGWIDTH_NATIVE = REGWIDTH_64
}
enum  REG_CLASS {
  REG_CLASS_NONE = 0,
  REG_CLASS_PSEUDO,
  REG_CLASS_GR,
  REG_CLASS_GRU8,
  REG_CLASS_GRL8,
  REG_CLASS_GRH16,
  REG_CLASS_GRH32,
  REG_CLASS_SEG,
  REG_CLASS_MM,
  REG_CLASS_XMM,
  REG_CLASS_YMM,
  REG_CLASS_ZMM,
  REG_CLASS_K,
  REG_CLASS_FPST,
  REG_CLASS_ST,
  REG_CLASS_CR,
  REG_CLASS_DR,
  REG_CLASS_TR,
  REG_CLASS_FLAGS,
  REG_CLASS_FLAGS16,
  REG_CLASS_FLAGS32,
  REG_CLASS_STATUS_FLAGS,
  REG_CLASS_DFLAG,
  REG_CLASS_MXCSR,
  REG_CLASS_MXCSRMASK,
  REG_CLASS_IP,
  REG_CLASS_IP16,
  REG_CLASS_IP32,
  REG_CLASS_ARCH,
  REG_CLASS_PIN_GR,
  REG_CLASS_PIN_GRU8,
  REG_CLASS_PIN_GRL8,
  REG_CLASS_PIN_GRH16,
  REG_CLASS_PIN_GRH32,
  REG_CLASS_PIN_XMM,
  REG_CLASS_PIN_YMM,
  REG_CLASS_PIN_ZMM,
  REG_CLASS_PIN_K,
  REG_CLASS_PIN_MXCSR,
  REG_CLASS_PIN_FLAGS,
  REG_CLASS_PIN_STATUS_FLAGS,
  REG_CLASS_PIN_DFLAG
}
enum  REG_SUBCLASS {
  REG_SUBCLASS_NONE = 0,
  REG_SUBCLASS_REX,
  REG_SUBCLASS_FULL_STACKPTR,
  REG_SUBCLASS_PIN_FULL_STACKPTR,
  REG_SUBCLASS_PIN_TMP,
  REG_SUBCLASS_PIN_INST_GR,
  REG_SUBCLASS_PIN_INST_GR_H32,
  REG_SUBCLASS_PIN_INST_BUF,
  REG_SUBCLASS_PIN_INST_COND
}

Functions

LOCALFUN INT32 MEGA (INT32 v)
LOCALFUN INT32 KILO (INT32 v)
LOCALVAR STAT_NORM StatStripeBytes ("mem","bytes","stripe","",&StatRawMmapBytes)
LOCALVAR STAT_UINT64 STAT_ArrayBaseAlloc ("pin","array_base","alloc","")
LOCALVAR STAT_UINT64 STAT_ArrayBaseFree ("pin","array_base","free","")
STAT_UINT64 STAT_TotalAttempts_COMPLEXLOCK ("pin","complexlock","attempts","")
STAT_UINT64 STAT_TotalSpins_COMPLEXLOCK ("pin","complexlock","spins_total","")
STAT_UINT64 STAT_MaxSpins_COMPLEXLOCK ("pin","complexlock","spins_max","")
STAT_NORM STAT_WaitTime_COMPLEXLOCK ("pin","time","complexlock_wait","",&TimerApp)
ATOMIC_STATS STAT_Backoff_COMPLEXLOCK ("pin","complexlock")
NATIVE_TID SlowGetTid ()
LOCALCONST char * SeverityToString (int num)
LOCALFUN string StripNewline (const string &cstr)
LOCALFUN VOID XML_encode (const string &source, string &destination)
LOCALFUN string LowerDash (const string &s)
LOCALFUN int cmp (const void *x1, const void *x2)
LOCALVAR KNOB_COMMENT KnobUserAndPintoolFamily ("user&pintool","General switches (available in pin and tool)")
LOCALVAR KNOB_COMMENT KnobMemoryConstraintsFamily ("user:memory","Knobs for constraining memory usage")
KNOB< BOOL > KnobSlowAsserts (KNOB_MODE_WRITEONCE,"user&pintool","slow_asserts","0","Perform expensive sanity checks")
KNOB< BOOL > KnobIFeelLucky (KNOB_MODE_WRITEONCE,"user","ifeellucky","0","skip warning message for unsupported platforms and convert some errors to warnings")
KNOB< BOOL > KnobAllowMt (KNOB_MODE_WRITEONCE,"user","mt","1","Allow multithreaded programs")
KNOB< UINT32 > KnobAttachToProcessPid (KNOB_MODE_WRITEONCE,"user","pid","0","Attach to process with PID")
KNOB< BOOL > KnobDetachReattachActive (KNOB_MODE_WRITEONCE,"user","detach_reattach","0","Allow detach and reattach in probe mode")
KNOB< UINT32 > KnobWaitingProcess (KNOB_MODE_WRITEONCE,"internal","waiting_process","0","Attach to waiting process with PID")
KNOB< UINT32 > KnobWaitingInjector (KNOB_MODE_WRITEONCE,"internal","waiting_injector","0","PID of waiting injector process")
KNOB< UINT32 > KnobSigChildHandler (KNOB_MODE_WRITEONCE,"internal","sigchld_handler","0","PID of waiting injector process")
KNOB< string > KnobErrorFile (KNOB_MODE_WRITEONCE,"user","error_file","","The error file name")
KNOB< BOOL > KnobUniqueErrorFile (KNOB_MODE_WRITEONCE,"user","unique_error_file","0","The error file name will contain the pid")
KNOB< string > KnobLogFile (KNOB_MODE_WRITEONCE,"user","logfile","pin.log","The log file path and file name")
KNOB< BOOL > KnobUniqueLogFiles (KNOB_MODE_WRITEONCE,"user","unique_logfile","0","The log file names will contain the pid")
KNOB< BOOL > KnobAppendLogFile (KNOB_MODE_WRITEONCE,"supported","append_logfile","0","Append to the end of the log file if it already exists")
KNOB< string > P64Knob (KNOB_MODE_WRITEONCE,"user","p64","","Specify Pin binary for Intel(R) 64 architecture")
KNOB< string > P32Knob (KNOB_MODE_WRITEONCE,"user","p32","","Specify Pin binary for IA-32 architecture")
KNOB< string > T64Knob (KNOB_MODE_WRITEONCE,"user","t64","","Specify tool binary for Intel(R) 64 architecture")
KNOB< BOOL > KnobFollowChild (KNOB_MODE_WRITEONCE,"user","follow_execv","0","Execute with Pin all processes spawned by execv class system calls")
KNOB< BOOL > KnobLateInjection (KNOB_MODE_WRITEONCE,"supported","late_injection","0","Late injection (after initialization APC) on Windows")
KNOB< BOOL > KnobDebugInstrumentedProcesses (KNOB_MODE_WRITEONCE,"user","debug_instrumented_processes","0","Print message to allow debugger attach to instrumented processes")
KNOB< BOOL > KnobHelp (KNOB_MODE_WRITEONCE,"user","help","0","Print help message")
KNOB< BOOL > KnobVersion (KNOB_MODE_WRITEONCE,"user","version","0","Print version message")
VOID PIN_InitLock (PIN_LOCK *lock)
VOID PIN_GetLock (PIN_LOCK *lock, INT32 val)
INT32 PIN_ReleaseLock (PIN_LOCK *lock)
BOOL PIN_MutexInit (PIN_MUTEX *lock)
VOID PIN_MutexFini (PIN_MUTEX *lock)
VOID PIN_MutexLock (PIN_MUTEX *lock)
VOID PIN_MutexUnlock (PIN_MUTEX *lock)
BOOL PIN_MutexTryLock (PIN_MUTEX *lock)
BOOL PIN_RWMutexInit (PIN_RWMUTEX *lock)
VOID PIN_RWMutexFini (PIN_RWMUTEX *lock)
VOID PIN_RWMutexReadLock (PIN_RWMUTEX *lock)
VOID PIN_RWMutexWriteLock (PIN_RWMUTEX *lock)
VOID PIN_RWMutexUnlock (PIN_RWMUTEX *lock)
BOOL PIN_RWMutexTryReadLock (PIN_RWMUTEX *lock)
BOOL PIN_RWMutexTryWriteLock (PIN_RWMUTEX *lock)
BOOL PIN_SemaphoreInit (PIN_SEMAPHORE *sem)
VOID PIN_SemaphoreFini (PIN_SEMAPHORE *sem)
VOID PIN_SemaphoreSet (PIN_SEMAPHORE *sem)
VOID PIN_SemaphoreClear (PIN_SEMAPHORE *sem)
BOOL PIN_SemaphoreIsSet (PIN_SEMAPHORE *sem)
VOID PIN_SemaphoreWait (PIN_SEMAPHORE *sem)
BOOL PIN_SemaphoreTimedWait (PIN_SEMAPHORE *sem, unsigned timeout)
MESSAGE_TYPE MessageTypeNonFatalError ("non_fatal_error","NFE: ", false, false, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"errors")
MESSAGE_TYPE MessageTypeError ("error","E: ", true, false, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"errors")
MESSAGE_TYPE MessageTypeCriticalError ("critical_error","E: ", false, false, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"errors")
MESSAGE_TYPE MessageTypeWarning ("warning","W: ", false, false, true, false, LOGTYPE_LOGFILE,"warnings")
MESSAGE_TYPE MessageTypeConsole ("console","C: ", false, false, true, false, LOGTYPE_CONSOLE,"console")
MESSAGE_TYPE MessageTypeConsoleNoPrefix ("console_noprefix","", false, false, true, false, LOGTYPE_CONSOLE,"console")
MESSAGE_TYPE_ALWAYS_ON MessageTypeAssert ("assert","A: ", true, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"assert")
MESSAGE_TYPE MessageTypePhase ("phase","P: ", false, false, true, true, LOGTYPE_CONSOLE,"phase")
MESSAGE_TYPE MessageTypeKnown ("known","K: ", false, false, true, false, LOGTYPE_CONSOLE,"known problem")
MESSAGE_TYPE MessageTypeInfo ("info","I: ", false, false, true, false, LOGTYPE_CONSOLE,"info")
MESSAGE_TYPE MessageTypeDebug ("debug","D: ", false, false, false, false, LOGTYPE_CONSOLE,"generic debug")
MESSAGE_TYPE MessageTypeOpportunity ("opportunity","O: ", false, false, true, false, LOGTYPE_CONSOLE,"generic optimization opportunity")
MESSAGE_TYPE MessageTypeStats ("stats","S: ", false, false, true, false, LOGTYPE_CONSOLE,"statistic")
MESSAGE_TYPE MessageTypeLog ("log","", false, false, true, false, LOGTYPE_LOGFILE,"generic log")
const string Line1 (80,'#')
const string Line2 (80,'=')
const string Line3 (80,'-')
const string Line4 (80,'.')
UINT64 MilliSecondsElapsed ()
UINT64 KiloBytesUsed ()
string ResourceInfo ()
string AssertString (const char *fileName, const char *functionName, unsigned line, const std::string &message)
LOCALVAR KNOB< UINT32 > PauseAbortKnob (KNOB_MODE_WRITEONCE,"supported:basic","pause_abort","0","Pause and print pid so gdb can attach before pin aborts")
GLOBALCFUN VOID PrintPinStackTrace (ostream &os)
VOID BreakMe ()
UINT32 DivZero (UINT32 x)
VOID SegFault ()
LOCALFUN VOID SignalHandler (int arg)
VOID InstallSignalHandlers ()
BOOL SlowAssertsEnabled ()
KNOB< string > KnobMesgOn (KNOB_MODE_APPEND,"supported:message","mesgon","","enable given message type")
KNOB< string > KnobMesgOff (KNOB_MODE_APPEND,"supported:message","mesgoff","","disable given message type")
PIN_LOAD_STATUS PinStatusGetLoadStatus ()
VOID PinStatusSetLoadStatus (PIN_LOAD_STATUS ls)
PIN_LOAD_STATUS PinStatusGetInjectionType ()
string LoadStatusString (PIN_LOAD_STATUS load_status)
string PinStatusString (PIN_STATUS *ps)
KNOB< BOOL > KnobSeparatelyHandledXmm (KNOB_MODE_WRITEONCE,"supported","separately_handled_xmm","1","separtely handled xmm")
string REGALLOCHINT_String (const REGALLOC_HINT_TYPE hint)
LOCALVAR KNOB_COMMENT KnobStatFamily ("supported:stat","Statistic switches")
KNOB< BOOL > KnobStatistics (KNOB_MODE_WRITEONCE,"supported:stat","statistic","0","print general statistics")
LOCALFUN int cmp (const VOID *x1, const VOID *x2)
LOCALFUN VOID TestStringForBadChars (const string &s)
STAT_NORM TimerApp ("pin","time","total","", 0)
LOCALVAR STAT_NORM TimerOtherApp ("pin","time","cc+tool","",&TimerApp, TRUE)
STAT_NORM TimerVm ("pin","time","vm","",&TimerApp)
STAT_NORM STAT_vm_enter_count ("pin","time_vm","vmenter_count","", NULL)
STAT_NORM STAT_time_vm_enter_to_leave ("pin","time_vm","time_in_vm","",&STAT_vm_enter_count)
STAT_NORM STAT_time_vm_past_enter ("pin","time_vm","time_in_vm_past_enter","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_vm_locked ("pin","time_vm","time_locked","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_acquire_vm_lock_count ("pin","time_vm","get_lock_count","", NULL)
STAT_NORM STAT_time_wait_for_vm_lock ("pin","time_vm","time_wait_for_lock","",&STAT_acquire_vm_lock_count)
STAT_NORM STAT_time_vm_threads ("pin","time_vm","time_all_threads","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_EMU ("pin","time_vm","VMSVC_EMU","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_XFER ("pin","time_vm","VMSVC_XFER","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_XFER_INDIRECT ("pin","time_vm","VMSVC_XFER_INDIRECT","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_XFER_NATIVE ("pin","time_vm","VMSVC_XFER_NATIVE","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_SMC ("pin","time_vm","VMSVC_SMC","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_SELF_HANDLER ("pin","time_vm","VMSVC_SELF_HANDLER","",&STAT_time_vm_enter_to_leave)
STAT_NORM STAT_time_VMSVC_XFER_BRIDGE ("pin","time_vm","VMSVC_XFER_BRIDGE","",&STAT_time_vm_enter_to_leave)
STAT_NORM TimerCompile ("pin","time","Compile","",&TimerVm)
STAT_NORM TimerMakeRegion ("pin","time","MakeRegion","",&TimerCompile)
STAT_NORM TimerMakeApplication ("pin","time","MakeApplication","",&TimerMakeRegion)
STAT_NORM TimerFetchRegion ("pin","time","FetchRegion","",&TimerMakeApplication)
VOID StartApplicationTimer ()
VOID StopApplicationTimer ()
CHAR * GetCmdArg (const CHAR *cmdPtr, BOOL isFile, CHAR *buf, size_t bufSize, size_t *pArgSize, const CHAR **pNextPtr)
CHAR * GetAppCmdLine (const CHAR *pinCmdLine)
string SplitString (string *input, const string &delimiter=" ")
BOOL EndsWith (const CHAR *in, const CHAR *post)
BOOL StartsWith (const CHAR *in, const CHAR *pre)
VOID SetAddress0x (BOOL val)
BOOL CharIsSpace (CHAR c)
CHAR CharToUpper (CHAR c)
string ptrstr (const VOID *val)
string StringFromAddrint (ADDRINT l)
string StringFromUint64 (UINT64 l)
string StringDec (UINT64 l, UINT32 digits, CHAR padding)
string StringDecSigned (INT64 l, UINT32 digits, CHAR padding)
string StringBignum (INT64 l, UINT32 digits, CHAR padding)
string Reformat (const string &s, const string &prefix, UINT32 min_line, UINT32 max_line)
string StringHex32 (UINT32 l, UINT32 digits, BOOL prefix_0x)
LOCALFUN VOID InsertCommas (CHAR *buffer, INT32 width)
string StringFlt (FLT64 val, UINT32 precision, UINT32 width)
string StringBool (BOOL b)
string StringTri (TRI t)
INT32 Int32FromString (const string &s)
UINT32 Uint32FromString (const string &s)
INT64 Int64FromString (const string &s)
UINT64 Uint64FromString (const string &s)
FLT64 FLT64FromString (const string &s)
INT CharToHexDigit (CHAR c)
ADDRINT AddrintFromString (const string &str)
UINT32 BitCount (ADDRINT val)
string ReadLine (istream &inputFile, UINT32 *lineNum)
UINT32 Tokenize (const string &line, string *array, UINT32 n)
string StringHex (UINT32 l, UINT32 digits, BOOL prefix_0x=TRUE)
string decstr (INT64 val, UINT32 width=0)
string decstr (INT32 val, UINT32 width=0)
string decstr (INT16 val, UINT32 width=0)
string decstr (UINT64 val, UINT32 width=0)
string decstr (UINT32 val, UINT32 width=0)
string decstr (UINT16 val, UINT32 width=0)
string hexstr (INT64 val, UINT32 width=0)
string hexstr (INT32 val, UINT32 width=0)
string hexstr (INT16 val, UINT32 width=0)
string hexstr (UINT64 val, UINT32 width=0)
string hexstr (VOID *p, UINT32 width=0)
string hexstr (const VOID *p, UINT32 width=0)
string hexstr (UINT32 val, UINT32 width=0)
string hexstr (UINT16 val, UINT32 width=0)
string fltstr (FLT64 val, UINT32 prec=0, UINT32 width=0)
string ljstr (const string &s, UINT32 width, CHAR padding= ' ')
template<typename ITER, typename CONV>
GLOBALTEMPLATEFUN string StringSequence (ITER begin, ITER end, const CONV &conv, const string &delimiter=string(" "))
VOID * Addrint2VoidStar (ADDRINT addr)
ADDRINT VoidStar2Addrint (const VOID *addr)
ADDRINT VoidStar2Addrint (VOID *addr)
template<typename T>
GLOBALTEMPLATEFUN BOOL IsPowerOf2 (T value)
template<typename T>
GLOBALTEMPLATEFUN T RoundToNextPower2 (T value)
template<typename T>
GLOBALTEMPLATEFUN T RoundUp (T value, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T * RoundUp (T *ptr, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T RoundUpPowerOf2 (T value, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T * RoundUpPowerOf2 (T *ptr, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T RoundDown (T value, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T * RoundDown (T *ptr, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T RoundDownPowerOf2 (T value, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN T * RoundDownPowerOf2 (T *ptr, size_t alignment)
template<typename T>
GLOBALTEMPLATEFUN ADDRINT PointerToInt (const T *ptr)
template<typename T>
GLOBALTEMPLATEFUN T * IntToPointer (ADDRINT addr)
INT64 VoidStar2Int (VOID *addr)
BOOL UnsignedImmediateFits (const UINT64 value, const UINT32 bits)
void RangeCheck (const UINT32 value, const UINT32 bits)
BOOL SignedImmediateFits (const INT64 value, const UINT32 origSize, const UINT32 extendedSize)
BOOL SignedImmediateFits (const INT64 value, const UINT32 origSize)
template<UINT32 size>
GLOBALTEMPLATEFUN UINT32 internalHashData (UINT32 prevHash, const CHAR *bytes)
template<>
GLOBALTEMPLATEFUN UINT32 internalHashData< 1 > (UINT32 prevHash, const CHAR *bytes)
template<>
GLOBALTEMPLATEFUN UINT32 internalHashData< 2 > (UINT32 prevHash, const CHAR *bytes)
template<>
GLOBALTEMPLATEFUN UINT32 internalHashData< 4 > (UINT32 prevHash, const CHAR *bytes)
template<>
GLOBALTEMPLATEFUN UINT32 internalHashData< 8 > (UINT32 prevHash, const CHAR *bytes)
template<typename T>
GLOBALTEMPLATEFUN UINT32 HashData (UINT32 oldHash, const T &data)
BOOL HasBaseName (const char *fileName, const char *baseNameToCheckFor)
INT32 MEMORY_ReadInt32 (ADDRINT address)
VOID MEMORY_WriteInt32 (ADDRINT address, INT32 value)
UINT32 MEMORY_ReadUint32 (ADDRINT address)
VOID MEMORY_WriteUint32 (ADDRINT address, UINT32 value)
INT64 MEMORY_ReadInt64 (ADDRINT address)
VOID MEMORY_WriteInt64 (ADDRINT address, INT64 value)
UINT64 MEMORY_ReadUint64 (ADDRINT address)
VOID MEMORY_WriteUint64 (ADDRINT address, UINT32 value)
ADDRINT GetPageOfAddr (ADDRINT addr)
ADDRINT ProgramEntry (const ImageLoaderInfo *mainImage, const ImageLoaderInfo *loader)
string Joinpath (string s1, string s2)
string Basename (const string &path)
CHAR * CreateTmpFileName (const CHAR *fnameTemplate)
const VOID * GetSp ()
size_t PtrDiff (const VOID *ptr1, const VOID *ptr2)
VOID * PtrAtOffset (VOID *ptr, size_t offset)
const VOID * PtrAtOffset (const VOID *ptr, size_t offset)
template<typename T>
GLOBALTEMPLATEFUN VOID * PushDataToStack (VOID *stack, const T *data, size_t alignment=1, size_t size=sizeof(T))
VOID * PushAddrintToStack (VOID *stack, ADDRINT value)
string MemRangeToString (const MemRange &range)
MemRange MemPageRange (ADDRINT addr)
MemRange MemPageRange (const VOID *addr)
STAT_NORM StatRawMmapBytes ("mem","bytes","RawMmap","",&StatReservedBytes)
STAT_NORM StatReservedBytes ("mem","bytes","Reserved","", 0)
LOCALVAR STAT_NORM StatOtherBytes ("mem","bytes","other","",&StatRawMmapBytes, TRUE)
VOID UpdateRawMmapBytes ()
VOID PullinPinMalloc ()
const CHAR * GetEnvFromArray (const CHAR *envArray[], const CHAR *name)
const string & ReleaseFamily ()
const char * PinCommitHash ()
GLOBALDLLCFUN const char * PinCommitHashC ()
const string & CommitCounter ()
LOCALFUN const string & CopyRight ()
const string & PrintablePinVersion ()
VOID * FunctionCodeAddress (void(*fp)())
LOCALVAR KNOB< BOOL > KnobAllowAvxSupport (KNOB_MODE_WRITEONCE,"supported","allow_AVX_support","1","allow AVX support")
LOCALVAR KNOB< BOOL > KnobAllowAvx512Support (KNOB_MODE_WRITEONCE,"supported","allow_AVX512_support","1","Allow using AVX-512 instructions")
CPU_INFO & Cpu ()
LOCALVAR KNOB< BOOL > KnobNoCmov (KNOB_MODE_WRITEONCE,"supported","nocmov","0","disable the use of CMOV even on machines which support it")
BOOL CanUseCMOV ()
BOOL CpuSupportsLahfSahf ()
GLOBALCFUN ADDRINT HaveAvxSupport ()
GLOBALCFUN ADDRINT HaveAvx2Support ()
GLOBALCFUN ADDRINT HaveAvx512FSupport ()
GLOBALCFUN ADDRINT HaveAvx512BWSupport ()
LOCALFUN VECTOR_REGISTER_SET DetermineVectorRegisterSet ()
VECTOR_REGISTER_SET SupportedVectorRegisterSet ()
BOOL REG_is_reg (REG reg)
BOOL REG_is_pseudo (REG reg)
BOOL REG_is_gr (REG reg)
BOOL REG_is_fr (REG reg)
BOOL REG_is_br (REG reg)
BOOL REG_is_gr64 (REG reg)
REG operator++ (REG &r)
BOOL REG_is_gr32 (REG reg)
BOOL REG_is_pin_gr32 (REG reg)
BOOL REG_is_gr16 (REG reg)
BOOL REG_is_gr8 (REG reg)
BOOL REG_is_seg (REG reg)
BOOL REG_is_fr_for_get_context (REG reg)
BOOL REG_is_fr_or_x87 (REG reg)
BOOL REG_is_mxcsr (REG reg)
BOOL REG_is_any_mxcsr (REG reg)
BOOL REG_is_any_x87 (REG reg)
REG REG_st_return_reg ()
BOOL REG_is_mm (REG reg)
BOOL REG_is_xmm (REG reg)
BOOL REG_is_ymm (REG reg)
BOOL REG_is_zmm (REG reg)
BOOL REG_is_xmm_ymm_zmm (REG reg)
BOOL REG_is_any_vector_reg (REG reg)
BOOL REG_is_k_mask (REG reg)
BOOL REG_is_any_mask (REG reg)
REG REG_corresponding_ymm_reg (REG reg)
REG REG_corresponding_zmm_reg (REG reg)
REG REG_corresponding_zmm_from_ymm (REG reg)
BOOL REG_is_dr (REG reg)
BOOL REG_is_cr (REG reg)
BOOL REG_is_tr (REG reg)
BOOL REG_is_st (REG reg)
BOOL REG_is_in_X87 (REG reg)
BOOL REG_is_machine (REG reg)
BOOL REG_is_application (REG reg)
BOOL REG_is_pin (REG reg)
BOOL REG_is_subclass_none (REG reg)
BOOL REG_is_pin_gpr (REG reg)
BOOL REG_is_seg_base (REG reg)
BOOL REG_valid_for_iarg_reg_value (REG reg)
BOOL REG_is_pin_gr (REG reg)
BOOL REG_is_pin_gr_half32 (REG reg)
BOOL REG_is_pin_xmm (REG reg)
BOOL REG_is_pin_ymm (REG reg)
BOOL REG_is_pin_zmm (REG reg)
BOOL REG_is_pin_xmm_ymm_zmm (REG reg)
BOOL REG_is_pin_k_mask (REG reg)
BOOL REG_is_avx512_hi16_xmm (const REG xmm)
BOOL REG_is_avx512_hi16_ymm (const REG ymm)
BOOL REG_is_gr_type (REG reg)
REG REG_AppFlags ()
BOOL REG_is_flags (REG reg)
BOOL REG_is_pin_flags (REG reg)
BOOL REG_is_status_flags (REG reg)
BOOL REG_is_pin_status_flags (REG reg)
BOOL REG_is_df_flag (REG reg)
BOOL REG_is_pin_df_flag (REG reg)
BOOL REG_is_flags_type (REG reg)
BOOL REG_is_flags_any_size_type (REG reg)
BOOL REG_is_status_flags_type (REG reg)
BOOL REG_is_app_status_flags_type (REG reg)
BOOL REG_is_df_flag_type (REG reg)
BOOL REG_is_app_df_flag_type (REG reg)
BOOL REG_is_any_flags_type (REG reg)
BOOL REG_is_any_pin_flags (REG reg)
BOOL REG_is_any_app_flags (REG reg)
REG REG_get_status_flags_reg_of_type (REG reg)
REG REG_get_df_flag_reg_of_type (REG reg)
REG REG_get_full_flags_reg_of_type (REG reg)
BOOL REG_is_stackptr_type (REG reg)
BOOL REG_is_representative_reg (REG reg)
BOOL REG_is_x87_reg (REG reg)
BOOL REG_is_pin_inst (REG reg)
BOOL REG_is_buffer (REG reg)
BOOL REG_is_inst_scratch (REG reg)
ADDRINT REG_regSubClassBitMapTable ()
ADDRINT REG_regDefTable ()
BOOL REG_is_pin_tmp (REG reg)
REG REG_INVALID ()
BOOL REG_valid (REG reg)
UINT32 REG_SpilledSize (const REG reg)
UINT32 REG_SpilledAlignment (const REG reg)
REG REG_PinToMachine (const REG reg, BOOL strict)
REG REG_MachineToPin (const REG reg)
BOOL REG_is_pin64 (REG reg)
BOOL REG_RequiresRex (const REG reg)
REGWIDTH REG_WidthOfGr (REG reg)
REGWIDTH REGWIDTH_FromByteWidth (UINT32 byteWidth)
INT32 BitWidth_FromREGWIDTH (REGWIDTH regWidth)
BOOL REG_needs_identical_phys_reg (REG vreg)
LOCALFUN REG REG_DetermineLastSupportedXmm ()
REG REG_LastSupportedXmm ()
LOCALFUN REG REG_DetermineLastSupportedYmm ()
REG REG_LastSupportedYmm ()
LOCALFUN REG REG_DetermineLastSupportedZmm ()
REG REG_LastSupportedZmm ()
LOCALFUN REG REG_DetermineLastSupportedPinXmm ()
REG REG_LastSupportedPinXmm ()
LOCALFUN REG REG_DetermineLastSupportedPinYmm ()
REG REG_LastSupportedPinYmm ()
LOCALFUN REG REG_DetermineLastSupportedPinZmm ()
REG REG_LastSupportedPinZmm ()
BOOL REG_IsVectorRegSupported (const REG reg)
UINT32 REG_Size (REG reg)
REG REG_FullRegName (const REG reg)
string REG_StringShort (REG reg)
BOOL REG_SameType (const REG vreg, const REG preg)
REG REG_IdentityCopy (const REG reg)
REG REG_SpillPtr ()
REG REG_PinToMachineAndSpillPtr (const REG reg, BOOL strict)
UINT32 REG_SizeFromREGWIDTH (REGWIDTH width)
INT32 REG_NmCondCallThenExtraReadRegs ()
INT32 REG_NmCondCallThenExtraWriteRegs ()
REG REG_GetCondCallExtraRegRead (INT32 index)
REG REG_GetCondCallExtraRegWritten (INT32 index)
BOOL REG_is_Half16 (const REG reg)
REGWIDTH REG_Width (REG reg)
BOOL REG_is_Half32 (const REG reg)
BOOL REG_is_Lower8 (const REG reg)
BOOL REG_is_Upper8 (const REG reg)
BOOL REG_is_Any8 (const REG reg)
REG REG_Half16 (const REG reg, const BOOL must_success)
REG REG_Half32 (const REG reg, const BOOL must_success)
REG REG_Lower8 (const REG reg, const BOOL must_succeed)
REG REG_Upper8 (const REG reg, const BOOL must_succeed)
REG REG_Xmm (const REG reg, const BOOL must_succeed)
REG REG_Ymm (const REG reg, const BOOL must_succeed)
BOOL REG_is_partialreg (const REG reg)
VOID SanityCheckPartialRegisters ()
VOID REG_SetHalf16 (ADDRINT &fullvalue, ADDRINT half16)
VOID REG_SetLower8 (ADDRINT &fullvalue, ADDRINT lower8)
VOID REG_SetUpper8 (ADDRINT &fullvalue, ADDRINT upper8)

Variables

LOCALCONST INT32 MEMORY_CHUNK_ALLOCATION_SIZE = GetMemoryAllocationGranularity()
LOCALCONST PIN_ERROR_DESCRIPTOR PinErrorDescriptors []
LOCALCONST string ArgumentNumber []
LOCALVAR PINVM::PINSYNC_SAFEPOD_LOCK MessageLock
LOCALVAR PIN_STATUS PinStatus = {PIN_LOAD_STATUS_INJECTOR, PIN_LOAD_STATUS_INJECTOR}
LOCALVAR STAT_TIMER AppTimer
GLOBALCONST TLS_KEY INVALID_TLS_KEY = (-1)
LOCALVAR BOOL Address0x = false
LOCALVAR const CHAR HexTab [] = "0123456789abcdef"
GLOBALCONST XSAVE_LAYOUT FPSTATE_layout
LOCALVAR BOOL cpuSupportsCMOV = Cpu().Supports(CPU_FEATURE_CMOV)
LOCALVAR BOOL cpuSupportsLahfSahf = Cpu().Supports(CPU_FEATURE_LAHF_SAHF)
LOCALVAR BOOL cpuSupportsAVX = Cpu().Supports(CPU_FEATURE_AVX)
LOCALVAR BOOL cpuSupportsAVX2 = Cpu().Supports(CPU_FEATURE_AVX2)
LOCALVAR BOOL cpuSupportsAVX512F = Cpu().Supports(CPU_FEATURE_AVX512F)
LOCALVAR BOOL cpuSupportsAVX512BW = Cpu().Supports(CPU_FEATURE_AVX512BW)
GLOBALCONST ADDRINT AC_FLAG_BIT = 0x40000
GLOBALCONST ADDRINT NUM_PHYSICAL_REGS = REG_PHYSICAL_INTEGER_END - REG_PHYSICAL_INTEGER_BASE + 1
GLOBALCONST ADDRINT NUM_SCRATCH_REGS = REG_INST_SCRATCH_LAST - REG_INST_SCRATCH_BASE + 1
GLOBALCONST ADDRINT NUM_SPECIAL_REGS = 2 + NUM_SCRATCH_REGS
GLOBALCONST ADDRINT NUM_CONTEXT_INT_REGS = NUM_PHYSICAL_REGS + NUM_SPECIAL_REGS
GLOBALCONST ADDRINT NUM_CONTEXT_REGS = REG_LAST_CONTEXT_REG + 1
GLOBALCONST ADDRINT ARCH_STATE_SIZE
GLOBALCONST UINT32 NUM_BUFFER_REGS = REG_BUF_LAST - REG_BUF_BASE0 + 1
const REGDEF_ENTRY _regDefTable []
GLOBALCONST UINT32 OPCODE_TABLE_NREADS = (11)
GLOBALCONST UINT32 OPCODE_TABLE_NWRITES = (9)
GLOBALCONST REG_CLASS_BITS REGCBIT_APP_FLAGS
GLOBALCONST REG_CLASS_BITS REGCBIT_PIN_FLAGS
GLOBALCONST REG_CLASS_BITS REGCBIT_PARTIAL
GLOBALCONST REG_SUBCLASS_BITS REGSBIT_PIN_INST_ALL
GLOBALCONST REG_SUBCLASS_BITS REGSBIT_PIN_SCRATCH_ALL
GLOBALCONST REG_SUBCLASS_BITS REGSBIT_STACKPTR_ALL
GLOBALCONST UINT32 PIN_INFINITE_TIMEOUT = static_cast<UINT32>(-1)
GLOBALCONST UINT32 PIN_MAX_THREADS = 2048


Detailed Description

This file defines an object which collects statistics about the various ATOMIC objects.


Typedef Documentation

typedef BOOL(* LEVEL_BASE::MESSAGE_CALLBACK)(const string &message, PIN_ERRTYPE type, INT32 userType, INT32 severity, INT32 numArgs, va_list ap)
 

A call-back function that is called whenever a MESSAGE_TYPE object prints a message.

Parameters:
[in] messageName Name of the MESSAGE_TYPE object. This is empty for messages printed via PrintMessageAndExit().
[in] message The text of the message.
[in] type The type of the message.
[in] ap A variable list of additional arguments for the message.
Returns:
When TRUE is returned, the message is also printed to the console if the MESSAGE_TYPE would normally do this. When FALSE is returned, the message is not printed to the console.

typedef STAT_FLT64 LEVEL_BASE::STAT1
 

FLT64 single value stat.

typedef STAT_SINGLE<FLT32> LEVEL_BASE::STAT_FLT32
 

FLT32 single value stat.

typedef STAT_SINGLE<FLT64> LEVEL_BASE::STAT_FLT64
 

FLT64 single value stat.

typedef STAT_INTEGRAL<INT64> LEVEL_BASE::STAT_INT64
 

INT64 single value stat.

typedef STAT_INTEGRAL<SIZE> LEVEL_BASE::STAT_SIZE
 

SIZE single value stat.

typedef STAT_INTEGRAL<UINT32> LEVEL_BASE::STAT_UINT32
 

UINT32 single value stat.

typedef STAT_INTEGRAL<UINT64> LEVEL_BASE::STAT_UINT64
 

UINT64 single value stat.


Enumeration Type Documentation

enum LEVEL_BASE::CPU_FEATURE
 

Types of CPU features

enum LEVEL_BASE::CPU_XFEATURE
 

These values specify processor states that are enabled on the processor. They are related to parts of the extended state that should be saved/restored by XSAVE/XRSTORE instructions. See IA-32 manual, vol.3, section 2.6. and vol 2B. XSAVE/XRSTOR

enum LEVEL_BASE::CPU_XFEATURE_BIT
 

Bits of the XFEATURE_ENABLED_MASK in the extended control register XCR0. These bits specify processor states that are enabled on the processor. A combination of these bits also specifies which part of the extended state should be saved/restored by XSAVE/XRSTORE instructions. See IA-32 manual, vol.3, section 2.6. and vol 2B. XSAVE/XRSTOR

enum LEVEL_BASE::LOGTYPE
 

Type that represents where to put the log.

Enumerator:
LOGTYPE_CONSOLE  log only to the console
LOGTYPE_LOGFILE  log only to the log file
LOGTYPE_CONSOLE_AND_LOGFILE  log to both the log file and console

enum LEVEL_BASE::PIN_LOAD_STATUS
 

this reflects the state of the pin process which is part of the application process. There maybe another pin process, the injector. The state of this latter process will always be PIN_LOAD_STATUS_INJECTOR.

Enumerator:
PIN_LOAD_STATUS_INJECTOR  initial state on virgin pin injecting process
PIN_LOAD_STATUS_ATTACHED  the application is running under pin control
PIN_LOAD_STATUS_CLEAR  cannot read this variable from remote process
PIN_LOAD_STATUS_CHILD_RUNS_APP  pin forks child who execs app (-injection child)
PIN_LOAD_STATUS_PARENT_RUNS_APP  parent execs app. child ptraces (-injection parent)
PIN_LOAD_STATUS_SELF_RUNS_APP  pin will load the app manually (-injection self)
PIN_LOAD_STATUS_DETACHED_LITE  pin has been detached but its memory has not been freed
PIN_LOAD_STATUS_DETACHED_FULL  pin has been detached and almost all pin memory has been freed

enum LEVEL_BASE::REGALLOC_HINT_TYPE
 

Types of hints for guiding the register allocator. They need to be defined in level_base as they are used in val.C

enum LEVEL_BASE::STAT_TYPE
 

Types of STAT's

Functions that need to iterate over all stats can use this to determine the type

Enumerator:
STAT_TYPE_INVALID  Invalid.
STAT_TYPE_SINGLE  Simple stat with a single value.
STAT_TYPE_SD  Holds static and dynamic count.
STAT_TYPE_BA  Holds a before and after count.
STAT_TYPE_NORM  Holds a count normalized to another stat, displayed as a ratio.
STAT_TYPE_DIST  Holds a distribution.


Function Documentation

VOID* LEVEL_BASE::Addrint2VoidStar ADDRINT  addr  ) 
 

Convert ADDRINT to "void *"

string LEVEL_BASE::AssertString const char *  fileName,
const char *  functionName,
unsigned  line,
const std::string &  message
 

Create a string for an assertion failure.

Parameters:
[in] fileName Name of the file containing the assertion failure or the empty string.
[in] functionName Name of the function containing the assertion failure.
[in] line Line number of the assertion failure.
[in] message Message describing the failure.

string LEVEL_BASE::Basename const string &  path  ) 
 

Strip the path information

UINT32 LEVEL_BASE::BitCount ADDRINT  val  ) 
 

popcount/bitcount code using the usual trick

INT32 LEVEL_BASE::BitWidth_FromREGWIDTH REGWIDTH  regWidth  ) 
 

return the width in bits given the REGWIDTH

VOID LEVEL_BASE::BreakMe  ) 
 

x

BOOL LEVEL_BASE::CanUseCMOV  ) 
 

Returns:
TRUE, if pin can use CMOV instructions

const string& LEVEL_BASE::CommitCounter  ) 
 

Returns the number of commits in the current branch with an adjustment of 90000 to differentiate from SVN revisions. This is not a unique identifier of a Pin version, it may appear in multiple branches. For a full-blown version identifier, this number should be combined with the major and minor numbers (see PinVersion). Example: pin-3.3-98765: 8765 commits in the Pin 3.3 branch (since the beginning of time). pin-3.4-98765: 8765 commits in the Pin 3.4 branch (since the beginning of time). Alternatively one can use the git commit hash as a truly unique identifier.

LOCALFUN const string& LEVEL_BASE::CopyRight  ) 
 

Returns Pin's copyright string.

CPU_INFO& LEVEL_BASE::Cpu  ) 
 

Return reference to the CPU_INFO instance.

BOOL LEVEL_BASE::CpuSupportsLahfSahf  ) 
 

Returns:
TRUE if this CPU supports lahf/sahf instructions

CHAR* LEVEL_BASE::CreateTmpFileName const CHAR *  fnameTemplate  ) 
 

Create a temporary file name

LOCALFUN VECTOR_REGISTER_SET LEVEL_BASE::DetermineVectorRegisterSet  ) 
 

Returns:
Returns the widest register set supported by the host CPU.

UINT32 LEVEL_BASE::DivZero UINT32  x  ) 
 

x

BOOL LEVEL_BASE::EndsWith const CHAR *  in,
const CHAR *  post
 

Find if string ends with another string

Parameters:
[in] in - input string.
[in] post - the postfix the we check
Returns:
TRUE/FALSE

VOID* LEVEL_BASE::FunctionCodeAddress void(*)()  fp  ) 
 

Returns:
Address of the code, given a function pointer

CHAR* LEVEL_BASE::GetAppCmdLine const CHAR *  pinCmdLine  ) 
 

Given pin's command line, return substring containing application's command line.

Parameters:
[in] pinCmdLine command line of pin exe process.
Returns:
pointer to substring containing application's command line; NULL, if application's command line is not found

CHAR* LEVEL_BASE::GetCmdArg const CHAR *  cmdPtr,
BOOL  isFile,
CHAR *  buf,
size_t  bufSize,
size_t *  pArgSize,
const CHAR **  pNextPtr
 

Given a command line (sub)string, find and parse its first argument. Parsing rules (see MS CRT): File names =========== Quoted string -> non-quoted string (quotes are not copied)

Regular argument ================ 2N backslashes + " -> N backslashes + begin/end quoted string (quote is not copied) 2N+1 backslashes + " -> N backslashes + literal " " + " in a quoted string -> single literal " all other combinations of symbols are copied as is

Parameters:
[in] cmdPtr pointer to the command line (sub)string
[in] isFile TRUE - use parsing rules for file name FALSE - use parsing rules for regular argument
[out] buf buffer that receives argument after parsing. If this parameter is NULL, the argument is not copied. If the buffer is too small, the terminating NULL is not copied into the buffer.
[in] bufSize size of the buffer; ignored if <buf> is NULL.
[out] pArgSize pointer to variable that receives size of the argument to be copied into the buffer, not including terminating NULL. If this parameter is NULL, the argument size is not returned. Otherwise, the size value is returned even if <buf> is NULL.
[out] pNextPtr pointer to variable that receives pointer to the command line substring following the found attribute. If this parameter is NULL, the pointer is not returned.
Returns:
pointer to the first argument found in the specified command line (sub)string or NULL.

const CHAR* LEVEL_BASE::GetEnvFromArray const CHAR *  envArray[],
const CHAR *  name
 

Find value of environment variable

ADDRINT LEVEL_BASE::GetPageOfAddr ADDRINT  addr  ) 
 

Get the address of the page that addr is in

const VOID* LEVEL_BASE::GetSp  ) 
 

Returns:
current stack pointer

BOOL LEVEL_BASE::HasBaseName const char *  fileName,
const char *  baseNameToCheckFor
 

Determine if the fileName has the BaseName baseNameToCheckFor On Windows comparison is case-insensitive, others are case sensitive

Parameters:
[in] fileName The file name that is to be checked
[in] baseNameToCheckFor Check if the file name has this name as it's filename
  • e.g. "kernel32.dll"
Returns:
true if the file name has specified baseNameToCheckFor as it's base name

template<typename T>
GLOBALTEMPLATEFUN UINT32 LEVEL_BASE::HashData UINT32  oldHash,
const T &  data
[inline]
 

Function to incrementally construct a hash value.

Parameters:
[in] prevHash Previous hash value (or zero)
[in] data New data item to include in hash value.
Returns:
Returns the new hash value.

GLOBALCFUN ADDRINT LEVEL_BASE::HaveAvx2Support  ) 
 

Returns:
TRUE if this CPU supports AVX2 and Pin is prepared to support AVX2
Note:
it is called from assembly routines also - so it is a GLOBALCFUN

GLOBALCFUN ADDRINT LEVEL_BASE::HaveAvx512BWSupport  ) 
 

Returns:
TRUE if this CPU supports AVX512 Byte and Word instructions and Pin is prepared to support AVX512
Note:
it may be called from assembly routines also - so it is a GLOBALCFUN

GLOBALCFUN ADDRINT LEVEL_BASE::HaveAvx512FSupport  ) 
 

Returns:
TRUE if this CPU supports AVX512 foundation and Pin is prepared to support AVX512
Note:
it may be called from assembly routines also - so it is a GLOBALCFUN

GLOBALCFUN ADDRINT LEVEL_BASE::HaveAvxSupport  ) 
 

Returns:
TRUE if this CPU supports AVX and Pin is prepared to support AVX
Note:
it is called from assembly routines also - so it is a GLOBALCFUN

VOID LEVEL_BASE::InstallSignalHandlers  ) 
 

install signal handler for SIGSEGV,SIGBUS,SIGILL that will behave like an assert

template<UINT32 size>
GLOBALTEMPLATEFUN UINT32 LEVEL_BASE::internalHashData UINT32  prevHash,
const CHAR *  bytes
 

Internal helper for HashData().

template<>
GLOBALTEMPLATEFUN UINT32 LEVEL_BASE::internalHashData< 1 > UINT32  prevHash,
const CHAR *  bytes
[inline]
 

Specialization for optimization (1 byte data size).

template<>
GLOBALTEMPLATEFUN UINT32 LEVEL_BASE::internalHashData< 2 > UINT32  prevHash,
const CHAR *  bytes
[inline]
 

Specialization for optimization (2 byte data size).

template<>
GLOBALTEMPLATEFUN UINT32 LEVEL_BASE::internalHashData< 4 > UINT32  prevHash,
const CHAR *  bytes
[inline]
 

Specialization for optimization (4 byte data size).

template<>
GLOBALTEMPLATEFUN UINT32 LEVEL_BASE::internalHashData< 8 > UINT32  prevHash,
const CHAR *  bytes
[inline]
 

Specialization for optimization (8 byte data size).

template<typename T>
GLOBALTEMPLATEFUN T* LEVEL_BASE::IntToPointer ADDRINT  addr  ) 
 

Convert an ADDRINT to a pointer.

template<typename T>
GLOBALTEMPLATEFUN BOOL LEVEL_BASE::IsPowerOf2 value  ) 
 

Determine whether a value is a power of 2

Parameters:
[in] value any input value
Returns:
true if value is a power of 2

string LEVEL_BASE::Joinpath string  s1,
string  s2
 

Concatenate two strings with a path delimiter

UINT64 LEVEL_BASE::KiloBytesUsed  ) 
 

KiloBytes used by program according to /proc/self/status

KNOB<BOOL> LEVEL_BASE::KnobAllowMt KNOB_MODE_WRITEONCE  ,
"user"  ,
"mt"  ,
"1"  ,
"Allow multithreaded programs" 
 

Allow multithreading. When the automatic cache flush is implemented, we can delete this

KNOB<BOOL> LEVEL_BASE::KnobAppendLogFile KNOB_MODE_WRITEONCE  ,
"supported"  ,
"append_logfile"  ,
"0"  ,
"Append to the end of the log file if it already exists" 
 

Indicates that new log messages should be appended to the end of the log file if it already exists. This is particularly useful on Unix when using -follow_execv because the log messages after the exec are appended to any messages that happen before the exec.

KNOB<UINT32> LEVEL_BASE::KnobAttachToProcessPid KNOB_MODE_WRITEONCE  ,
"user"  ,
"pid"  ,
"0"  ,
"Attach to process with PID" 
 

pin attach/detach knobs

KNOB<BOOL> LEVEL_BASE::KnobDebugInstrumentedProcesses KNOB_MODE_WRITEONCE  ,
"user"  ,
"debug_instrumented_processes"  ,
"0"  ,
"Print message to allow debugger attach to instrumented processes" 
 

Pop-up debug message to allow debugger attach to instrumented processes. In follow child scenario, active only if parent is being debugged

KNOB<BOOL> LEVEL_BASE::KnobDetachReattachActive KNOB_MODE_WRITEONCE  ,
"user"  ,
"detach_reattach"  ,
"0"  ,
"Allow detach and reattach in probe mode" 
 

pin attach/detach knobs

KNOB<string> LEVEL_BASE::KnobErrorFile KNOB_MODE_WRITEONCE  ,
"user"  ,
"error_file"  ,
""  ,
"The error file name" 
 

specifies the error file name.

KNOB<BOOL> LEVEL_BASE::KnobFollowChild KNOB_MODE_WRITEONCE  ,
"user"  ,
"follow_execv"  ,
"0"  ,
"Execute with Pin all processes spawned by execv class system calls" 
 

Should the VM follow spawned processes?

KNOB<BOOL> LEVEL_BASE::KnobHelp KNOB_MODE_WRITEONCE  ,
"user"  ,
"help"  ,
"0"  ,
"Print help message" 
 

Print help message

KNOB<BOOL> LEVEL_BASE::KnobIFeelLucky KNOB_MODE_WRITEONCE  ,
"user"  ,
"ifeellucky"  ,
"0"  ,
"skip warning message for unsupported platforms and convert some errors to warnings" 
 

Knob for skipping a warning message about unsupported platforms; It also converts some error messages to warnings to try to allow further progress.

KNOB<BOOL> LEVEL_BASE::KnobLateInjection KNOB_MODE_WRITEONCE  ,
"supported"  ,
"late_injection"  ,
"0"  ,
"Late injection (after initialization APC) on Windows" 
 

Late injection vs. early injection

KNOB<string> LEVEL_BASE::KnobLogFile KNOB_MODE_WRITEONCE  ,
"user"  ,
"logfile"  ,
"pin.log"  ,
"The log file path and file name" 
 

specifies the log file name.

KNOB<string> LEVEL_BASE::KnobMesgOff KNOB_MODE_APPEND  ,
"supported:message"  ,
"mesgoff"  ,
""  ,
"disable given message type" 
 

disable specific message type

KNOB<string> LEVEL_BASE::KnobMesgOn KNOB_MODE_APPEND  ,
"supported:message"  ,
"mesgon"  ,
""  ,
"enable given message type" 
 

enable specific message type

KNOB<BOOL> LEVEL_BASE::KnobSeparatelyHandledXmm KNOB_MODE_WRITEONCE  ,
"supported"  ,
"separately_handled_xmm"  ,
"1"  ,
"separtely handled xmm" 
 

Knob to control the handling of xmm regs as separately-handled-partial-regs when Pin is running on a system with AVX

KNOB<UINT32> LEVEL_BASE::KnobSigChildHandler KNOB_MODE_WRITEONCE  ,
"internal"  ,
"sigchld_handler"  ,
"0"  ,
"PID of waiting injector process" 
 

parent injector process that waits for injection completion

KNOB<BOOL> LEVEL_BASE::KnobSlowAsserts KNOB_MODE_WRITEONCE  ,
"user&pintool"  ,
"slow_asserts"  ,
"0"  ,
"Perform expensive sanity checks" 
 

Knob for deciding whether using expensive sanity checks.

KNOB<BOOL> LEVEL_BASE::KnobStatistics KNOB_MODE_WRITEONCE  ,
"supported:stat"  ,
"statistic"  ,
"0"  ,
"print general statistics" 
 

Print general statistic info

KNOB<BOOL> LEVEL_BASE::KnobUniqueErrorFile KNOB_MODE_WRITEONCE  ,
"user"  ,
"unique_error_file"  ,
"0"  ,
"The error file name will contain the pid" 
 

indicates that the pid should be added to the error file name.

KNOB<BOOL> LEVEL_BASE::KnobUniqueLogFiles KNOB_MODE_WRITEONCE  ,
"user"  ,
"unique_logfile"  ,
"0"  ,
"The log file names will contain the pid" 
 

indicates that the pid should be added to the log file name.

KNOB<BOOL> LEVEL_BASE::KnobVersion KNOB_MODE_WRITEONCE  ,
"user"  ,
"version"  ,
"0"  ,
"Print version message" 
 

Print version message

KNOB<UINT32> LEVEL_BASE::KnobWaitingInjector KNOB_MODE_WRITEONCE  ,
"internal"  ,
"waiting_injector"  ,
"0"  ,
"PID of waiting injector process" 
 

parent injector process that waits for injection completion

KNOB<UINT32> LEVEL_BASE::KnobWaitingProcess KNOB_MODE_WRITEONCE  ,
"internal"  ,
"waiting_process"  ,
"0"  ,
"Attach to waiting process with PID" 
 

pin attach/detach knobs

const string LEVEL_BASE::Line1 80  ,
'#' 
 

line of 80 '#' characters

const string LEVEL_BASE::Line2 80  ,
= '
 

line of 80 '=' characters

const string LEVEL_BASE::Line3 80  ,
'-' 
 

line of 80 '-' characters

const string LEVEL_BASE::Line4 80  ,
'.' 
 

line of 80 '.' characters

string LEVEL_BASE::LoadStatusString PIN_LOAD_STATUS  load_status  ) 
 

x

MemRange LEVEL_BASE::MemPageRange const VOID *  addr  ) 
 

Get the page that contains the specified address

Parameters:
[in] addr address inside the requested page
Returns:
one-page range that contains the specified address

MemRange LEVEL_BASE::MemPageRange ADDRINT  addr  ) 
 

Get the page that contains the specified address

Parameters:
[in] addr address inside the requested page
Returns:
one-page range that contains the specified address

string LEVEL_BASE::MemRangeToString const MemRange &  range  ) 
 

Returns:
string representation of the specified memory range

MESSAGE_TYPE_ALWAYS_ON LEVEL_BASE::MessageTypeAssert "assert"  ,
"A: "  ,
true  ,
true  ,
false  ,
LOGTYPE_CONSOLE_AND_LOGFILE  ,
"assert" 
 

Assert message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeConsole "console"  ,
"C: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE  ,
"console" 
 

Console message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeConsoleNoPrefix "console_noprefix"  ,
""  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE  ,
"console" 
 

Console message object - No prefix

MESSAGE_TYPE LEVEL_BASE::MessageTypeCriticalError "critical_error"  ,
"E: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE_AND_LOGFILE  ,
"errors" 
 

Error message object for fatal errors that require post-logging handling. These errors do not cause the process termination in the MESSAGE_TYPE::Message() function.

MESSAGE_TYPE LEVEL_BASE::MessageTypeDebug "debug"  ,
"D: "  ,
false  ,
false  ,
false  ,
false  ,
LOGTYPE_CONSOLE  ,
"generic debug" 
 

Debug message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeError "error"  ,
"E: "  ,
true  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE_AND_LOGFILE  ,
"errors" 
 

Error message object (terminates)

MESSAGE_TYPE LEVEL_BASE::MessageTypeInfo "info"  ,
"I: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE  ,
"info" 
 

Info message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeKnown "known"  ,
"K: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE  ,
"known problem" 
 

Known-warning message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeLog "log"  ,
""  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_LOGFILE  ,
"generic log" 
 

Log message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeNonFatalError "non_fatal_error"  ,
"NFE: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE_AND_LOGFILE  ,
"errors" 
 

Error message object for non-fatal error.

MESSAGE_TYPE LEVEL_BASE::MessageTypeOpportunity "opportunity"  ,
"O: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE  ,
"generic optimization opportunity" 
 

Optimization opportunity message object

MESSAGE_TYPE LEVEL_BASE::MessageTypePhase "phase"  ,
"P: "  ,
false  ,
false  ,
true  ,
true  ,
LOGTYPE_CONSOLE  ,
"phase" 
 

Phase message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeStats "stats"  ,
"S: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_CONSOLE  ,
"statistic" 
 

Statistcis message object

MESSAGE_TYPE LEVEL_BASE::MessageTypeWarning "warning"  ,
"W: "  ,
false  ,
false  ,
true  ,
false  ,
LOGTYPE_LOGFILE  ,
"warnings" 
 

Warning message object

UINT64 LEVEL_BASE::MilliSecondsElapsed  ) 
 

MilliSeconds elapsed since last invocation of this function

REG LEVEL_BASE::operator++ REG r  ) 
 

reg++ is convenient for loops over registers

KNOB<string> LEVEL_BASE::P32Knob KNOB_MODE_WRITEONCE  ,
"user"  ,
"p32"  ,
""  ,
"Specify Pin binary for IA-32 architecture" 
 

Specify Pin binary for 32-bit applications

KNOB<string> LEVEL_BASE::P64Knob KNOB_MODE_WRITEONCE  ,
"user"  ,
"p64"  ,
""  ,
"Specify Pin binary for Intel(R) 64 architecture" 
 

Specify Pin binary for 64-bit (IA32E) applications

const char* LEVEL_BASE::PinCommitHash  ) 
 

Returns the git commit hash of the current (unmodified) source code.

GLOBALDLLCFUN const char* LEVEL_BASE::PinCommitHashC  ) 
 

Returns the git commit hash of the current (unmodified) source code.

C-style version of this function.

PIN_LOAD_STATUS LEVEL_BASE::PinStatusGetInjectionType  ) 
 

Return the type of injection used by Pin

PIN_LOAD_STATUS LEVEL_BASE::PinStatusGetLoadStatus  ) 
 

x

VOID LEVEL_BASE::PinStatusSetLoadStatus PIN_LOAD_STATUS  ls  ) 
 

x

string LEVEL_BASE::PinStatusString PIN_STATUS *  ps  ) 
 

x

template<typename T>
GLOBALTEMPLATEFUN ADDRINT LEVEL_BASE::PointerToInt const T *  ptr  ) 
 

Convert a pointer to an ADDRINT.

const string& LEVEL_BASE::PrintablePinVersion  ) 
 

Returns a fully descriptive Pin version and copyright notice.

ADDRINT LEVEL_BASE::ProgramEntry const ImageLoaderInfo *  mainImage,
const ImageLoaderInfo *  loader
 

Return the entry point of a program (either that of the main image or of the dynamic loader)

GLOBALTEMPLATEFUN const T * LEVEL_BASE::PtrAtOffset const VOID *  ptr,
size_t  offset
 

Return const pointer whose offset, in bytes, from <ptr> is <offset>

GLOBALTEMPLATEFUN T * LEVEL_BASE::PtrAtOffset VOID *  ptr,
size_t  offset
 

Return pointer whose offset, in bytes, from <ptr> is <offset>

size_t LEVEL_BASE::PtrDiff const VOID *  ptr1,
const VOID *  ptr2
 

Return offset, in bytes, of <ptr1> from <ptr2>

VOID LEVEL_BASE::PullinPinMalloc  ) 
 

A function calling all malloc-related functions. Calling PullinPinMalloc() in pin and pinclient forces the dynamic loader to pull in the Pin's malloc.

VOID* LEVEL_BASE::PushAddrintToStack VOID *  stack,
ADDRINT  value
 

Push ADDRINT value into stack and return updated value of top of stack

Parameters:
[in] stack top of stack
[in] value value to be pushed
Returns:
updated value of top of stack

template<typename T>
GLOBALTEMPLATEFUN VOID* LEVEL_BASE::PushDataToStack VOID *  stack,
const T *  data,
size_t  alignment = 1,
size_t  size = sizeof(T)
 

Push data into stack and return updated value of top of stack the stack is growing to the lower addresses

Parameters:
[in] stack top of stack
[in] data pointer to the data to be copied
[in] alignment new value of top of stack suppose to be aligned on "alignment" value, in bytes. the value has to be power of 2
[in] size size of the data, in bytes
Returns:
updated value of top of stack

void LEVEL_BASE::RangeCheck const UINT32  value,
const UINT32  bits
 

REG LEVEL_BASE::REG_GetCondCallExtraRegRead INT32  index  ) 
 

No such regs - only write regs

REG LEVEL_BASE::REG_GetCondCallExtraRegWritten INT32  index  ) 
 

Will write the REG_PIN_DF_FLAGS

REG LEVEL_BASE::REG_Half16 const REG  reg,
const BOOL  must_success
 

Return the lower 16-bit version of reg

REG LEVEL_BASE::REG_Half32 const REG  reg,
const BOOL  must_success
 

Return the lower 32-bit version of reg

BOOL LEVEL_BASE::REG_is_in_X87 REG  reg  ) 
 

Returns:
true if reg is ST0-7, MM0-7(MMX) or ST control/status register

BOOL LEVEL_BASE::REG_IsVectorRegSupported const REG  reg  ) 
 

Returns:
TRUE iff the given register is a vector register i.e. xmm/ymm/zmm and it is supported on the current CPU.

REG LEVEL_BASE::REG_LastSupportedPinXmm  ) 
 

Returns:
the highest Pin xmm register supported on the current CPU

REG LEVEL_BASE::REG_LastSupportedPinYmm  ) 
 

Returns:
the highest Pin ymm register supported on the current CPU

REG LEVEL_BASE::REG_LastSupportedPinZmm  ) 
 

Returns:
the highest Pin zmm register supported on the current CPU

REG LEVEL_BASE::REG_Lower8 const REG  reg,
const BOOL  must_succeed
 

Return the lower 8-bit version of reg

BOOL LEVEL_BASE::REG_needs_identical_phys_reg REG  vreg  ) 
 

Return TRUE iff the vreg is required to be allocated to it's corresponding preg

INT32 LEVEL_BASE::REG_NmCondCallThenExtraReadRegs  ) 
 

No such regs - only write regs

INT32 LEVEL_BASE::REG_NmCondCallThenExtraWriteRegs  ) 
 

Will write the REG_PIN_DF_FLAGS

REG LEVEL_BASE::REG_PinToMachine const REG  reg,
BOOL  strict
 

Return the identity copy of reg. If it is not a Pin reg and strict is not set, its physical copy is simply reg itself. If strict is set, its physical copy is REG_INVALID().

BOOL LEVEL_BASE::REG_RequiresRex const REG  reg  ) 
 

Does this register require a REX prefix when encoded on Intel(R) 64 architecture?

BOOL LEVEL_BASE::REG_SameType const REG  vreg,
const REG  preg
 

Return true if reg can replace orig during register re-allocation

VOID LEVEL_BASE::REG_SetHalf16 ADDRINT &  fullvalue,
ADDRINT  half16
 

Set the bottom 16 bits of the register without changing the rest of the register's bits.

VOID LEVEL_BASE::REG_SetLower8 ADDRINT &  fullvalue,
ADDRINT  lower8
 

Set the bottom 8 bits of the register without changing the rest of the register's bits.

VOID LEVEL_BASE::REG_SetUpper8 ADDRINT &  fullvalue,
ADDRINT  upper8
 

Set the upper 8 bits (of the bottom 16) of the register without changing the rest of the register's bits. Note - All instances of upper 8 in the documentation below refers to the upper 8 bits of the lower 16.

UINT32 LEVEL_BASE::REG_SizeFromREGWIDTH REGWIDTH  width  ) 
 

return the register size in bytes given a REGWIDTH

UINT32 LEVEL_BASE::REG_SpilledAlignment const REG  reg  ) 
 

Return the size (in bytes) of the alignment of the the spill slot dedicated for reg

UINT32 LEVEL_BASE::REG_SpilledSize const REG  reg  ) 
 

Return the size (in bytes) of a spill slot dedicated for reg

REG LEVEL_BASE::REG_SpillPtr  ) 
 

The physical register assigned to hold the spill pointer

REG LEVEL_BASE::REG_Upper8 const REG  reg,
const BOOL  must_succeed
 

Return the upper 8-bit version of reg

REGWIDTH LEVEL_BASE::REG_WidthOfGr REG  reg  ) 
 

return the register width for GRs only.

REG LEVEL_BASE::REG_Xmm const REG  reg,
const BOOL  must_succeed
 

Return the xmm reg part of the ymm/zmm reg (or the xmm itself).

REG LEVEL_BASE::REG_Ymm const REG  reg,
const BOOL  must_succeed
 

Return the ymm reg part of the zmm reg (or the ymm itself).

string LEVEL_BASE::REGALLOCHINT_String const REGALLOC_HINT_TYPE  hint  ) 
 

REGWIDTH LEVEL_BASE::REGWIDTH_FromByteWidth UINT32  byteWidth  ) 
 

return the register width given a width in bytes

const string& LEVEL_BASE::ReleaseFamily  ) 
 

Returns the Pin release family number. The release family includes the initial release and all subsequent patch releases with the same major and minor numbers.

string LEVEL_BASE::ResourceInfo  ) 
 

stringified resource info for use with phase messages

template<typename T>
GLOBALTEMPLATEFUN T* LEVEL_BASE::RoundDown T *  ptr,
size_t  alignment
 

Specialization of the RoundDown function for pointer type

template<typename T>
GLOBALTEMPLATEFUN T LEVEL_BASE::RoundDown value,
size_t  alignment
 

Round integer of type <T> down to given alignment.

template<typename T>
GLOBALTEMPLATEFUN T* LEVEL_BASE::RoundDownPowerOf2 T *  ptr,
size_t  alignment
 

Specialization of the RoundDownPowerOf2 function for pointer type

template<typename T>
GLOBALTEMPLATEFUN T LEVEL_BASE::RoundDownPowerOf2 value,
size_t  alignment
 

Round integer of type <T> down to given alignment. The alignment must be power of two.

template<typename T>
GLOBALTEMPLATEFUN T LEVEL_BASE::RoundToNextPower2 value  ) 
 

Round integer of type <T> up to the next power of two.

Parameters:
[in] size the integer (in bytes).
Returns:
Returns the smallest power of two which is greater than or equal to size.

template<typename T>
GLOBALTEMPLATEFUN T* LEVEL_BASE::RoundUp T *  ptr,
size_t  alignment
 

Specialization of the RoundUp function for pointer type

template<typename T>
GLOBALTEMPLATEFUN T LEVEL_BASE::RoundUp value,
size_t  alignment
 

Round integer of type <T> up to given alignment.

template<typename T>
GLOBALTEMPLATEFUN T* LEVEL_BASE::RoundUpPowerOf2 T *  ptr,
size_t  alignment
 

Specialization of the RoundUpPowerOf2 function for pointer type

template<typename T>
GLOBALTEMPLATEFUN T LEVEL_BASE::RoundUpPowerOf2 value,
size_t  alignment
 

Round integer of type <T> up to given alignment. The alignment must be power of two.

VOID LEVEL_BASE::SanityCheckPartialRegisters  ) 
 

Ensure that we don't re-create Mantis 1903, where a register was short but not partial. This function checks that the partial register information is internally consistent.

It is called when we have the -slow_asserts flag.

VOID LEVEL_BASE::SegFault  ) 
 

x

LOCALFUN VOID LEVEL_BASE::SignalHandler int  arg  ) 
 

install signal handler for SIGSEGV,SIGBUS,SIGILL that will behave like an assert

BOOL LEVEL_BASE::SignedImmediateFits const INT64  value,
const UINT32  origSize
 

Wrapper for 3-arg SignedImmediateFits()

Parameters:
value the value to whose size we are checking
origSize where to look for the sign bit (typically 8,16,32 or 64)
Returns:
true if sign extending from origSize to extendedSize will not change value

BOOL LEVEL_BASE::SignedImmediateFits const INT64  value,
const UINT32  origSize,
const UINT32  extendedSize
 

Sign extend from origSize to extendedSize and check if it fits in a field of extendedSize

Parameters:
[in] value - value to whose size we are checking
[in] origSize - position of sign bit in value
[in] extendedSize - size extend to this size, if 0 then extendedSize is origSize

BOOL LEVEL_BASE::SlowAssertsEnabled  ) 
 

Return TRUE if slow-asserts are enabled.

string LEVEL_BASE::SplitString string *  input,
const string &  delimiter = " "
 

Split string into 2 sub strings. Example1: prefix = SplitString(input = "aaa bbb ccc", " ") -> prefix = "aaa", input = "bbb ccc" Example2: prefix = SplitString(input = "aaa", " ") -> prefix = "aaa", input = ""

Parameters:
inout] input - input string. remove prefix and set the new string into input.
[in] delimiter - delimiter
Returns:
prefix string

VOID LEVEL_BASE::StartApplicationTimer  ) 
 

Start the application timer

BOOL LEVEL_BASE::StartsWith const CHAR *  in,
const CHAR *  pre
 

Find if string starts with another string

Parameters:
[in] in - input string.
[in] pre - the prefix the we check
Returns:
TRUE/FALSE

STAT_NORM LEVEL_BASE::STAT_acquire_vm_lock_count "pin"  ,
"time_vm"  ,
"get_lock_count"  ,
""  ,
NULL 
 

A counter for the number of times acquiring the VM lock

ATOMIC_STATS LEVEL_BASE::STAT_Backoff_COMPLEXLOCK "pin"  ,
"complexlock" 
 

Exponential backoff statistics while incrementing recursive count.

STAT_UINT64 LEVEL_BASE::STAT_MaxSpins_COMPLEXLOCK "pin"  ,
"complexlock"  ,
"spins_max"  ,
"" 
 

Max number of Yield() spins for a single lock attempt.

STAT_NORM LEVEL_BASE::STAT_time_vm_enter_to_leave "pin"  ,
"time_vm"  ,
"time_in_vm"  ,
""  ,
STAT_vm_enter_count
 

The time spent in the VM including the time waiting for the VM lock

STAT_NORM LEVEL_BASE::STAT_time_vm_locked "pin"  ,
"time_vm"  ,
"time_locked"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent in the VM executing code while being locked under the VM lock

STAT_NORM LEVEL_BASE::STAT_time_vm_past_enter "pin"  ,
"time_vm"  ,
"time_in_vm_past_enter"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent in the VM excluding the time waiting for the VM lock

STAT_NORM LEVEL_BASE::STAT_time_vm_threads "pin"  ,
"time_vm"  ,
"time_all_threads"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The total time spent by all VM threads

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_EMU "pin"  ,
"time_vm"  ,
"VMSVC_EMU"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the EMU flow

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_SELF_HANDLER "pin"  ,
"time_vm"  ,
"VMSVC_SELF_HANDLER"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the SELF_HANDLER flow

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_SMC "pin"  ,
"time_vm"  ,
"VMSVC_SMC"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the SMC flow

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_XFER "pin"  ,
"time_vm"  ,
"VMSVC_XFER"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the XFER flow

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_XFER_BRIDGE "pin"  ,
"time_vm"  ,
"VMSVC_XFER_BRIDGE"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the XFER_BRIDGE flow

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_XFER_INDIRECT "pin"  ,
"time_vm"  ,
"VMSVC_XFER_INDIRECT"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the XFER_INDIRECT flow

STAT_NORM LEVEL_BASE::STAT_time_VMSVC_XFER_NATIVE "pin"  ,
"time_vm"  ,
"VMSVC_XFER_NATIVE"  ,
""  ,
STAT_time_vm_enter_to_leave
 

The time spent executing the NATIVE flow

STAT_NORM LEVEL_BASE::STAT_time_wait_for_vm_lock "pin"  ,
"time_vm"  ,
"time_wait_for_lock"  ,
""  ,
STAT_acquire_vm_lock_count
 

The time spent while waiting for the VM lock

STAT_UINT64 LEVEL_BASE::STAT_TotalAttempts_COMPLEXLOCK "pin"  ,
"complexlock"  ,
"attempts"  ,
"" 
 

Total number of attempts to acquire lock.

STAT_UINT64 LEVEL_BASE::STAT_TotalSpins_COMPLEXLOCK "pin"  ,
"complexlock"  ,
"spins_total"  ,
"" 
 

Total number of Yield() spins while waiting for lock to be free.

STAT_NORM LEVEL_BASE::STAT_vm_enter_count "pin"  ,
"time_vm"  ,
"vmenter_count"  ,
""  ,
NULL 
 

A counter for the number of times entering the VM

STAT_NORM LEVEL_BASE::STAT_WaitTime_COMPLEXLOCK "pin"  ,
"time"  ,
"complexlock_wait"  ,
""  ,
TimerApp
 

Total time waiting for all Yield() spins.

LOCALVAR STAT_NORM LEVEL_BASE::StatOtherBytes "mem"  ,
"bytes"  ,
"other"  ,
""  ,
StatRawMmapBytes,
TRUE 
 

Unattributed allocations

STAT_NORM LEVEL_BASE::StatRawMmapBytes "mem"  ,
"bytes"  ,
"RawMmap"  ,
""  ,
StatReservedBytes
 

Total net bytes allocated by RawMmap and RawMunmap. This must be global because another stats are normalized to this value. The actual value is kept as a local variable in sysfuncs_* and updated by UpdateRawMmapBytes to avoid accessing this variable before the constructor has run.

STAT_NORM LEVEL_BASE::StatReservedBytes "mem"  ,
"bytes"  ,
"Reserved"  ,
""  ,
 

Total net bytes reserved.

LOCALVAR STAT_NORM LEVEL_BASE::StatStripeBytes "mem"  ,
"bytes"  ,
"stripe"  ,
""  ,
StatRawMmapBytes
 

allocate a memory region of "size" bytes at location address

not used with the single mmap approach

VOID LEVEL_BASE::StopApplicationTimer  ) 
 

Stop the application timer

template<typename ITER, typename CONV>
GLOBALTEMPLATEFUN string LEVEL_BASE::StringSequence ITER  begin,
ITER  end,
const CONV &  conv,
const string &  delimiter = string(" ")
 

Convert the sequence [begin, end) to string. Use the <conv> object to convert the elements. Separate the elements by <delimiter>.

VECTOR_REGISTER_SET LEVEL_BASE::SupportedVectorRegisterSet  ) 
 

Returns:
The supported vector instruction set extension.

KNOB<string> LEVEL_BASE::T64Knob KNOB_MODE_WRITEONCE  ,
"user"  ,
"t64"  ,
""  ,
"Specify tool binary for Intel(R) 64 architecture" 
 

Specify Tool for 64-bit (IA32E) applications

STAT_NORM LEVEL_BASE::TimerApp "pin"  ,
"time"  ,
"total"  ,
""  ,
 

Entire time that Pin is running.

STAT_NORM LEVEL_BASE::TimerCompile "pin"  ,
"time"  ,
"Compile"  ,
""  ,
TimerVm
 

Timer for Compilation

STAT_NORM LEVEL_BASE::TimerFetchRegion "pin"  ,
"time"  ,
"FetchRegion"  ,
""  ,
TimerMakeApplication
 

Time spent fetching while MakeApplication.

STAT_NORM LEVEL_BASE::TimerMakeApplication "pin"  ,
"time"  ,
"MakeApplication"  ,
""  ,
TimerMakeRegion
 

Timer for MakeApplication

STAT_NORM LEVEL_BASE::TimerMakeRegion "pin"  ,
"time"  ,
"MakeRegion"  ,
""  ,
TimerCompile
 

Timer for compiler

STAT_NORM LEVEL_BASE::TimerVm "pin"  ,
"time"  ,
"vm"  ,
""  ,
TimerApp
 

Timer for VM

BOOL LEVEL_BASE::UnsignedImmediateFits const UINT64  value,
const UINT32  bits
 

integer bit width check

VOID LEVEL_BASE::UpdateRawMmapBytes  ) 
 

Update StatRawMmapBytes from a local variable. We can't update the stat directly in RawMmap because it might be called before the constructor for the stat has been executed.

ADDRINT LEVEL_BASE::VoidStar2Addrint VOID *  addr  ) 
 

Convert "void *" to ADDRINT

ADDRINT LEVEL_BASE::VoidStar2Addrint const VOID *  addr  ) 
 

Convert "void *" to ADDRINT.

INT64 LEVEL_BASE::VoidStar2Int VOID *  addr  ) 
 

convert "void *" to int


Variable Documentation

GLOBALCONST ADDRINT LEVEL_BASE::ARCH_STATE_SIZE
 

Initial value:

 (NUM_PHYSICAL_REGS + NUM_SPECIAL_REGS)*sizeof(ADDRINT) +
                                      (FPSTATE_SIZE // because CONTEXT size must
                                                         // be at least as big as
                                                         // CONTEXT_CANONICAL size,
                                                         // and CONTEXT_CANONICAL._fpstate is used
                                      + FPSTATE_ALIGNMENT)
Size of the CONTEXT's architectural state in bytes

LOCALCONST string LEVEL_BASE::ArgumentNumber[]
 

Initial value:

{
    "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
}

GLOBALCONST XSAVE_LAYOUT LEVEL_BASE::FPSTATE_layout
 

Initial value:

{
    sizeof(FPSTATE),    
    {
        { offsetof(FPSTATE::XSTATE, _ymmUpper),
          sizeof(((FPSTATE::XSTATE *)0)->_ymmUpper) }, 
        { offsetof(FPSTATE::VSTATE, _bndRegs) + offsetof(FPSTATE, _vstate) - offsetof(FPSTATE, _xstate),
          sizeof(((FPSTATE::VSTATE *)0)->_bndRegs) },  
        { offsetof(FPSTATE::VSTATE, _bndCSR) + offsetof(FPSTATE, _vstate) - offsetof(FPSTATE, _xstate),
          sizeof(((FPSTATE::VSTATE *)0)->_bndCSR) },   
        { offsetof(FPSTATE::VSTATE, _kmasks) + offsetof(FPSTATE, _vstate) - offsetof(FPSTATE, _xstate),
          sizeof(((FPSTATE::VSTATE *)0)->_kmasks) },   
        { offsetof(FPSTATE::VSTATE, _zmmUpper) + offsetof(FPSTATE, _vstate) - offsetof(FPSTATE, _xstate),
          sizeof(((FPSTATE::VSTATE *)0)->_zmmUpper) }, 




    }
}
XSAVE layout representing FPSTATE structure

LOCALVAR PINVM::PINSYNC_SAFEPOD_LOCK LEVEL_BASE::MessageLock
 

Lock that serializes message logging

GLOBALCONST UINT32 LEVEL_BASE::NUM_BUFFER_REGS = REG_BUF_LAST - REG_BUF_BASE0 + 1
 

Total number of buffer registers, which is also the maximum number of buf ids.

GLOBALCONST ADDRINT LEVEL_BASE::NUM_CONTEXT_INT_REGS = NUM_PHYSICAL_REGS + NUM_SPECIAL_REGS
 

Total number of integer registers in CONTEXT

GLOBALCONST ADDRINT LEVEL_BASE::NUM_CONTEXT_REGS = REG_LAST_CONTEXT_REG + 1
 

Total number of registers in CONTEXT (app registers + tool registers + special)

GLOBALCONST ADDRINT LEVEL_BASE::NUM_SPECIAL_REGS = 2 + NUM_SCRATCH_REGS
 

REG_SEG_FS_BASE and REG_SEG_GS_BASE are represented as special IA-32/Intel(R) 64 architecture registers

GLOBALCONST UINT32 LEVEL_BASE::OPCODE_TABLE_NREADS = (11)
 

GLOBALCONST UINT32 LEVEL_BASE::OPCODE_TABLE_NWRITES = (9)
 

GLOBALCONST UINT32 LEVEL_BASE::PIN_INFINITE_TIMEOUT = static_cast<UINT32>(-1)
 

Timeout interval that never elapses.

GLOBALCONST UINT32 LEVEL_BASE::PIN_MAX_THREADS = 2048
 

Maximum number of threads supported by PIN.


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