int main(int argc, char **argv)
{
PIN_Init(argc, argv);
PIN_InitSymbols();
OutFile.open("iarg_tsc5.out");
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
TRACE_AddInstrumentFunction(Trace, 0);
IMG_AddInstrumentFunction(Image, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char** argv)
{
PIN_InitSymbols();
if (!PIN_Init(argc, argv))
{
IMG_AddInstrumentFunction(on_module_loading, 0);
PIN_StartProbedProgram();
}
exit(1);
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitSymbols();
PIN_Init(argc, argv);
RTN_AddInstrumentFunction(Rtn, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, CHAR *argv[])
{
PIN_InitSymbols();
if (PIN_Init(argc,argv))
return 1;
TraceFile.open(KnobOutputFile.Value().c_str());
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_StartProgramProbed();
return 0;
}
int main(int argc, char * argv[])
{
// prepare for image instrumentation mode
PIN_InitSymbols();
if (PIN_Init(argc, argv))
return Usage();
// Start the program, never returns
PIN_StartProgram();
return 0;
}
// -------------------------------------------------------------
// Tool startup function
// -------------------------------------------------------------
void STool_Run(STool_TSetup* s) {
// make setup configuration globally available
gSetup = *s;
// extract application (path)name and full application command line
for (int i=0; i<gSetup.argc-1;)
if (!strcmp("--", gSetup.argv[i++])) {
int len = 0, j;
for (j=i; j<gSetup.argc; ++j) len += strlen(gSetup.argv[j])+1;
gAppName = gSetup.argv[i];
gCommandLine = (char*)calloc(len, 1);
if (gCommandLine == NULL) exit((printf("Can't allocate command line string\n"),1));
strcat(gCommandLine, gSetup.argv[i]);
for (j=i+1; j<gSetup.argc; ++j) {
strcat(gCommandLine, " ");
strcat(gCommandLine, gSetup.argv[j]);
}
}
// initialize symbol table code, needed for rtn instrumentation
PIN_InitSymbols();
// initialize pin
if (PIN_Init(gSetup.argc, gSetup.argv)) {
Usage();
return;
}
// obtain a key for TLS storage.
gTlsKey = PIN_CreateThreadDataKey(0);
// if using memory operations buffering, define a BUF_SIZE-pages trace buffer
// and register BufferOverflow to be called when the buffer fills up
if (gSetup.memBuf) buf_id = PIN_DefineTraceBuffer(sizeof(STool_TMemRec), BUF_SIZE, BufferOverflow, 0);
// register ThreadStart to be called when a thread starts
PIN_AddThreadStartFunction(ThreadStart, 0);
// register ThreadEnd to be called when a thread ends
PIN_AddThreadFiniFunction(ThreadEnd, 0);
// register I_Trace to be called to instrument traces
TRACE_AddInstrumentFunction(I_Trace, 0);
// register Fini to be called when application exits
if (gSetup.appEnd) PIN_AddFiniFunction(Fini, 0);
// start the program, never returns
PIN_StartProgram();
}
int main(int argc, char *argv[])
{
PIN_InitSymbols();
if(PIN_Init(argc, argv)){
return Usage();
}
PIN_SetSyntaxIntel();
IMG_AddInstrumentFunction(Image, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
INS_AddInstrumentFunction(Instruction, 0);
IMG_AddInstrumentFunction(ImageLoad, 0);
// Register Fini to be called when the application exits
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitSymbols();
PIN_Init(argc, argv);
out.open(KnobOutput.Value().c_str());
IMG_AddInstrumentFunction(ImageLoad, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
RTN_AddInstrumentFunction(Rtn, 0);
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
// Initialize pin
PIN_Init(argc, argv);
TraceFile.open(KnobOutputFile.Value().c_str());
IMG_AddInstrumentFunction(imageLoad, 0);
// Start the program, never returns
PIN_StartProgramProbed();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
InitLock(&Lock);
IMG_AddInstrumentFunction(OnImage, 0);
RTN_AddInstrumentFunction(InstrumentRtn, 0);
PIN_InterceptDebuggingEvent(DEBUGGING_EVENT_BREAKPOINT, Intercept, 0);
PIN_InterceptDebuggingEvent(DEBUGGING_EVENT_ASYNC_BREAK, Intercept, 0);
PIN_AddFiniFunction(OnExit, 0);
PIN_StartProgram();
return 0;
}
Pintool <T>::Pintool (int argc, char * argv [])
: tool_ (0),
cmdline_error_ (false)
{
PIN_InitSymbols ();
this->cmdline_error_ = PIN_Init (argc, argv);
if (this->cmdline_error_)
std::cerr
<< "*** error parsing command line arguments" << std::endl
<< KNOB_BASE::StringKnobSummary () << std::endl;
else
this->tool_ = new T ();
}
int main( int argc, char **argv )
{
PIN_InitSymbols();
if ( PIN_Init(argc, argv) )
return Usage();
LogFile = fopen( KnobOutputFile.Value().c_str(), "wb" );
IMG_AddInstrumentFunction( ImageLoad, NULL );
PIN_AddFiniFunction( Finish, NULL );
PIN_StartProgram();
return 0;
}
int main(int argc, char** argv)
{
PIN_InitSymbols();
if (!PIN_Init(argc, argv))
{
IMG_AddInstrumentFunction(onImageLoad, 0);
PIN_StartProgram();
}
return(1);
}
int main(int argc, char * argv[]){
//If we want to debug the program manually setup the proper options in order to attach an external debugger
if(Config::ATTACH_DEBUGGER){
initDebug();
}
MYINFO("->Configuring Pintool<-\n");
//get the start time of the execution (benchmark)
tStart = clock();
// Initialize pin
PIN_InitSymbols();
if (PIN_Init(argc, argv)) return Usage();
//Register PIN Callbacks
INS_AddInstrumentFunction(Instruction,0);
//TRACE_AddInstrumentFunction(Trace,0);
PIN_AddThreadStartFunction(OnThreadStart, 0);
IMG_AddInstrumentFunction(imageLoadCallback, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_AddInternalExceptionHandler(ExceptionHandler,NULL);
//get theknob args
ConfigureTool();
if(Config::getInstance()->POLYMORPHIC_CODE_PATCH){
TRACE_AddInstrumentFunction(Trace,0);
}
proc_info->addProcAddresses();
//init the hooking system
HookSyscalls::enumSyscalls();
HookSyscalls::initHooks();
// Start the program, never returns
MYINFO("->Starting instrumented program<-\n");
PIN_StartProgram();
return 0;
}
/* ===================================================================== */
int main(int argc, char *argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
IMG_AddInstrumentFunction(ImageLoad, 0);
if ( PIN_IsProbeMode() )
PIN_StartProgramProbed();
else
PIN_StartProgram();
return 0;
}
int main(int argc, CHAR *argv[])
{
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return Usage();
}
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_StartProgramProbed();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
outfile.open(KnobOutputFile.Value().c_str());
IMG_AddInstrumentFunction(ImageLoad, 0);
IMG_AddUnloadFunction(ImageUnload, 0);
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
static sse_aligner_t aligner; // must be before usage...
PIN_InitSymbols();
if (PIN_Init(argc, argv))
return usage();
aligner.activate();
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
out.open(KnobOutput.Value().c_str());
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(AtEnd, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main (int argc, char *argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
IMG_AddInstrumentFunction (ImageLoad, 0);
// INS_AddInstrumentFunction(Ins, 0);
// PIN_AddSyscallEntryFunction(SyscallEntry, 0);
// PIN_AddSyscallExitFunction(SyscallExit, 0);
PIN_AddFiniFunction (Fini, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
INS_AddInstrumentFunction(Instruction, 0);
AllocateNewTLS();
// Never returns
PIN_StartProgram();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitLock(&lock);
PIN_InitSymbols();
PIN_Init(argc, argv);
PIN_AddThreadStartFunction(ThreadStart, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
// Scratch register used to select
// instrumentation version.
version_reg = PIN_ClaimToolRegister();
TRACE_AddInstrumentFunction(Trace, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
// Write to a file since cout and cerr maybe closed by the application
out = new std::ofstream("safecopy.out");
// Initialize pin & symbol manager
if (PIN_Init(argc, argv)) return Usage();
PIN_InitSymbols();
// Register EmulateLoad to be called to instrument instructions
INS_AddInstrumentFunction(EmulateLoad, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
if(PIN_Init(argc, argv)) {
cerr << "This Pintool modifies return values in certain memory addresses." << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return 0;
}
INS_AddInstrumentFunction(traceInst, 0);
RTN_AddInstrumentFunction(Routine, 0);
IMG_AddInstrumentFunction(Image, (VOID *) 1);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
if (KnobVerbose)
fout = fopen("swizzle3.log","w");
INS_AddInstrumentFunction(Instruction, 0);
IMG_AddInstrumentFunction(Image, 0);
// Never returns
PIN_StartProgram();
return 0;
}
// argc, argv are the entire command line, including pin -t <toolname> -- ...
int main(int argc, char * argv[])
{
// Initialize pin
PIN_InitSymbols();
PIN_Init(argc, argv);
// Activate alarm, must be done before PIN_StartProgram
ialarm.Activate("/lib/tls/libc.so.6", 0x1563a);
ialarm.SetAlarm(1, Handler, &ialarm);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
