int main(int argc, char *argv[])
{
PIN_Init(argc, argv);
PIN_AddThreadStartFunction(ThreadStart, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
out = new ofstream("nops.out");
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
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;
}
// -------------------------------------------------------------
// 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();
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[])
{
if (PIN_Init(argc, argv)) return Usage();
trace = fopen("pinatrace.out", "w");
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
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(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;
}
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[])
{
// Initialize PIN library. Print help message if -h(elp) is specified
// in the command line or the command line is invalid
if(PIN_Init(argc,argv))
return Usage();
/// Instrumentations
// Register function to be called to instrument traces
TRACE_AddInstrumentFunction(trace_instrumentation, 0);
// Register function to be called when the application exits
PIN_AddFiniFunction(this_is_the_end, 0);
// Register function to be called when a module is loaded
IMG_AddInstrumentFunction(image_instrumentation, 0);
/// Other stuffs
// This routine will be called if the sleeping_thread calls PIN_Detach() (when the time is out)
PIN_AddDetachFunction(pin_is_detached, 0);
// Run a thread that will wait for the time out
PIN_SpawnInternalThread(
sleeping_thread,
0,
0,
NULL
);
// If we are in a wow64 process we must blacklist manually the JMP FAR: stub
// from being instrumented (each time a syscall is called, it will be instrumented for *nothing*)
// Its address is in FS:[0xC0] on Windows 7
ADDRINT wow64stub = __readfsdword(0xC0);
modules_blacklisted.insert(
std::make_pair(
std::string("wow64stub"),
std::make_pair(
wow64stub,
wow64stub
)
)
);
/// FIRE IN THE HOLE
// Start the program, never returns
PIN_StartProgram();
return 0;
}
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)
{
if (PIN_Init(argc,argv)) usage();
file = fopen(KnobOutputFile.Value().c_str(),"w");
INS_AddInstrumentFunction(record_calls,0);
PIN_AddFiniFunction(finish,0);
PIN_StartProgram();
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[])
{
if( PIN_Init(argc,argv) )
{
return Usage();
}
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 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;
}
// argc, argv are the entire command line, including pin -t <toolname> -- ...
int main(int argc, char * argv[])
{
// Initialize pin
if (PIN_Init(argc, argv)) return Usage();
PIN_AddThreadStartFunction(ThreadStart, 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(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();
if(PIN_Init(argc, argv)){
return Usage();
}
PIN_SetSyntaxIntel();
IMG_AddInstrumentFunction(Image, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
return 0;
}
// argc, argv are the entire command line, including pin -t <toolname> -- ...
int main(int argc, char * argv[])
{
// Initialize pin
PIN_Init(argc, argv);
// Register Instruction to be called to instrument instructions
INS_AddInstrumentFunction(Instruction, 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(int argc, char * argv[])
{
if (PIN_Init(argc, argv)) return -1;;
// Register Instruction to be called to instrument instructions
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
Out.open(KnobOutfile.Value().c_str());
if (!Out.good())
{
std::cerr << "Unable to open '" << KnobOutfile.Value() << "'" << std::endl;
return 1;
}
INS_AddInstrumentFunction(InstrumentIndirects, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
PIN_Init(argc, argv);
out.open(KnobOutput.Value().c_str());
INS_AddInstrumentFunction(InstrumentInstruction, 0);
// Fini prints the results.
PIN_AddFiniFunction(Fini, 0);
PIN_AddThreadStartFunction(CheckThreadCount, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
#if defined(TARGET_LINUX) || defined(TARGET_BSD)
LimitAvailableSpace();
#endif
out = fopen(KnobOutputFile.Value().c_str(), "w");
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
IMG_AddInstrumentFunction(ImageLoad, 0);
TRACE_AddInstrumentFunction(Trace, 0);
PIN_AddFiniFunction(Fini, 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_Init(argc, argv);
// Register InstrumentTrace function
TRACE_AddInstrumentFunction(InstrumentTrace, 0);
// Register application exit call back
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
// Initialize symbol processing
PIN_InitSymbols();
// Initialize pin
if (PIN_Init(argc, argv)) return Usage();
logging = ! KnobReplay.Value();
if (logging)
{
trace = fopen("record_imageload_rec.out", "w");
imgLog = fopen("imageload.log", "w");
IMG_AddInstrumentFunction(LogImageLoad, 0);
IMG_AddUnloadFunction (LogImageUnload, 0);
}
else
{ // Replaying
trace = fopen("record_imageload_play.out", "w");
imgLog = fopen("imageload.log", "r");
// We will handle image load operations.
PIN_SetReplayMode (REPLAY_MODE_IMAGEOPS);
// And then we replay the first two image load ops before we start the program.
// We do this even before adding the image instrumentation callback, that should still work,
// Pin should defer these and replay them inside PIN_StartProgram.
ReplayImageEntry();
ReplayImageEntry();
INS_AddInstrumentFunction (InstrumentInstruction, 0);
}
// These Trace functions demonstrate that the events are happening, they are the client...
IMG_AddInstrumentFunction(TraceImageLoad, 0);
IMG_AddUnloadFunction (TraceImageUnload, 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_InitLock(&lock);
out = fopen("thread_count.out", "w");
PIN_Init(argc, argv);
PIN_AddThreadStartFunction(ThreadStart, 0);
PIN_AddThreadFiniFunction(ThreadFini, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitLock(&Lock);
PIN_Init(argc, argv);
Out.open(KnobOutputFile.Value().c_str());
PIN_AddThreadStartFunction(ThreadStart, 0);
PIN_AddThreadFiniFunction(ThreadFini, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
if (PIN_Init(argc, argv)) return Usage();
// Create a Profiler Object
Profiler *prof = new Profiler();
// Passing profiler object to the instrumentation function
INS_AddInstrumentFunction(Instruction, prof);
// Passing profiler object to the finish function
PIN_AddFiniFunction(Fini, prof);
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return 1;
}
INS_AddInstrumentFunction(InstrumentInstruction, 0);
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
