Pin
Classes | Typedefs | Enumerations | Functions | Variables
LEVEL_PINCLIENT Namespace Reference

Classes

struct  IMAGE_INIT_SESSION
struct  ImageLoadArgs
class  INSTR
class  INSTR_INFO
class  RTN_KEY
class  IMG_IDENTIFIER
struct  OUTSIDE_TARGET_MEM_RANGE
struct  OUTSIDE_TARGET
class  RTN_OUTSIDE_RANGES
class  SymbolAddressRange
struct  SymbolDebugInfo
class  IMAGE_LOAD_OP
class  IMAGE_LOAD_OP2
struct  PIN_CLIENT_MUTEX
class  REPLACEDFUN
class  CLIENT_TLS

Typedefs

typedef
LEVEL_BASE::CHILD_PROCESS_CLASS * 
CHILD_PROCESS
typedef BOOL(* FOLLOW_CHILD_PROCESS_CALLBACK )(CHILD_PROCESS childProcess, VOID *val)
typedef BOOL(* DEBUG_INTERPRETER_CALLBACK )(THREADID threadIndex, CONTEXT *ctxt, const std::string &cmd, std::string *reply, VOID *v)
typedef BOOL(* DEBUG_BREAKPOINT_CALLBACK )(ADDRINT addr, UINT size, BOOL insert, VOID *v)
typedef VOID(* IMAGECALLBACK )(IMG, VOID *)
typedef EXCEPT_HANDLING_RESULT(* INTERNAL_EXCEPTION_CALLBACK )(THREADID tid, EXCEPTION_INFO *pExceptInfo, PHYSICAL_CONTEXT *pPhysCtxt, VOID *v)
typedef TRACE_CLASS * TRACE
typedef VOID * PIN_CONFIGURATION_INFO
typedef COMPLEX_CALLBACKVAL_BASE * PIN_CALLBACK
typedef VOID(* REMOVE_INSTRUMENTATION_CALLBACK )(VOID *v)
typedef VOID(* DETACH_CALLBACK )(VOID *v)
typedef VOID(* DETACH_PROBED_CALLBACK )(VOID *v)
typedef VOID(* ATTACH_PROBED_CALLBACK )(VOID *v)
typedef VOID(* ATTACH_CALLBACK )(VOID *v)
typedef VOID(* APPLICATION_START_CALLBACK )(VOID *v)
typedef VOID(* PREPARE_FOR_FINI_CALLBACK )(VOID *v)
typedef VOID(* FINI_CALLBACK )(INT32 code, VOID *v)
typedef size_t(* FETCH_CALLBACK )(void *buf, ADDRINT addr, size_t size, EXCEPTION_INFO *pExceptInfo, VOID *v)
typedef VOID(* OUT_OF_MEMORY_CALLBACK )(size_t size, VOID *v)
typedef ADDRINT(PIN_FAST_ANALYSIS_CALL * MEMORY_ADDR_TRANS_CALLBACK )(PIN_MEM_TRANS_INFO *memTransInfo, VOID *v)
typedef VOID(* SMC_CALLBACK )(ADDRINT traceStartAddress, ADDRINT traceEndAddress, VOID *v)
typedef VOID(* FORK_CALLBACK )(THREADID threadid, const CONTEXT *ctxt, VOID *v)
typedef VOID(* THREAD_START_CALLBACK )(THREADID threadIndex, CONTEXT *ctxt, INT32 flags, VOID *v)
typedef VOID(* THREAD_ATTACH_PROBED_CALLBACK )(VOID *sigmask, VOID *v)
typedef VOID(* THREAD_DETACH_PROBED_CALLBACK )(VOID *v)
typedef VOID(* THREAD_ATTACH_CALLBACK )(THREADID threadIndex, CONTEXT *ctxt, VOID *v)
typedef VOID(* THREAD_DETACH_CALLBACK )(THREADID threadIndex, const CONTEXT *ctxt, VOID *v)
typedef VOID(* THREAD_FINI_CALLBACK )(THREADID threadIndex, const CONTEXT *ctxt, INT32 code, VOID *v)
typedef VOID(* CONTEXT_CHANGE_CALLBACK )(THREADID threadIndex, CONTEXT_CHANGE_REASON reason, const CONTEXT *from, CONTEXT *to, INT32 info, VOID *v)
typedef VOID(* SYSCALL_ENTRY_CALLBACK )(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)
typedef VOID(* SYSCALL_EXIT_CALLBACK )(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)
typedef BOOL(* INTERCEPT_SIGNAL_CALLBACK )(THREADID tid, INT32 sig, CONTEXT *ctxt, BOOL hasHandler, const EXCEPTION_INFO *pExceptInfo, VOID *v)
typedef VOID(* PROBES_INSERTED_CALLBACK )(IMG img, VOID *v)
typedef VOID *(* TRACE_BUFFER_CALLBACK )(BUFFER_ID id, THREADID tid, const CONTEXT *ctxt, VOID *buf, UINT64 numElements, VOID *v)
typedef VOID(* INS_INSTRUMENT_CALLBACK )(INS ins, VOID *v)
typedef VOID(* TRACE_INSTRUMENT_CALLBACK )(TRACE trace, VOID *v)
typedef VOID(* RTN_INSTRUMENT_CALLBACK )(RTN rtn, VOID *v)
typedef VOID(* FORK_PROBE_MODE_CALLBACK )(UINT32 childPid, VOID *v)

Enumerations

enum  UNDECORATION {
  UNDECORATION_COMPLETE,
  UNDECORATION_NAME_ONLY
}
enum  SYMBOL_INFO_MODE {
  NO_SYMBOLS = 0,
  EXPORT_SYMBOLS = (1<<0),
  DEBUG_SYMBOLS = (1<<1),
  IFUNC_SYMBOLS = (1<<2),
  DEBUG_OR_EXPORT_SYMBOLS = (DEBUG_SYMBOLS | EXPORT_SYMBOLS)
}
enum  REPLAY_MODE {
  REPLAY_MODE_NONE = 0x00,
  REPLAY_MODE_IMAGEOPS = 0x01,
  REPLAY_MODE_ALL = REPLAY_MODE_IMAGEOPS
}
enum  PROBE_MODE {
  PROBE_MODE_DEFAULT = 0,
  PROBE_MODE_ALLOW_RELOCATION = (1<<0)
}
enum  SMC_ENABLE_DISABLE_TYPE {
  SMC_ENABLE,
  SMC_DISABLE
}
enum  FPOINT {
  FPOINT_BEFORE,
  FPOINT_AFTER_IN_PARENT,
  FPOINT_AFTER_IN_CHILD
}
enum  ATTACH_STATUS {
  ATTACH_INITIATED,
  ATTACH_FAILED_DETACH
}
enum  CONDINSTSTATE {
  CONDINST_NORMAL,
  CONDINST_IF,
  CONDINST_THEN
}
enum  {
  TLS_KEY_INTERNAL_EXCEPTION,
  TLS_KEY_CLIENT_FIRST,
  TLS_KEY_CLIENT_LAST = TLS_KEY_CLIENT_FIRST + 63
}

Functions

VOID PIN_InitSymbols ()
BOOL PIN_InitSymbolsAlt (SYMBOL_INFO_MODE mode)
LOCALFUN VOID AddSym (SYM sym, IMG img, BOOL dynamic, const CHAR *sym_name, const SYMREC *rawsym, UINT32 imgsize, IADDR iaddr, SYM_IFUNC_TYPE Ifunc_type)
template<typename SYMBOL_TYPE >
LOCALTEMPLATEFUN VOID ConvertSym (SYMREC *sym_dst, const SYMBOL_TYPE *sym_src)
LOCALFUN VOID CookSymIfuncSec (IMG img, SYM ifunc_resolver, const SYMREC *symrec, SYM_RESOLVER_VS_ACTUAL_ADDRESS_IFUNC_MAP *sym_resolver_vs_actual_address_ifunc_map)
LOCALFUN BOOL GetPltSec (IMG img, SEC *plt_sec, SEC *relocation_Sec)
template<typename SYMBOL_TYPE >
LOCALTEMPLATEFUN VOID CookSymPltSec (IMG img, const SYMBOL_TYPE *array, const CHAR *string_table)
template<typename SYMBOL_TYPE >
LOCALTEMPLATEFUN VOID CookSymSec (std::set< SYM_BASIC_INFO > &symbolSet, SEC sec_symtab, SEC sec_strtab, BOOL dynamic, SYM_RESOLVER_VS_ACTUAL_ADDRESS_IFUNC_MAP *sym_resolver_vs_actual_address_ifunc_map)
LOCALFUN BOOL CompareSyms (const SYM &s1, const SYM &s2)
LOCALFUN VOID IMG_SortRegsymsByIaddr (IMG img)
OS_PROCESS_ID CHILD_PROCESS_GetId (CHILD_PROCESS childProcess)
VOID CHILD_PROCESS_GetCommandLine (CHILD_PROCESS childProcess, INT *pArgc, const CHAR *const **pArgv)
VOID CHILD_PROCESS_SetPinCommandLine (CHILD_PROCESS childProcess, INT argc, const CHAR *const *argv)
void PIN_GetSourceLocation (ADDRINT address, INT32 *column, INT32 *line, std::string *fileName)
PIN_CALLBACK PIN_AddDebugInterpreter (DEBUG_INTERPRETER_CALLBACK fun, VOID *val)
VOID PIN_RemoveDebugInterpreter (DEBUG_INTERPRETER_CALLBACK fun)
PIN_CALLBACK PIN_AddBreakpointHandler (DEBUG_BREAKPOINT_CALLBACK fun, VOID *val)
VOID PIN_RemoveBreakpointHandler (DEBUG_BREAKPOINT_CALLBACK fun)
VOID PIN_ResetBreakpointAt (ADDRINT addr)
VOID PIN_ApplicationBreakpoint (const CONTEXT *ctxt, THREADID tid, BOOL waitIfNoDebugger, const std::string &msg)
BOOL PIN_SetDebugMode (const DEBUG_MODE *mode)
DEBUG_STATUS PIN_GetDebugStatus ()
BOOL PIN_GetDebugConnectionInfo (DEBUG_CONNECTION_INFO *info)
DEBUGGER_TYPE PIN_GetDebuggerType ()
BOOL PIN_WaitForDebuggerToConnect (unsigned timeout)
BOOL PIN_GetStoppedThreadPendingToolBreakpoint (THREADID tid, std::string *msg)
BOOL PIN_ChangePendingToolBreakpointOnStoppedThread (THREADID tid, BOOL squash, const std::string &msg)
PIN_DEPRECATED_API VOID CALLBACK_SetExecutionPriority (PIN_CALLBACK callback, INT32 priority)
PIN_DEPRECATED_API INT32 CALLBACK_GetExecutionPriority (PIN_CALLBACK callback)
LOCALVAR KNOB_COMMENT KnobSymFamily ("pintool:sym","Symbols controls")
LOCALVAR KNOB< BOOL > KnobUnrestrictedRtnSize (KNOB_MODE_WRITEONCE,"pintool:sym","unrestricted_rtn_size","0","Use the unrestricted RTN size. ""When set the RTN size defined by the distance between RTN start to the beginning of next RTN.")
LOCALVAR KNOB< BOOL > KnobShortName (KNOB_MODE_WRITEONCE,"pintool:sym","short_name","0","Use the shortest name for the RTN. ""Names with version substrings are preferred over the same name without the substring.")
LOCALVAR KNOB< BOOL > KnobIgnoreDebugInfo (KNOB_MODE_WRITEONCE,"pintool:sym","ignore_debug_info","0","Ignore debug info for the image. Symbols are taken from the symbol tables.")
LOCALVAR KNOB< std::string > KnobReduceRtnSizeMode (KNOB_MODE_WRITEONCE,"pintool:sym","reduce_rtn_size_mode","auto","Mode for RTN size reduction: delete trailing instructions after RET if there is no ""jump to the rtn part after the RET. ""Possible modes are: auto/never/always")
KNOB< BOOL > KnobJitApi (KNOB_MODE_WRITEONCE,"pintool:sym","support_jit_api","0","Enables the Jitted Functions Support")
IMG IMG_Next (IMG img)
IMG IMG_Prev (IMG img)
IMG IMG_Invalid ()
BOOL IMG_Valid (IMG img)
SEC IMG_SecHead (IMG img)
SEC IMG_SecTail (IMG img)
SYM IMG_RegsymHead (IMG img)
PIN_DEPRECATED_API ADDRINT IMG_Entry (IMG img)
ADDRINT IMG_EntryAddress (IMG img)
BOOL IMG_HasProperty (IMG img, IMG_PROPERTY property)
const std::string & IMG_Name (IMG img)
ADDRINT IMG_Gp (IMG img)
ADDRINT IMG_LoadOffset (IMG img)
ADDRINT IMG_LowAddress (IMG img)
ADDRINT IMG_HighAddress (IMG img)
ADDRINT IMG_StartAddress (IMG img)
USIZE IMG_SizeMapped (IMG img)
IMG_TYPE IMG_Type (IMG img)
BOOL IMG_IsMainExecutable (IMG x)
BOOL IMG_hasLinesData (IMG x)
BOOL IMG_IsInterpreter (IMG x)
BOOL IMG_IsStaticExecutable (IMG x)
BOOL IMG_IsVDSO (IMG img)
UINT32 IMG_NumRegions (IMG img)
ADDRINT IMG_RegionHighAddress (IMG img, UINT32 n)
ADDRINT IMG_RegionLowAddress (IMG img, UINT32 n)
IMG SEC_Img (SEC sec)
SEC SEC_Next (SEC sec)
SEC SEC_Prev (SEC sec)
SEC SEC_Invalid ()
BOOL SEC_Valid (SEC x)
RTN SEC_RtnHead (SEC sec)
RTN SEC_RtnTail (SEC sec)
const std::string & SEC_Name (SEC sec)
SEC_TYPE SEC_Type (SEC sec)
BOOL SEC_Mapped (SEC sec)
const VOID * SEC_Data (SEC sec)
SEC RTN_Sec (RTN x)
RTN RTN_Next (RTN x)
RTN RTN_Prev (RTN x)
RTN RTN_Invalid ()
BOOL RTN_Valid (RTN x)
LOCALINLINE RTN_OUTSIDE_RANGESRtnOutsideRangesManager ()
LOCALFUN VOID DisassembleRegion (RTN rtn, BBL bbl, const VOID *current, const VOID *end, ADDRINT rtnStart, ADDRINT rtnEnd, ADDRINT rtnLimit, ADDRINT virtual_offset)
LOCALFUN INS DisassembleFirstIns (const VOID *current, const VOID *end, ADDRINT limit, ADDRINT virtual_offset)
LOCALFUN VOID FetchRtnIns (RTN rtn)
LOCALFUN INS FetchRtnInsFirstOnly (RTN rtn)
const std::string & RTN_Name (RTN x)
BOOL RTN_IsArtificial (RTN x)
SYM RTN_Sym (RTN x)
UINT RTN_DynamicMethodId (RTN x)
AFUNPTR RTN_Funptr (RTN x)
LOCALFUN VOID RTN_Destroy (RTN rtn)
UINT32 RTN_Id (RTN x)
INS BBL_InsHead (BBL x)
INS BBL_InsTail (BBL x)
BBL BBL_Next (BBL x)
BBL BBL_Prev (BBL x)
BOOL BBL_Valid (BBL x)
BBL_TYPE BBL_Type (BBL x)
RTN INS_Rtn (INS x)
INS INS_Next (INS x)
INS INS_Prev (INS x)
INS INS_Invalid ()
BOOL INS_Valid (INS x)
ADDRINT INS_Address (INS ins)
USIZE INS_Size (INS ins)
PIN_DEPRECATED_API ADDRINT INS_DirectBranchOrCallTargetAddress (INS ins)
ADDRINT INS_DirectControlFlowTargetAddress (INS ins)
ADDRINT INS_NextAddress (INS ins)
SYM SYM_Next (SYM x)
SYM SYM_Prev (SYM x)
const std::string & SYM_Name (SYM x)
SYM SYM_Invalid ()
BOOL SYM_Valid (SYM x)
BOOL SYM_Dynamic (SYM x)
BOOL SYM_GeneratedByPin (SYM x)
BOOL SYM_IFuncImplementation (SYM x)
BOOL SYM_IFuncResolver (SYM x)
ADDRINT SYM_Value (SYM x)
UINT32 SYM_Index (SYM x)
ADDRINT SYM_Address (SYM x)
UINT32 IMG_Id (IMG x)
IMG IMG_FindImgById (UINT32 id)
IMG IMG_FindByAddress (ADDRINT address)
PIN_CALLBACK RTN_AddInstrumentFunction (RTN_INSTRUMENT_CALLBACK fun, VOID *val)
LOCALFUN BOOL operator< (const RTN_KEY &p1, const RTN_KEY &p2)
PIN_CALLBACK IMG_AddInstrumentFunction (IMAGECALLBACK fun, VOID *v)
PIN_CALLBACK IMG_AddUnloadFunction (IMAGECALLBACK fun, VOID *v)
LOCALFUN VOID IMG_Destroy (IMG img)
USIZE RTN_Range (RTN rtn)
USIZE RTN_Size (RTN rtn)
RTN RTN_IFuncResolver (RTN rtn)
RTN RTN_IFuncImplementation (RTN rtn)
LOCALFUN VOID InitRtnToSym (RTN rtn, SYM sym)
LOCALFUN VOID UseShortName (RTN rtn, SYM sym)
LOCALFUN VOID BestFit (RTN rtn, SYM sym)
LOCALFUN INT SymPosition (SYM sym, const MemRange &range)
LOCALFUN RTN FinalizeRtn (RTN rtn, USIZE size)
LOCALFUN VOID AddRtnsToMap (IMG img)
LOCALFUN VOID DsUpdatesDueRtnfuncCreation (RTN rtnToSplit, RTN originatedFromIfunc, ADDRINT rtnToSplitAddr, ADDRINT rtnToSplitSize, ADDRINT newRtnAddr)
LOCALFUN RTN handleIfuncSymbol (ADDRINT actualFuncAddr, SYM resolver, IMG img)
LOCALFUN VOID FixSymbolsFromDebugInfo (IMG img)
LOCALFUN IMG ImgLoad (const std::string &filename, const CHAR *trueFilename, ADDRINT load_offset, UINT32 flags, BOOL *unmapAfterProcessing, void *arg)
IMG IMG_Open (const std::string &filename)
VOID IMG_Close (IMG img)
LOCALFUN VOID ImageLoadProbes (IMG img)
std::string RTN_FindNameByAddress (ADDRINT address)
RTN RTN_FindByAddress (ADDRINT address)
RTN RTN_FindByName (IMG img, const CHAR *name)
VOID RTN_Open (RTN rtn)
VOID RTN_Close (RTN rtn)
INS RTN_InsHead (RTN rtn)
INS RTN_InsHeadOnly (RTN rtn)
INS RTN_InsTail (RTN rtn)
UINT32 RTN_NumIns (RTN rtn)
VOID RTN_InsertCall (RTN rtn, IPOINT action, AFUNPTR funptr,...)
ADDRINT RTN_Address (RTN rtn)
RTN RTN_CreateAt (ADDRINT address, std::string name)
LOCALINLINE ADDRINT AlignToPageDown (ADDRINT addr)
LOCALINLINE ADDRINT AlignToPageUp (ADDRINT addr)
LOCALFUN VOID UpdateDynamicImgRegions (IMG img, ADDRINT rtn_low_addr, ADDRINT rtn_high_addr)
BOOL RTN_IsDynamic (RTN rtn)
ADDRINT SEC_Address (SEC sec)
BOOL SEC_IsReadable (SEC sec)
BOOL SEC_IsWriteable (SEC sec)
BOOL SEC_IsExecutable (SEC sec)
USIZE SEC_Size (SEC sec)
BOOL BBL_Original (BBL bbl)
ADDRINT BBL_Address (BBL bbl)
USIZE BBL_Size (BBL bbl)
IMG APP_ImgHead ()
IMG APP_ImgTail ()
std::string PIN_UndecorateSymbolName (const std::string &symbolName, UNDECORATION style)
PIN_CALLBACK PIN_AddInternalExceptionHandler (INTERNAL_EXCEPTION_CALLBACK fun, VOID *val)
VOID PIN_TryStart (THREADID tid, INTERNAL_EXCEPTION_CALLBACK fun, VOID *val)
VOID PIN_TryEnd (THREADID tid)
BOOL PIN_IsProbeMode ()
BOOL PIN_IsAttaching ()
LOCALFUN BOOL CheckInsSequenceForProbe (INS ins, UINT32 probe_size)
BOOL RTN_IsSafeForProbedInsertion (RTN rtn)
BOOL RTN_IsSafeForProbedInsertionEx (RTN rtn, PROBE_MODE mode)
BOOL RTN_IsSafeForProbedReplacement (RTN rtn)
BOOL RTN_IsSafeForProbedReplacementEx (RTN rtn, PROBE_MODE mode)
LOCALFUN IARGLIST CookArguments (va_list argList, ADDRINT instAddress, BOOL addReturnReg)
LOCALFUN IARGLIST CookArgumentsRTN (va_list argList, RTN rtn)
LOCALFUN IARGLIST CookArgumentsINS (va_list argList, INS ins)
LOCALFUN AFUNPTR RTN_ReplaceSignatureProbedImpl (RTN orgRtn, AFUNPTR replacement, PROBE_MODE mode, va_list argList)
AFUNPTR RTN_ReplaceSignatureProbed (RTN replacedRtn, AFUNPTR replacementFun,...)
AFUNPTR RTN_ReplaceSignatureProbedEx (RTN replacedRtn, PROBE_MODE mode, AFUNPTR replacementFun,...)
VOID RTN_InsertCallProbed (RTN orgRtn, IPOINT action, AFUNPTR funptr,...)
VOID RTN_InsertCallProbedEx (RTN orgRtn, IPOINT action, PROBE_MODE mode, AFUNPTR funptr,...)
LOCALFUN BOOL INS_CheckForProbeInsertion (INS ins)
BOOL PIN_IsSafeForProbedInsertion (ADDRINT addr)
VOID PIN_InsertCallProbed (ADDRINT addr, AFUNPTR funptr,...)
INT32 RTN_CodeRangesProbed (RTN rtn, INT32 num, PIN_CODE_RANGE *buffer)
GLOBALCONST PIN_CALLBACK PIN_CALLBACK_INVALID (0)
LOCALVAR KNOB< BOOL > KnobProfile (KNOB_MODE_WRITEONCE,"supported:stat","profile","0","print amount of memory dynamically allocated but not yet freed by the tool")
BOOL IsThreadInFiniCallback (OS_THREAD_ID sysId)
LOCALVAR KNOB< BOOL > KnobCheckLocks (KNOB_MODE_WRITEONCE,"supported:message","checklocks","1","Check locks are used correctly")
VOID PIN_LockClient ()
VOID PIN_UnlockClient ()
VOID PIN_WriteErrorMessage (const char *msg, INT32 type, PIN_ERR_SEVERITY_TYPE severity, INT32 num,...)
LOCALFUN VOID DoReplaceFunByNativeCall (INS ins, VOID *v)
LOCALFUN VOID DoInstrumentForFunReplacement (REGION *region, BOOL firstInstIsReplaceable)
AFUNPTR RTN_Replace (RTN replacedRtn, AFUNPTR replacementFun)
AFUNPTR RTN_ReplaceSignature (RTN replacedRtn, AFUNPTR replacementFun,...)
AFUNPTR RTN_ReplaceProbed (RTN replacedRtn, AFUNPTR replacementFun)
AFUNPTR RTN_ReplaceProbedEx (RTN replacedRtn, PROBE_MODE mode, AFUNPTR replacementFun)
VOID PIN_CallApplicationFunction (const CONTEXT *ctxt, THREADID tid, CALLINGSTD_TYPE cstype, AFUNPTR origFunPtr, CALL_APPLICATION_FUNCTION_PARAM *param,...)
BOOL INS_IsAddedForFunctionReplacement (INS ins)
VOID CALLBACK_SetExecutionOrder (PIN_CALLBACK callback, CALL_ORDER order)
CALL_ORDER CALLBACK_GetExecutionOrder (PIN_CALLBACK callback)
PIN_CALLBACK TRACE_AddInstrumentFunction (TRACE_INSTRUMENT_CALLBACK fun, VOID *val)
PIN_CALLBACK INS_AddInstrumentFunction (INS_INSTRUMENT_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddFiniFunction (FINI_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddPrepareForFiniFunction (PREPARE_FOR_FINI_CALLBACK fun, VOID *val)
VOID PIN_AddFetchFunction (FETCH_CALLBACK fun, VOID *val)
size_t PIN_FetchCode (void *copyBuf, const VOID *address, size_t maxSize, EXCEPTION_INFO *pExceptInfo)
VOID PIN_AddOutOfMemoryFunction (OUT_OF_MEMORY_CALLBACK fun, VOID *val)
VOID PIN_AddMemoryAddressTransFunction (MEMORY_ADDR_TRANS_CALLBACK fun, VOID *val)
VOID TRACE_AddSmcDetectedFunction (SMC_CALLBACK fun, VOID *val)
MEMORY_ADDR_TRANS_CALLBACK PIN_GetMemoryAddressTransFunction ()
PIN_CALLBACK PIN_AddDetachFunction (DETACH_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddDetachFunctionProbed (DETACH_PROBED_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddThreadStartFunction (THREAD_START_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddThreadAttachProbedFunction (THREAD_ATTACH_PROBED_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddThreadAttachFunction (THREAD_ATTACH_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddThreadDetachProbedFunction (THREAD_DETACH_PROBED_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddThreadDetachFunction (THREAD_DETACH_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddApplicationStartFunction (APPLICATION_START_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddThreadFiniFunction (THREAD_FINI_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddContextChangeFunction (CONTEXT_CHANGE_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddSyscallEntryFunction (SYSCALL_ENTRY_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddSyscallExitFunction (SYSCALL_EXIT_CALLBACK fun, VOID *val)
BOOL PIN_InterceptSignal (INT32 sig, INTERCEPT_SIGNAL_CALLBACK fun, VOID *val)
BOOL PIN_UnblockSignal (INT32 sig, BOOL enable)
VOID PIN_SetSmcSupport (SMC_ENABLE_DISABLE_TYPE enable_disable)
PIN_CALLBACK PIN_AddProbesInsertedFunction (PROBES_INSERTED_CALLBACK fun, VOID *val)
PIN_CALLBACK PIN_AddForkFunction (FPOINT point, FORK_CALLBACK fun, VOID *val)
VOID PIN_RemoveInstrumentation ()
VOID PIN_RemoveInstrumentationInRange (ADDRINT start, ADDRINT end)
VOID PIN_RemoveFiniFunctions ()
VOID PIN_Detach ()
ATTACH_STATUS PIN_Attach (ATTACH_CALLBACK fun, VOID *val)
VOID PIN_DetachProbed ()
ATTACH_STATUS PIN_AttachProbed (ATTACH_PROBED_CALLBACK fun, VOID *val)
LOCALFUN VOID CheckAndUpdateCondInstState (char const *typeName, CONDINSTSTATE &lastState, CONDINSTSTATE currState)
VOID INS_InsertPredicatedCall (INS ins, IPOINT ipoint, AFUNPTR funptr,...)
VOID INS_InsertCall (INS ins, IPOINT action, AFUNPTR funptr,...)
VOID INS_InsertIfCall (INS ins, IPOINT action, AFUNPTR funptr,...)
VOID INS_InsertThenCall (INS ins, IPOINT action, AFUNPTR funptr,...)
VOID INS_InsertIfPredicatedCall (INS ins, IPOINT action, AFUNPTR funptr,...)
VOID INS_InsertThenPredicatedCall (INS ins, IPOINT action, AFUNPTR funptr,...)
VOID AInsertCall (INS ins, IPOINT ipoint, PREDICATE pred, COND_CALL_TYPE condCallType, AFUNPTR funptr, va_list ap)
VOID AInsertVersionCase (INS ins, REG reg, INT32 case_value, ADDRINT version, va_list ap)
LOCALFUN VOID StartProgram ()
PIN_CONFIGURATION_INFO PIN_CreateDefaultConfigurationInfo ()
VOID PIN_SetAllowedConcurrentCallbacks (PIN_CONFIGURATION_INFO options, PIN_CALLBACK_TYPE callbackType)
VOID PIN_StartProgram (PIN_CONFIGURATION_INFO options=PIN_CreateDefaultConfigurationInfo())
VOID PIN_StartProgramProbed ()
LOCALFUN VOID DumpPinVersion ()
LOCALVAR KNOB_COMMENT KnobPintoolFamily ("pintool","Pin tools switches")
LOCALVAR KNOB_COMMENT KnobGeneralFamily ("supported","General developer switches")
LOCALVAR KNOB_COMMENT KnobBasicFamily ("supported:basic","Basic switches")
LOCALVAR KNOB_COMMENT KnobDebugFamily ("supported:debug","General switches")
LOCALVAR KNOB_COMMENT KnobMessageFamily ("supported:message","Message switches")
LOCALVAR KNOB_COMMENT KnobRegionFamily ("supported:region","Region generation switches")
LOCALVAR KNOB_COMMENT KnobRegAllocFamily ("supported:regalloc","Register allocation switches")
LOCALVAR KNOB< std::string > KnobLogFile (KNOB_MODE_WRITEONCE,"pintool","logfile","pintool.log","The log file path and file name")
LOCALVAR KNOB< BOOL > KnobUniqueLogFiles (KNOB_MODE_WRITEONCE,"pintool","unique_logfile","0","The log file names will contain the pid")
LOCALVAR KNOB< BOOL > KnobHelp1 (KNOB_MODE_WRITEONCE,"pintool","help","0","Print help message (Return failure of PIN_Init() in order to allow the tool\ to print help message)")
LOCALVAR KNOB< BOOL > KnobHelp2 (KNOB_MODE_WRITEONCE,"pintool","h","0","Print help message (Return failure of PIN_Init() in order to allow the tool\ to print help message)")
LOCALFUN BOOL PIN_ParseCommandLine (int xargc, CHAR **xargv, BOOL standAlone)
LOCALFUN VOID InitializeCallBacks ()
const std::string & PIN_Version ()
BOOL PIN_Init (INT32 argc, CHAR **argv)
VOID TRACE_InsertCall (TRACE trace, IPOINT action, AFUNPTR funptr,...)
VOID TRACE_InsertIfCall (TRACE trace, IPOINT action, AFUNPTR funptr,...)
VOID TRACE_InsertThenCall (TRACE trace, IPOINT action, AFUNPTR funptr,...)
BBL TRACE_BblHead (TRACE trace)
BBL TRACE_BblTail (TRACE trace)
ADDRINT TRACE_Address (TRACE trace)
USIZE TRACE_Size (TRACE trace)
RTN TRACE_Rtn (TRACE trace)
BOOL TRACE_HasFallThrough (TRACE trace)
UINT32 TRACE_NumBbl (TRACE trace)
UINT32 TRACE_NumIns (TRACE trace)
VOID BBL_InsertCall (BBL bbl, IPOINT action, AFUNPTR funptr,...)
VOID BBL_InsertIfCall (BBL bbl, IPOINT action, AFUNPTR funptr,...)
VOID BBL_InsertThenCall (BBL bbl, IPOINT action, AFUNPTR funptr,...)
BOOL BBL_HasFallThrough (BBL bbl)
BOOL PIN_SupportsProcessorState (PROCESSOR_STATE state)
BOOL PIN_ContextContainsState (CONTEXT *ctxt, PROCESSOR_STATE state)
VOID PIN_SetContextRegval (CONTEXT *ctxt, REG reg, const UINT8 *val)
VOID PIN_GetContextRegval (const CONTEXT *ctxt, REG reg, UINT8 *val)
VOID PIN_SetContextReg (CONTEXT *ctxt, REG reg, ADDRINT val)
ADDRINT PIN_GetContextReg (const CONTEXT *ctxt, REG reg)
VOID PIN_SetContextFPState (CONTEXT *ctxt, const FPSTATE *fpstate)
VOID PIN_GetContextFPState (const CONTEXT *ctxt, FPSTATE *fpstate)
REGSET PIN_GetFullContextRegsSet ()
VOID PIN_SaveContext (const CONTEXT *ctxtFrom, CONTEXT *ctxtTo)
VOID PIN_ExecuteAt (const CONTEXT *ctxt)
VOID PIN_SetSyscallArgument (CONTEXT *ctxt, SYSCALL_STANDARD std, UINT32 argNum, ADDRINT val)
ADDRINT PIN_GetSyscallArgument (const CONTEXT *ctxt, SYSCALL_STANDARD std, UINT32 argNum)
VOID PIN_SetSyscallNumber (CONTEXT *ctxt, SYSCALL_STANDARD std, ADDRINT val)
ADDRINT PIN_GetSyscallNumber (const CONTEXT *ctxt, SYSCALL_STANDARD std)
ADDRINT PIN_GetSyscallReturn (const CONTEXT *ctxt, SYSCALL_STANDARD std)
ADDRINT PIN_GetSyscallErrno (const CONTEXT *ctxt, SYSCALL_STANDARD std)
VOID PIN_SetPhysicalContextReg (PHYSICAL_CONTEXT *pPhysCtxt, REG reg, ADDRINT val)
ADDRINT PIN_GetPhysicalContextReg (const PHYSICAL_CONTEXT *pPhysCtxt, REG reg)
VOID PIN_SetPhysicalContextFPState (PHYSICAL_CONTEXT *pPhysCtxt, const VOID *fpstate)
VOID PIN_GetPhysicalContextFPState (const PHYSICAL_CONTEXT *pPhysCtxt, VOID *fpstate)
VOID PIN_RaiseException (const CONTEXT *ctxt, THREADID tid, const EXCEPTION_INFO *pExceptInfo)
LOCALFUN VOID RecordInstructionMutation (INS ins, EXT ext, BOOL noDuplicates)
VOID INS_RewriteMemoryOperand (INS ins, UINT32 memindex, REG reg)
VOID INS_InsertIndirectJump (INS ins, IPOINT ipoint, REG reg)
VOID INS_InsertDirectJump (INS ins, IPOINT ipoint, ADDRINT tgt)
REG PIN_ClaimToolRegister ()
CHAR * PIN_VmFullPath ()
const CHAR * PIN_ToolFullPath ()
NORETURN VOID PIN_ExitProcess (INT32 exitCode)
INT PIN_GetPid ()
VOID INS_Delete (INS ins)
VOID IARGLIST_AddArguments (IARGLIST args,...)
IARGLIST IARGLIST_Alloc ()
VOID IARGLIST_Free (IARGLIST args)
size_t PIN_SafeCopy (VOID *dst, const VOID *src, size_t size)
size_t PIN_SafeCopyEx (VOID *dst, const VOID *src, size_t size, EXCEPTION_INFO *pExceptInfo)
VOID INS_InsertFillBuffer (INS ins, IPOINT action, BUFFER_ID id,...)
VOID INS_InsertFillBufferPredicated (INS ins, IPOINT action, BUFFER_ID id,...)
VOID INS_InsertFillBufferThen (INS ins, IPOINT action, BUFFER_ID id,...)
VOID BBL_InsertFillBuffer (BBL bbl, IPOINT action, BUFFER_ID id,...)
VOID RTN_InsertFillBuffer (RTN rtn, IPOINT action, BUFFER_ID id,...)
BUFFER_ID PIN_DefineTraceBuffer (size_t recordSize, UINT32 numPages, TRACE_BUFFER_CALLBACK fun, VOID *val)
VOID * PIN_AllocateBuffer (BUFFER_ID id)
VOID PIN_DeallocateBuffer (BUFFER_ID id, VOID *buf)
BOOL PIN_IsActionPending (THREADID tid)
UINT32 PIN_GetInitialThreadCount ()
VOID * PIN_GetBufferPointer (CONTEXT *const ctxt, BUFFER_ID id)
BOOL PIN_CheckReadAccess (VOID *addr)
BOOL PIN_CheckWriteAccess (VOID *addr)
ADDRINT PIN_GetAuxVectorValue (ADDRINT type, bool *found)
NORETURN VOID PIN_ExitApplication (INT32 status)
LOCALFUN const char * ContextChangeReasonName (CONTEXT_CHANGE_REASON r)
OS_THREAD_ID PIN_GetTid ()
THREADID PIN_ThreadId ()
PIN_THREAD_UID PIN_ThreadUid ()
OS_THREAD_ID PIN_GetParentTid ()
VOID PIN_Sleep (UINT32 milliseconds)
VOID PIN_Yield ()
THREADID PIN_SpawnInternalThread (ROOT_THREAD_FUNC *pThreadFunc, VOID *arg, size_t stackSize, PIN_THREAD_UID *pThreadUid)
VOID PIN_ExitThread (INT32 exitCode)
BOOL PIN_IsApplicationThread ()
BOOL PIN_WaitForThreadTermination (const PIN_THREAD_UID &threadUid, UINT32 milliseconds, INT32 *pExitCode)
TLS_KEY PIN_CreateThreadDataKey (DESTRUCTFUN destruct_func)
BOOL PIN_DeleteThreadDataKey (TLS_KEY key)
BOOL PIN_SetThreadData (TLS_KEY key, const VOID *data)
BOOL PIN_SetThreadData (TLS_KEY key, const VOID *data, THREADID threadId)
VOID * PIN_GetThreadData (TLS_KEY key)
VOID * PIN_GetThreadData (TLS_KEY key, THREADID threadId)
VOID BBL_SetTargetVersion (BBL bbl, ADDRINT version)
ADDRINT TRACE_Version (TRACE trace)
VOID INS_InsertVersionCase (INS ins, REG reg, INT32 case_value, ADDRINT version,...)
int PIN_GetInitialContextForUnwind (const CONTEXT *ctxt, void *cursor)
int PIN_Backtrace (const CONTEXT *ctxt, void **buffer, int size)
PIN_CALLBACK PIN_AddForkFunctionProbed (FPOINT point, FORK_PROBE_MODE_CALLBACK fun, VOID *val)
LOCALFUN BOOL RTN_ReplaceSyscallProbed (RTN rtn, INT32 syscallNum, RTN errnoLocationRtn, RTN sysenterTrapRtn)
LOCALFUN VOID beforeForkSyscall (ADDRINT gax)
LOCALFUN VOID afterForkSyscall (ADDRINT syscall_result_reg)
LOCALFUN std::string sanitize (const std::string &original)
LOCALFUN std::string cplus_demangle (std::string name, UNDECORATION style)

Variables

LOCALTYPE typedef void *(* rbrk_ft )(void)
LOCALTYPE typedef std::pair
< std::string, ADDRINT > 
SYM_BASIC_INFO
LOCALTYPE typedef std::set
< SYM_BASIC_INFO >
::const_iterator 
SYMSET_CONST_ITERATOR
LOCALTYPE typedef std::list
< INSTR
ILIST
LOCALTYPE typedef std::map
< ADDRINT, INSTR_INFO
IMAP
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< FOLLOW_CHILD_PROCESS_CALLBACK
FOLLOW_CHILD_PROCESS_CALLBACKVAL
LOCALTYPE typedef
FOLLOW_CHILD_PROCESS_CALLBACKVAL::FUNS 
FOLLOW_CHILD_PROCESS_CALLBACKVALFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< DEBUG_INTERPRETER_CALLBACK
DEBUG_INTERPRETER_CALLBACKVAL
LOCALTYPE typedef
DEBUG_INTERPRETER_CALLBACKVAL::FUNS 
DEBUG_INTERPRETER_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< DEBUG_BREAKPOINT_CALLBACK
DEBUG_BREAKPOINT_CALLBACKVAL
LOCALTYPE typedef
DEBUG_BREAKPOINT_CALLBACKVAL::FUNS 
DEBUG_BREAKPOINT_CALLBACKFUNS
LOCALTYPE typedef
SIMPLE_CALLBACKVAL
< INTERCEPT_DEBUGGING_EVENT_CALLBACK > 
INTERCEPT_DEBUGGING_EVENT_CALLBACKVAL
LOCALTYPE typedef std::pair
< RTN_KEY, RTN > 
RTN_PAIR
LOCALTYPE typedef std::map
< RTN_KEY, RTN > 
RTN_MAP
LOCALTYPE typedef std::list
< MemRange > 
RTN_OUTSIDE_RANGES_LIST
LOCALTYPE typedef std::map
< ADDRINT,
OUTSIDE_TARGET_MEM_RANGE,
std::less< ADDRINT > > 
RTN_OUTSIDE_RANGES_MAP
LOCALTYPE typedef std::map
< ADDRINT, OUTSIDE_TARGET,
std::less< ADDRINT > > 
RTN_OUTSIDE_TARGETS_MAP
LOCALTYPE typedef std::map
< ADDRINT, BBL, std::less
< ADDRINT > > 
RTN_OUTSIDE_PREV_BBLS_MAP
LOCALTYPE typedef std::vector
< INS > 
RTN_UJMP_VECTOR
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< IMAGECALLBACK
IMAGECALLBACKVAL
LOCALTYPE typedef
IMAGECALLBACKVAL::FUNS 
IMAGECALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< RTN_INSTRUMENT_CALLBACK
RTN_INSTRUMENT_CALLBACKVAL
LOCALTYPE typedef
RTN_INSTRUMENT_CALLBACKVAL::FUNS 
RTN_INSTRUMENT_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< INS_INSTRUMENT_CALLBACK
INS_INSTRUMENT_CALLBACKVAL
LOCALTYPE typedef
INS_INSTRUMENT_CALLBACKVAL::FUNS 
INS_INSTRUMENT_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< TRACE_INSTRUMENT_CALLBACK
TRACE_INSTRUMENT_CALLBACKVAL
LOCALTYPE typedef
TRACE_INSTRUMENT_CALLBACKVAL::FUNS 
TRACE_INSTRUMENT_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< SMC_CALLBACK
SMC_CALLBACKVAL
LOCALTYPE typedef
SMC_CALLBACKVAL::FUNS 
SMC_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< PREPARE_FOR_FINI_CALLBACK
PREPARE_FOR_FINI_CALLBACKVAL
LOCALTYPE typedef
PREPARE_FOR_FINI_CALLBACKVAL::FUNS 
PREPARE_FOR_FINI_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< FINI_CALLBACK
FINI_CALLBACKVAL
LOCALTYPE typedef
FINI_CALLBACKVAL::FUNS 
FINI_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< FORK_CALLBACK
FORK_CALLBACKVAL
LOCALTYPE typedef
FORK_CALLBACKVAL::FUNS 
FORK_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< DETACH_CALLBACK
DETACH_CALLBACKVAL
LOCALTYPE typedef
DETACH_CALLBACKVAL::FUNS 
DETACH_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< DETACH_PROBED_CALLBACK
DETACH_PROBED_CALLBACKVAL
LOCALTYPE typedef
DETACH_PROBED_CALLBACKVAL::FUNS 
DETACH_PROBED_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< APPLICATION_START_CALLBACK
APPLICATION_START_CALLBACKVAL
LOCALTYPE typedef
APPLICATION_START_CALLBACKVAL::FUNS 
APPLICATION_START_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< THREAD_START_CALLBACK
THREAD_START_CALLBACKVAL
LOCALTYPE typedef
THREAD_START_CALLBACKVAL::FUNS 
THREAD_START_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< THREAD_ATTACH_PROBED_CALLBACK
THREAD_ATTACH_PROBED_CALLBACKVAL
LOCALTYPE typedef
THREAD_ATTACH_PROBED_CALLBACKVAL::FUNS 
THREAD_ATTACH_PROBED_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< THREAD_DETACH_PROBED_CALLBACK
THREAD_DETACH_PROBED_CALLBACKVAL
LOCALTYPE typedef
THREAD_DETACH_PROBED_CALLBACKVAL::FUNS 
THREAD_DETACH_PROBED_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< THREAD_ATTACH_CALLBACK
THREAD_ATTACH_CALLBACKVAL
LOCALTYPE typedef
THREAD_ATTACH_CALLBACKVAL::FUNS 
THREAD_ATTACH_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< THREAD_DETACH_CALLBACK
THREAD_DETACH_CALLBACKVAL
LOCALTYPE typedef
THREAD_DETACH_CALLBACKVAL::FUNS 
THREAD_DETACH_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< THREAD_FINI_CALLBACK
THREAD_FINI_CALLBACKVAL
LOCALTYPE typedef
THREAD_FINI_CALLBACKVAL::FUNS 
THREAD_FINI_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< CONTEXT_CHANGE_CALLBACK
CONTEXT_CHANGE_CALLBACKVAL
LOCALTYPE typedef
CONTEXT_CHANGE_CALLBACKVAL::FUNS 
CONTEXT_CHANGE_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< SYSCALL_ENTRY_CALLBACK
SYSCALL_ENTRY_CALLBACKVAL
LOCALTYPE typedef
SYSCALL_ENTRY_CALLBACKVAL::FUNS 
SYSCALL_ENTRY_CALLBACKFUNS
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< SYSCALL_EXIT_CALLBACK
SYSCALL_EXIT_CALLBACKVAL
LOCALTYPE typedef
SYSCALL_EXIT_CALLBACKVAL::FUNS 
SYSCALL_EXIT_CALLBACKFUNS
LOCALTYPE typedef
SIMPLE_CALLBACKVAL
< INTERCEPT_SIGNAL_CALLBACK
INTERCEPT_SIGNAL_CALLBACKVAL
LOCALTYPE typedef std::map
< int,
INTERCEPT_SIGNAL_CALLBACKVAL > 
INTERCEPT_SIGNAL_MAP
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< PROBES_INSERTED_CALLBACK
PROBES_INSERTED_CALLBACKVAL
LOCALTYPE typedef
PROBES_INSERTED_CALLBACKVAL::FUNS 
PROBES_INSERTED_CALLBACKFUNS
LOCALTYPE typedef
SIMPLE_CALLBACKVAL
< TRACE_BUFFER_CALLBACK
TRACE_BUFFER_CALLBACKVAL
LOCALTYPE typedef std::map
< BUFFER_ID,
TRACE_BUFFER_CALLBACKVAL > 
TRACE_BUFFER_CALLBACK_MAP
LOCALTYPE typedef
COMPLEX_CALLBACKVAL
< FORK_PROBE_MODE_CALLBACK
FORK_PROBE_MODE_CALLBACKVAL
LOCALTYPE typedef
FORK_PROBE_MODE_CALLBACKVAL::FUNS 
FORK_PROBE_MODE_CALLBACKFUNS
LOCALTYPE typedef pid_t(* FORKFUNCPTR )()
LOCALTYPE typedef int(* CLOSEFUNCPTR )(int fd)
LOCALCONST UINT32 crc32table []
LOCALVAR const CHAR * debug_state_func = "_dl_debug_state"
LOCALVAR const CHAR * debug_state_var = "_r_debug"
LOCALVAR BOOL SymInit = false
LOCALVAR SYMBOL_INFO_MODE SymMode = NO_SYMBOLS
LOCALVAR const INT PLT0_ENTRY_SIZE = 16
LOCALVAR const INT PLT_ENTRY_SIZE = 16
LOCALVAR const INT RELC_INDEX_OFFSET = 7
LOCALVAR IMAP imap
LOCALVAR
FOLLOW_CHILD_PROCESS_CALLBACKVALFUNS 
followChildProcessList
LOCALVAR
DEBUG_INTERPRETER_CALLBACKFUNS 
debugInterpreterList
LOCALVAR
DEBUG_BREAKPOINT_CALLBACKFUNS 
debugBreakpointList
LOCALVAR
INTERCEPT_DEBUGGING_EVENT_CALLBACKVAL 
InterceptDebuggingEventBreakpoint
LOCALVAR
INTERCEPT_DEBUGGING_EVENT_CALLBACKVAL 
InterceptDebuggingEventSingleStep
LOCALVAR
INTERCEPT_DEBUGGING_EVENT_CALLBACKVAL 
InterceptDebuggingEventAsyncBreak
LOCALVAR
GET_EMULATED_REGISTER_CALLBACK 
GetEmulatedRegisterCallback
LOCALVAR
SET_EMULATED_REGISTER_CALLBACK 
SetEmulatedRegisterCallback
LOCALVAR
GET_TARGET_DESCRIPTION_CALLBACK 
GetTargetDescriptionCallback
LOCALVAR VOID * EmulatedRegisterCallbackVal
LOCALVAR RTN_MAP rtn_map
LOCALVAR const char * WHOLE_TEXT_SECTION = ".text"
LOCALVAR const char * UNNAMED_IMAGE_ENTRY_POINT = "unnamedImageEntryPoint"
LOCALVAR IMAGECALLBACKFUNS imageLoadList
LOCALVAR IMAGECALLBACKFUNS imageUnloadList
LOCALVAR APP app
LOCALVAR RTN OpenRtn
LOCALVAR IMG OpenImg
LOCALVAR
RTN_INSTRUMENT_CALLBACKFUNS 
rtnList
LOCALVAR std::list< IMAGE_LOAD_OPsavedImageLoadOps
LOCALVAR std::list
< IMAGE_LOAD_OP2
savedImageLoadOps2
LOCALVAR PINVM::PINSYNC_RWLOCK syscallCallbacksRWLock
LOCALVAR
INS_INSTRUMENT_CALLBACKFUNS 
insList
LOCALVAR
TRACE_INSTRUMENT_CALLBACKFUNS 
traceList
LOCALVAR OUT_OF_MEMORY_CALLBACK outOfMemoryFun = 0
LOCALVAR VOID * outOfMemoryVal = 0
LOCALVAR MEMORY_ADDR_TRANS_CALLBACK memoryAddrTransFun = 0
LOCALVAR VOID * memoryAddrTransVal = 0
LOCALVAR SMC_CALLBACKFUNS smcCallbackList
LOCALVAR
PREPARE_FOR_FINI_CALLBACKFUNS 
prepareForFiniList
LOCALVAR FINI_CALLBACKFUNS finiList
LOCALVAR FETCH_CALLBACK fetchCallbackFun = 0
LOCALVAR VOID * fetchCallbackVal = 0
LOCALVAR FORK_CALLBACKFUNS forkListBefore
LOCALVAR FORK_CALLBACKFUNS forkListAfterInParent
LOCALVAR FORK_CALLBACKFUNS forkListAfterInChild
LOCALVAR DETACH_CALLBACKFUNS detachList
LOCALVAR DETACH_PROBED_CALLBACKFUNS detachProbedList
LOCALVAR ATTACH_PROBED_CALLBACK attachProbedFun = 0
LOCALVAR VOID * attachProbedVal = 0
LOCALVAR
APPLICATION_START_CALLBACKFUNS 
appStartList
LOCALVAR THREAD_START_CALLBACKFUNS threadStartList
LOCALVAR
THREAD_ATTACH_PROBED_CALLBACKFUNS 
threadAttachProbedList
LOCALVAR
THREAD_DETACH_PROBED_CALLBACKFUNS 
threadDetachProbedList
LOCALVAR THREAD_ATTACH_CALLBACKFUNS threadAttachJitList
LOCALVAR THREAD_DETACH_CALLBACKFUNS threadDetachJitList
LOCALVAR THREAD_FINI_CALLBACKFUNS threadFiniList
LOCALVAR
CONTEXT_CHANGE_CALLBACKFUNS 
contextChangeList
LOCALVAR SYSCALL_ENTRY_CALLBACKFUNS syscallEntryList
LOCALVAR SYSCALL_EXIT_CALLBACKFUNS syscallExitList
LOCALVAR INTERCEPT_SIGNAL_MAP interceptSignalMap
LOCALVAR
PROBES_INSERTED_CALLBACKFUNS 
probesInsertedList
LOCALVAR TRACE_BUFFER_CALLBACK_MAP traceBufferCallbackMap
LOCALVAR std::set< ADDRINT,
std::less< ADDRINT > > 
addrReferences
LOCALVAR UINT32 replayModeFlags
LOCALVAR INT32 ToolArgc
LOCALVAR CHAR ** ToolArgv
LOCALVAR PIN_CONFIGURATION pinStartOptions
LOCALVAR volatile BOOL processExiting = FALSE
LOCALVAR OS_THREAD_ID IdOfThreadInFiniCallback = 0
LOCALVAR REPLACEDFUN::LIST replacedFunList
LOCALVAR CONDINSTSTATE condInstStateForIns = CONDINST_NORMAL
LOCALVAR PREDICATE insLastIfPredicate = PREDICATE_ALWAYS_TRUE
LOCALVAR CONDINSTSTATE condInstStateForTrace = CONDINST_NORMAL
LOCALVAR CONDINSTSTATE condInstStateForBbl = CONDINST_NORMAL
GLOBALCONST UINT32 MAX_CLIENT_TLS_KEYS = (TLS_KEY_CLIENT_LAST - TLS_KEY_CLIENT_FIRST + 1)
LOCALCONST std::string UNKNOWN_ELEMENT = "???"
LOCALVAR
FORK_PROBE_MODE_CALLBACKFUNS 
forkProbedListBefore
LOCALVAR
FORK_PROBE_MODE_CALLBACKFUNS 
forkProbedListAfterInParent
LOCALVAR
FORK_PROBE_MODE_CALLBACKFUNS 
forkProbedListAfterInChild
LOCALVAR FORKFUNCPTR origFork = NULL
LOCALVAR BOOL forkSyscallIsInstrumented = FALSE
LOCALVAR const char * getPpidFuncName = NAME("getppid")
LOCALVAR const char * errnoLocFuncName = "__errno_location"
struct {
   const std::string   name
   const std::string   replacement
   size_t   length
sanitizations []

Detailed Description

PIN DWARF debugging information using libpindwarf (LLVM based) library

Static model for instrumenting IMG's once they are loaded into memory. This file contains the ELF specific part for Linux.

Ahead of Time Instrumentation

Pin client functions for the follow child process mechanism

PIN support for debugging information

Pin client functions for the application-level debugger.

Deprecated Pin client functions.

Static model for instrumenting IMG's once they are loaded into memory.

Pin client interface and implementation for internal exception handling

Client side interface to pin vm.

Additional client side interface to pin vm containing the interfaces useful for a replay tool. These mainly allow a PinTool to request that Pin execute callbacks associated with specific events.

pin client state

Pin Jitted Functions Support

Pin client functions to temporarily stop all application threads, examine their state and resume.

Threading API for clients

Pin client interfaces for trace versioning

Unix-specific instrumentation in probe mode

Binary symbol handling in Unix.


Enumeration Type Documentation

anonymous enum

Keys to access client data in the thread local storage

Flags passed to PIN_SetReplayMode.

Enumerator:
REPLAY_MODE_IMAGEOPS 

Replayer will handle image ops.


Function Documentation

LOCALFUN VOID LEVEL_PINCLIENT::afterForkSyscall ( ADDRINT  syscall_result_reg)

Call the PIN tool's callback routines for an after-fork event

Compare the pid to the pid saved by beforeForkSyscall() to know which after-fork callbacks to call - parent or child. For safety we get the GAX value (which is also the syscall result register) as input and also return this value. This will ensure that the value of gax is maintained properly by this function, as gax is being used by the trampoline code to save the state and its value is not always maintained.

Parameters:
[in]syscall_result_regThe value of the gax register
Returns:
INT the value of the gax register that was received as input
VOID LEVEL_PINCLIENT::AInsertCall ( INS  ins,
IPOINT  ipoint,
PREDICATE  pred,
COND_CALL_TYPE  condCallType,
AFUNPTR  funptr,
va_list  ap 
)

If "condFun" is non-zero, then this analysis call will be invoked only if condFun (which is an analysis function called immediately before "funptr") returns a non-zero value.

Availability:
Mode: JIT
O/S: Linux, Windows & macOS*
CPU: All
VOID LEVEL_PINCLIENT::AInsertVersionCase ( INS  ins,
REG  reg,
INT32  case_value,
ADDRINT  version,
va_list  ap 
)
Availability:
Mode: JIT
O/S: Linux, Windows & macOS*
CPU: All
VOID LEVEL_PINCLIENT::BBL_InsertFillBuffer ( BBL  bbl,
IPOINT  action,
BUFFER_ID  id,
  ... 
)

Insert analysis code to fill one record in a trace buffer, relative to a BBL.

Parameters:
[in]bblThe application BBL
[in]actionWhether the record is filled before or after the BBL
[in]idThe ID of the buffer whose record is filled
[in]...IARG_TYPE. Additional arguments to specify the fields of the trace buffer.

Certain IARG_TYPEs cannot be used with the *_InsertFillBuffer APIs. The unsupported IARG_TYPEs are: IARG_CONTEXT, IARG_REG_REFERENCE, and IARG_REG_CONST_REFERENCE.

Availability:
Mode: JIT
O/S: Linux & Windows
CPU: IA-32 and Intel(R) 64 architectures
BBL_TYPE LEVEL_PINCLIENT::BBL_Type ( BBL  x)
Returns:
The type of the basic block
LOCALFUN VOID LEVEL_PINCLIENT::beforeForkSyscall ( ADDRINT  gax)

Call the PIN tool's callback routines for a before-fork event

Save the pid here - this is the pid of the parent. We need the saved pid later in afterForkSyscall() to know which after-fork callbacks to call - parent or child. For safety we get the GAX value as input and also return this value. This will ensure that the value of gax is maintained properly by this function, as gax is being used by the trampoline code to save the state and its value is not always maintained.

Parameters:
[in]gaxThe value of the gax register
Returns:
INT the value of the gax register that was received as input
LOCALFUN VOID LEVEL_PINCLIENT::DisassembleRegion ( RTN  rtn,
BBL  bbl,
const VOID *  current,
const VOID *  end,
ADDRINT  rtnStart,
ADDRINT  rtnEnd,
ADDRINT  rtnLimit,
ADDRINT  virtual_offset 
)

RtnOutsideRangesManager().HaveRet()

LOCALFUN VOID LEVEL_PINCLIENT::DsUpdatesDueRtnfuncCreation ( RTN  rtnToSplit,
RTN  originatedFromIfunc,
ADDRINT  rtnToSplitAddr,
ADDRINT  rtnToSplitSize,
ADDRINT  newRtnAddr 
)
LOCALFUN VOID LEVEL_PINCLIENT::FixSymbolsFromDebugInfo ( IMG  img)

This function compares the symbols previously read from the symbol tables with with the symbols read from the debug information. In case of conflict, the function will fix the symbol based on the information from the debug info. Conflicts may appear for example in the case of functions with multiple entry points. Each entry point will have its own label in the symbol table. This function will merge symbols that belong to the same function into a single symbol.

Parameters:
[in]imgThe image
LOCALFUN RTN LEVEL_PINCLIENT::handleIfuncSymbol ( ADDRINT  actualFuncAddr,
SYM  resolver,
IMG  img 
)

This function does all there is to do to handle an ifunc symbol, that is: 1. Find the RTN that is associated with actualFuncAddr 2. If this address don't have a symbol (routine) - create one and add it to img 3. Link the resolver RTN and the implementation RTN using RTN_ifunc_impl_set and RTN_ifunc_resolver_set 4. Mark the relevant symbols with the correct IFUNC_TYPE

The address should point to code (an executable section or segment). Since the whole code is "covered" by routine objects, the address should fall in one of the existing routines. Pin shortens the routine, which contains the given address, and creates a new routine which starts at the given address and continues till the next routine or the end of the code section.

Clarification: Each RTN which is created by this function was pointed by IFunc resolver. The name of the new function will be the name of the IFUNC symbol, and its address will be the address of the actual function address (the resolved address).

Parameters:
addressThe start address of the new routine
resolverThe symbol of the resolver function
imgThe image containing the resolver function
Returns:
RTN object The routine object is valid if the address fails into code section and there is no another routine object which starts at the same address.
LOCALFUN IMG LEVEL_PINCLIENT::ImgLoad ( const std::string &  filename,
const CHAR *  trueFilename,
ADDRINT  load_offset,
UINT32  flags,
BOOL *  unmapAfterProcessing,
void *  arg 
)

Create an image (IMG) for an already loaded image or load a new image into memory and create an IMG for it. When IMAGE_LOAD_RUNTIME is being used in flags it implies the image is an already loaded image otherwise it implies that we are mapping a new image.

On Unix (Linux & macOS) we map the image again even for an already loaded image because it's more convenient to us. When the loader or the kernel maps a file into memory it may split it in memory into several parts which makes it harder to parse. When we map the file using regular mapping system call it will map it in one chunk which makes it easier to parse. In these cases unmapAfterProcessing will be set to TRUE so that the duplicated image will be removed.

param[in] filename Image filename param[in] trueFilename Image filename - TODO - clarify difference compared to userFilename or unite!. param[in] load_offset Image load address for images which are already loaded param[in] flags Bitwise flags of IMAGE_LOAD_FLAGS param[out] unmapAfterProcessing If not NULL, True if image should be unmapped after IMG object had been created param[in] arg opaque pointer (OS specific), NULL if not used

BOOL LEVEL_PINCLIENT::IsThreadInFiniCallback ( OS_THREAD_ID  sysId)

Tells whether the given thread is currently executing a thread-fini callback.

Parameters:
[in]sysIdO/S ID for a thread.
Returns:
TRUE if the thread sysId is currently executing a thread-fini callback.
LOCALVAR KNOB<BOOL> LEVEL_PINCLIENT::KnobCheckLocks ( KNOB_MODE_WRITEONCE  ,
"supported:message"  ,
"checklocks"  ,
"1"  ,
"Check locks are used correctly"   
)
KNOB<BOOL> LEVEL_PINCLIENT::KnobJitApi ( KNOB_MODE_WRITEONCE  ,
"pintool:sym"  ,
"support_jit_api"  ,
"0"  ,
"Enables the Jitted Functions Support"   
)

This knob enables the Jitted Functions Support.

LOCALVAR KNOB<BOOL> LEVEL_PINCLIENT::KnobProfile ( KNOB_MODE_WRITEONCE  ,
"supported:stat"  ,
"profile"  ,
"0"  ,
"print amount of memory dynamically allocated but not yet freed by the tool"   
)

Remove all PIN client tool callbacks except for detachList and detachProbedList callbacks

LOCALFUN VOID LEVEL_PINCLIENT::RTN_Destroy ( RTN  rtn)

an rtn No RTN can be open when destroying an RTN

VOID LEVEL_PINCLIENT::RTN_InsertFillBuffer ( RTN  rtn,
IPOINT  action,
BUFFER_ID  id,
  ... 
)

Insert analysis code to fill one record in a trace buffer, relative to a RTN.

Parameters:
[in]rtnThe application RTN
[in]actionWhether the record is filled before or after the RTN
[in]idThe ID of the bufer whose record is filled
[in]...IARG_TYPE. Additional arguments to specify the fields of the trace buffer.

Certain IARG_TYPEs cannot be used with the *_InsertFillBuffer APIs. The unsupported IARG_TYPEs are: IARG_CONTEXT, IARG_REG_REFERENCE, and IARG_REG_CONST_REFERENCE.

Availability:
Mode: JIT
O/S: Linux & Windows
CPU: IA-32 and Intel(R) 64 architectures

Variable Documentation

LOCALVAR PINVM::PINSYNC_RWLOCK LEVEL_PINCLIENT::syscallCallbacksRWLock
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator