int main(INT32 argc, CHAR **argv)
{
out = fopen("exception_monitor.out", "w");
PIN_InitSymbols();
PIN_Init(argc, argv);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddContextChangeFunction(OnException, 0);
IMG_AddInstrumentFunction(Image, 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 symbol table code, needed for rtn instrumentation
PIN_InitSymbols();
// Initialize pin
PIN_Init(argc, argv);
// Register Routine to be called to instrument rtn
RTN_AddInstrumentFunction(Routine, 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);
PIN_Init(argc, argv);
PIN_InitLock(&Lock);
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;
}
// 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 CodeCacheStressUsage();
OutFile.open(KnobOutputFile.Value().c_str());
// Register CacheFlushedCallback to be called when the PIN flushes the code cache
CODECACHE_AddCacheFlushedFunction(CacheFlushedCallback, NULL);
// Register Fini to be called when the application exits
PIN_AddFiniFunction(Fini, 0);
ToolStartTime = clock();
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
TRACE_AddInstrumentFunction(Trace, 0);
IMG_AddInstrumentFunction(Image, 0);
if (!PIN_InterceptSignal(SIGSEGV, SegvHandler, 0))
{
fprintf (stderr, "InterceptSignal failed\n");
exit (1);
}
// Never returns
PIN_StartProgram();
return 0;
}
// argc, argv are the entire command line, including pin -t <toolname> -- ...
int main(int argc, char * argv[])
{
// Initialize symbol processing
PIN_InitSymbols();
// Initialize pin
if (PIN_Init(argc, argv) != 0)
{
return 1;
}
// Register ImageLoad to be called when an image is loaded
IMG_AddInstrumentFunction(ImageLoad, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
InitLock(&lock);
out = fopen("thread_count2.out", "w");
PIN_Init(argc, argv);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddThreadStartFunction(ThreadStart, 0);
PIN_AddThreadFiniFunction(ThreadFini, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
if( PIN_Init(argc,argv) )
{
return Usage();
}
string logfile = KnobOutputFile.Value();
log_inl.open(logfile.c_str());
INS_AddInstrumentFunction(Instruction, 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 memory area used to set values in ymm regs
for (int i =0; i<64; i++)
{
ymmInitVals[i] = 0xdeadbeef;
}
// Initialize pin
PIN_Init(argc, argv);
// Register Instruction to be called to instrument instructions
INS_AddInstrumentFunction(Instruction, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
if( PIN_Init(argc,argv) )
{
return Usage();
}
string filename = KnobOutputFile.Value();
// Do this before we activate controllers
out.open(filename.c_str());
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char **argv)
{
PIN_SetSyntaxXED();
PIN_InitSymbols();
if (PIN_Init(argc, argv)) {
return Usage();
}
outFile = fopen(outputFile.Value().c_str(), "wb+");
INS_AddInstrumentFunction(TraceInstructions, 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 Usage();
}
out = new std::ofstream(KnobOutputFile.Value().c_str());
TRACE_AddInstrumentFunction(Trace, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
trace = fopen(KnobOutput.Value().c_str(), "w");
if (!trace)
{
perror("fopen");
return 1;
}
INS_AddInstrumentFunction(RewriteIns, 0);
PIN_AddFiniFunction(AtEnd, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
trace = fopen("rewritememtrace.out", "w");
if (!trace)
{
perror("fopen");
return 1;
}
TRACE_AddInstrumentFunction(Trace, 0);
PIN_AddFiniFunction(AtEnd, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
TRACE_AddInstrumentFunction(Trace, 0);
INS_AddInstrumentFunction(Ins, 0);
RTN_AddInstrumentFunction(Rtn, 0);
IMG_AddInstrumentFunction(Image, 0);
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);
// Scratch register used to select
// instrumentation version.
version_reg = PIN_ClaimToolRegister();
TRACE_AddInstrumentFunction(Trace, 0);
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
#if defined(USE_DECODE_CACHE)
out = new std::ofstream("xed-with-cache.out");
#else
out = new std::ofstream("xed-no-cache.out");
#endif
if( PIN_Init(argc,argv) )
return Usage();
INS_AddInstrumentFunction(Instruction, 0);
memset(histo,0,sizeof(UINT64)*MAX_BINS);
/* FIXME: single threaded tests only */
UINT32 cache_limit = 16*1024;
xed_decode_cache_initialize(&cache, new xed_decode_cache_entry_t[cache_limit], cache_limit);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram(); // Never returns
return 0;
}
int main(int argc, char * argv[])
{
file = fopen("itrace.out", "w");
// Initialize pin
PIN_InitSymbols();
if (PIN_Init(argc, argv)) return Usage();
TRACE_AddInstrumentFunction(Trace,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();
globalReserve = malloc(ReserveSize);
PIN_AddOutOfMemoryFunction(Assert, 0);
PIN_AddOutOfMemoryFunction(OutOfMem, 0);
#if defined(TARGET_LINUX) || defined(TARGET_BSD) || defined(TARGET_MAC)
LimitAvailableSpace();
#endif
out = fopen(KnobOutputFile.Value().c_str(), "w");
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[]) {
prof_ctrl->Initialize();
prof_ctrl->PreSetup();
PIN_InitSymbols();
PIN_Init(argc, argv);
prof_ctrl->PostSetup();
TRACE_AddInstrumentFunction(I_InstrumentTrace, NULL);
IMG_AddInstrumentFunction(I_ImageLoad, NULL);
IMG_AddUnloadFunction(I_ImageUnload, NULL);
PIN_AddSyscallEntryFunction(I_SyscallEntry, NULL);
PIN_AddSyscallExitFunction(I_SyscallExit, NULL);
PIN_InterceptSignal(SIGUSR2, I_IntSignal, NULL);
PIN_AddContextChangeFunction(I_ContextChange, NULL);
PIN_AddFiniFunction(I_ProgramExit, NULL);
PIN_AddThreadStartFunction(I_ThreadStart, NULL);
PIN_AddThreadFiniFunction(I_ThreadExit, NULL);
I_ProgramStart();
// start the program
PIN_StartProgram();
}
int main(int argc, char * argv[])
{
// prepare for image instrumentation mode
PIN_InitSymbols();
// Initialize pin
if (PIN_Init(argc, argv)) return -1;
scratchReg = PIN_ClaimToolRegister();
// Register ImageLoad to be called when an image is loaded
IMG_AddInstrumentFunction(ImageLoad, 0);
// And our Fini function to check that we did all we expected to.
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
// Callback function to invoke for every
// execution of an instruction
INS_AddInstrumentFunction(Instruction, 0);
// Callback functions to invoke before
// Pin releases control of the application
PIN_AddDetachFunction(HelloWorld, 0);
PIN_AddDetachFunction(ByeWorld, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, CHAR *argv[])
{
if (PIN_Init(argc,argv))
{
return Usage();
}
if (KnobHelp)
{
Usage();
return 0;
}
TRACE_AddInstrumentFunction(Trace, 0);
IMG_AddInstrumentFunction(Image, 0);
PIN_StartProgram(); // Never returns
return 0;
}
//--------------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
time(&m_StartTime);
// 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();
}
cerr << APP_NAME;
for (int i = 0; i < argc; i++)
{
m_CommandLine += argv[i];
m_CommandLine += " ";
}
m_ProcessId = PIN_GetPid();
// Register function to be called to instrument traces
TRACE_AddInstrumentFunction(Trace, 0);
// Register function to be called for every loaded module
IMG_AddInstrumentFunction(ImageLoad, 0);
// Register functions to be called for every thread starting and termination
PIN_AddThreadStartFunction(ThreadStart, 0);
PIN_AddThreadFiniFunction(ThreadEnd, 0);
// Register function to be called when the application exits
PIN_AddFiniFunction(Fini, 0);
cerr << "Starting application..." << endl;
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main (int argc, char *argv[])
{
char buff[20];
if(PIN_Init(argc,argv)) {
printf("command line error\n");
return 1;
}
pid = PIN_GetPid();
sprintf(buff, "ct%d.log", pid);
logfp = fopen(buff, "w");
if (logfp == NULL) {
printf("cannot open '%s' for writing\n", buff);
return 1;
}
sprintf(buff, "ct%d.trace", pid);
if (tb_create(buff)) {
fprintf(logfp, "tb_create() failed\n");
fflush(logfp);
return 1;
}
PIN_AddFiniFunction(fini, 0);
PIN_AddThreadStartFunction(thread_start, 0);
PIN_AddThreadFiniFunction(thread_fini, 0);
IMG_AddInstrumentFunction(img_load, NULL);
IMG_AddUnloadFunction(img_unload, NULL);
TRACE_AddInstrumentFunction(trace, NULL);
INS_AddInstrumentFunction(instruction, NULL);
PIN_AddSyscallEntryFunction(sys_enter, NULL);
PIN_AddSyscallExitFunction(sys_exit, NULL);
PIN_AddContextChangeFunction(context_switch, NULL);
PIN_InitSymbols();
PIN_StartProgram(); // Never returns
return 0;
}
/******************************************************************
Title:main
Function:Entrance function of the application
Input:
int argc:The number of the arguments
char * argv[]:The arguments list passed by command line
Output:
int
return value:0 is correct, negative means a exception
*******************************************************************/
int main(int argc, char * argv[])
{
hasFound = 0;
MemoryRecorder recorder;
memManager = &recorder;
//manulMarkTainted();
/* print out the state of memory*/
initHandlerFuns();
initHandlerTable();
beginHandle();
/*fprintf(output,"****************************************************\n");
fprintf(output,"Before the application\n");
memManager->printState(output);*/
PIN_InitSymbols();
MVFdata[0].sign=0;
CFWdata[0].sign=0;
CFMWdata[0].sign=0;
/* Initialize pin */
PIN_Init(argc, argv);
/* Register instruction to be called to instrument instruction */
INS_AddInstrumentFunction(instruction, 0);
RTN_AddInstrumentFunction(TaintSource, 0);
/* Register fini to be called when the application exits */
PIN_AddFiniFunction(fini, 0);
/* Start the program, never returns */
PIN_StartProgram();
//endHandle();
return 0;
}
int main(int argc, char * argv[])
{
ostringstream ss;
ss << getpid();
std::string file_name = "itrace_av_" + ss.str() +".out";
trace = fopen( file_name.c_str() , "w");
// Initialize pin
if (PIN_Init(argc, argv)) return Usage();
// 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[])
{
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return Usage();
}
TRACE_AddInstrumentFunction(Trace, 0);
CODECACHE_AddTraceInsertedFunction(TraceInserted, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
/*!
* The main procedure of the tool.
*/
int main(int argc, char *argv[])
{
PIN_InitSymbols();
PIN_Init(argc,argv);
out.open(KnobOutputFile.Value().c_str());
// Register function to be called to instrument traces
TRACE_AddInstrumentFunction(Trace, 0);
// Register function to be called to instrument images
IMG_AddInstrumentFunction(ImageLoad, 0);
// Register function 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 Usage();
TraceFile.open(KnobOutputFile.Value().c_str());
TraceFile << "starting up!" << endl;
// instruction level hooks
INS_AddInstrumentFunction(Instruction, 0);
// application trace level hooks
TRACE_AddInstrumentFunction(Trace, 0);
// application exit hooks
PIN_AddFiniFunction(Fini, 0);
// start application trace
PIN_StartProgram();
return 0;
}
