Defines | |
#define | PIN_DEPRECATED_WARNINGS 1 |
Typedefs | |
typedef VOID(* | LEVEL_PINCLIENT::SIGNAL_BEFORE_CALLBACK )(THREADID threadIndex, INT32 sig, const CONTEXT *ctxtFrom, const CONTEXT *ctxtTo, VOID *v) |
typedef VOID(* | LEVEL_PINCLIENT::SIGNAL_AFTER_CALLBACK )(THREADID threadIndex, const CONTEXT *ctxtFrom, const CONTEXT *ctxtTo, VOID *v) |
typedef VOID(* | LEVEL_PINCLIENT::THREAD_BEGIN_CALLBACK )(THREADID threadIndex, VOID *sp, int flags, VOID *v) |
typedef VOID(* | LEVEL_PINCLIENT::THREAD_END_CALLBACK )(THREADID threadIndex, INT32 code, VOID *v) |
typedef BOOL(* | LEVEL_PINCLIENT::SIGNAL_INTERCEPT_CALLBACK )(THREADID threadIndex, INT32 sig, CONTEXT *ctxt, BOOL hasHndlr, VOID *v) |
Functions | |
PIN_DEPRECATED_API BOOL | LEVEL_CORE::INS_IsRewritableMemOpBaseLimited (INS ins, MEMORY_TYPE mtype, REG &base) |
PIN_DEPRECATED_API BOOL | LEVEL_CORE::INS_IsRewritableMemOpBase (INS ins, MEMORY_TYPE mtype, REG &base) |
PIN_DEPRECATED_API BOOL | LEVEL_CORE::INS_IsDynamicRewritableMemOpBase (INS ins, MEMORY_TYPE mtype, REG ®) |
PIN_DEPRECATED_API ADDRINT | LEVEL_CORE::INS_MemoryOffset (INS ins) |
PIN_DEPRECATED_API ADDRDELTA | LEVEL_CORE::INS_MemoryDisplacementSigned (INS ins) |
PIN_DEPRECATED_API BOOL | LEVEL_CORE::INS_OperandReadAndWriten (INS ins, UINT32 n) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_FindLineFileByAddress (ADDRINT address, INT32 *line, const CHAR **file) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_FindColumnLineFileByAddress (ADDRINT address, INT32 *column, INT32 *line, const CHAR **file) |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::PIN_AddSignalBeforeFunction (SIGNAL_BEFORE_CALLBACK fun, VOID *val) |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::PIN_AddSignalAfterFunction (SIGNAL_AFTER_CALLBACK fun, VOID *val) |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::PIN_AddSignalInterceptFunction (INT32 sig, SIGNAL_INTERCEPT_CALLBACK fun, VOID *val) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_AddThreadBeginFunction (THREAD_BEGIN_CALLBACK fun, VOID *val) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_AddThreadEndFunction (THREAD_END_CALLBACK fun, VOID *val) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_StartProbedProgram () |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::RTN_IsSafeForProbe (RTN rtn) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::RTN_ReplaceWithUninstrumentedRoutine (RTN replacedRtn, AFUNPTR replacementFun) |
PIN_DEPRECATED_API BBL | LEVEL_PINCLIENT::RTN_BblHead (RTN x) |
PIN_DEPRECATED_API BBL | LEVEL_PINCLIENT::RTN_BblTail (RTN x) |
PIN_DEPRECATED_API INT32 | LEVEL_PINCLIENT::RTN_No (RTN x) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_RegisterItcAuxCallBackPushFun (AFUNPTR callBackPushFun) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::RTN_ComplexReplaceWithUninstrumentedRoutine (RTN replacedRtn, AFUNPTR replacementFun) |
PIN_DEPRECATED_API ADDRINT | LEVEL_PINCLIENT::PIN_FindAlternateAppStack () |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::ParseCommandLine (int xargc, CHAR **xargv) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_SetContextFPState (CONTEXT *ctxt, const VOID *fpstate) |
PIN_DEPRECATED_API VOID | LEVEL_PINCLIENT::PIN_GetContextFPState (const CONTEXT *ctxt, VOID *fpstate) |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::INS_ChangeMemOpToBaseRegisterAddressMode (INS ins, MEMORY_TYPE mtype, REG newBase) |
PIN_DEPRECATED_API BOOL | LEVEL_PINCLIENT::INS_RewriteMemoryAddressingToBaseRegisterOnly (INS ins, MEMORY_TYPE mtype, REG newBase) |
|
By default Pin will annotate deprecated parts of the API so that their use in tools will generate compiler warnings. If you want to suppress these warnings during the compilation of your tool, you can do so by defining the macro PIN_DEPRECATED_WARNINGS with the value zero. |
|
Call back function when application signal handler returns.
|
|
Call back function when application handles a signal.
|
|
Call back function when tool creates its own signal handler.
|
|
Call back function when thread begins
|
|
Call back function when thread ends
|
|
Change this memory access instruction use a base register addressing mode. On IA-32/Intel(R) 64, it will not rewrite all references; See INS_IsRewritableMemOpBaseLimited() for details.
|
|
Test if this memory operation can be rewritten dynamically and return the base register
|
|
|
|
|
|
|
|
|
|
Old name for the previous function; this name is a typo. For backward compatibility we keep it.
|
|
Change this memory access instruction to reference the virtual memory location contained in the given register. On IA-32 and Intel64, the modified operand uses only base register addressing with the new base register newBase. Any index, scale, or offset fields from that operand in the original instruction are removed. In addition, if the original instruction's operand uses a segment override, the instruction is changed to use the default segment. A memory operand can't be rewritten when:
|
|
|
|
Register a notification function that is called immediately after the application returns from a signal handler. This notification only occurs if the application returns "normally" from the signal handler. If the application jumps out of its handler early (e.g. via longjmp), the notification does not occur.
|
|
Register a notification function that is called immediately before the application jumps to a signal handler. The tool is only notified of a signal that the application actually handles. Unhandled signals do not trigger a notification.
|
|
Takes over ownership of a signal for the tool and establishes a tool handler for the signal. Tools should never call sigaction() directly to handle signals. Use this function to take over "ownership" of a signal. If you want to be notified when the application receives a signal, use PIN_AddContextChangeFunction() instead. Tools should take care when intercepting signals, because this can adversely affect the application if it also uses the signal. The application is still allowed to set up its own handler for an intercepted signal. However, the application is prevented from attempts to block the signal. When an intercepted signal is received, the tool's handler is called first. The tool's handler then decides whether the signal should be forwarded to the application's handler (if any). A tool can set only one "intercept" handler for a particular signal, so a new handler overwrites any previous handler for the same signal. To disable a handler, pass a NULL function pointer.
|
|
Call func immediately after a new thread has been created
|
|
Call func immediately before a thread ends
|
|
If we are currently on a pin stack, return a location on the application stack where we can "unswitch to" and continue execution there
|
|
Find the line number, file, and column number corresponding to a memory address. Compile your program with -g to include line number information. Pin can only read dwarf2 information, which is the default for most modern compilers. Use -gdwarf-2 if you are using gcc 2.96.
|
|
Find the line number and file corresponding to a memory address. Compile your program with -g to include line number information. Pin can only read dwarf2 information, which is the default for most modern compilers. Use -gdwarf-2 if you are using gcc 2.96.
|
|
Get the floating point state of the specified context.
|
|
This API is only used by the Intel Thread Checker. Calling this API to register the function that libtcheck provides to push the original function pointer of a replaced function onto Thread Checker's internal storage. Once this API is called, the function replacement bridge will call "callBackPushFun" with the original function pointer of the replaced function as the parameter.
|
|
Set the given floating point state in the specified context.
|
|
Starts program executing, never returns. PIN_Init must be called first. The command line option -probe must be invoked when using PIN_StartProbedProgram(). A probed program only invokes instrumentation at explicitly inserted probe points.
|
|
|
|
|
|
Replace a function in the application (replacedRtn) by another function defined in the Pintool (replacementFun). The replacement function is not instrumented. Difference between RTN_ReplaceWithUninstrumentedRoutine() and RTN_ComplexReplaceWithUninstrumentedRoutine() is that the latter does complex replacement (i.e. a call to the callBackPushFun registered will be made before calling to the replacement funtion).
|
|
Return TRUE if the given RTN is a candidate for function insertion using probes, and FALSE otherwise. Please use RTN_IsSafeForProbedInsertion() if you want to insert a call before or after routine.
|
|
|
|
Replace a function in the application (replacedRtn) by another function defined in the Pintool (replacementFun). The replacement function is not instrumented.
|