C++ FILTER类代码示例

  bool Locality_Splitter::match_instance (
      uint32_t instance,
      const FILTER &filter) const
  {
    DANCEX11_LOG_TRACE ("Locality_Splitter::match_instance");

    // check if the node for the instance matches the filter
    bool match =
        filter.node ().empty () ||
          (filter.node () == this->plan_.instance ()[instance].node ());
    if (match)
      {
        // check if instance explicitly included or any allowed
        match = filter.included_instances ().empty () ||
                  filter.includes_instance (
                    this->plan_.instance ()[instance].node ());
      }
    return match;
  }

/*
 Instrumentation function;
 Track the trace, the usage of the code in the bbls and the bbl exits
*/
VOID Trace(TRACE trace, VOID *v)
{
	
	  if (!filter.SelectTrace(trace))
        return;
    /* Add trace to db */
    Trace_Info(TRACE_Address(trace),
               TRACE_NumBbl(trace),
               TRACE_NumIns(trace));

    /* Inc. trace execution count */
    TRACE_InsertCall(trace, IPOINT_BEFORE,
                     (AFUNPTR) Trace_Info,
                     IARG_ADDRINT, TRACE_Address(trace),
                     IARG_UINT32, TRACE_NumBbl(trace),
                     IARG_UINT32, TRACE_NumIns(trace),
                     IARG_END);

    USIZE accum_code_size = 0;
    for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
    {
        accum_code_size += BBL_Size(bbl);

        /* Add bbl to db */
        Bbl_Info(BBL_Address(bbl),
                    BBL_NumIns(bbl),
                    TRACE_Address(trace),
                    BBL_Size(bbl),
                    accum_code_size);

        INS ins = BBL_InsTail(bbl);

        if (INS_IsBranchOrCall(ins) || INS_IsRet(ins))
        {
            /* Inc. bbl exit count */
            INS_InsertCall(ins, IPOINT_TAKEN_BRANCH,
                           (AFUNPTR) BblExit_Info,
                           IARG_ADDRINT, BBL_Address(bbl),
                           IARG_ADDRINT, TRACE_Address(trace),
                           IARG_END);
        }
    }

    /* Trace falloff in the case the bbl is too big and does not
       necessarily end with a bbl terminating op                */
    INS ins = BBL_InsTail(TRACE_BblTail(trace));
    if (! INS_IsBranchOrCall(ins))
    {
        /* Inc. trace falloff exit count */
        INS_InsertCall(ins, IPOINT_BEFORE,
                       (AFUNPTR) TraceFall_Info,
                       IARG_ADDRINT, TRACE_Address(trace),
                       IARG_END);
    }
}

/*!
 * The main procedure of the tool.
 * This function is called when the application image is loaded but not yet started.
 * @param[in]   argc            total number of elements in the argv array
 * @param[in]   argv            array of command line arguments, 
 *                              including pin -t <toolname> -- ...
 */
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( unlikely(PIN_Init(argc,argv) ))
    {
        return Usage();
    }
    
    // Initialize the memory reference buffer;
    // set up the callback to process the buffer.
    //
    bufId = PIN_DefineTraceBuffer(sizeof(struct TRACEREF), KnobNumPagesInBuffer,
                                  BufferFull, 0);

    if(unlikely(bufId == BUFFER_ID_INVALID))
    {
        cerr << "Error: could not allocate initial buffer" << endl;
        return 1;
    }

   // Obtain  a key for TLS storage.
    mlog_key = PIN_CreateThreadDataKey(0);

    CODECACHE_AddCacheInitFunction(LimitTraces, 0);

    thread_ctx_ptr = PIN_ClaimToolRegister();
    ScratchReg = PIN_ClaimToolRegister();
    if (unlikely(!(REG_valid(thread_ctx_ptr) && REG_valid(ScratchReg))))
    {
        std::cerr << "Cannot allocate a scratch register.\n";
        std::cerr << std::flush;
        return 1;
    }


    // add callbacks
    PIN_AddThreadStartFunction(ThreadStart, 0);
    PIN_AddThreadFiniFunction(ThreadFini, 0);
    
    
        // add an instrumentation function
    TRACE_AddInstrumentFunction(Trace, 0);
    
    filter.Activate();

    // Start the program, never returns
    PIN_StartProgram();
    
    return 0;
}

// Call every time a basic block is hit
VOID Trace(TRACE trace, VOID *v) {
  // Use filtering to select traces. See filter.H in $PIN_ROOT/source/tools/InstLib
  // for the possible options that can be used as a filter

  // I typically use the -filter_no_shared_libs option. Make sure that you
  // specify the tool before using this flag
  // (e.g., $PIN_ROOT/pin -t bb_trace.so -filter_no_shared_libs -- EXE ARGS) -JL
  if (!filter.SelectTrace(trace))
    return;
  
  for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
    {
      BBL_InsertCall(bbl, IPOINT_BEFORE, (AFUNPTR)printip, IARG_INST_PTR,
      IARG_UINT32, BBL_NumIns(bbl), IARG_UINT32, BBL_NumIns(bbl), IARG_END);
    }
}

/*
 * Insert code to write data to a thread-specific buffer for instructions
 * that access memory.
 */
VOID Trace(TRACE trace, VOID *v)
{
    if (!filter.SelectTrace(trace))
        return;
       
    TRACE_InsertCall(trace, IPOINT_BEFORE, AFUNPTR(traceAddr),IARG_FAST_ANALYSIS_CALL, IARG_REG_VALUE, thread_ctx_ptr, IARG_END);
    ADDRINT trace_addr = TRACE_Address(trace);
    for(BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl=BBL_Next(bbl))
    {
    	INS ins = BBL_InsTail(bbl); //Last instruction of bbl
     
      if (INS_IsBranchOrCall(ins) || INS_IsRet(ins))
      {

    	  INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)setCJMP,
     	 		 IARG_CALL_ORDER, CALL_ORDER_FIRST,
     	 		 IARG_FAST_ANALYSIS_CALL,
     	 		 IARG_REG_VALUE, thread_ctx_ptr,
     	 		 IARG_ADDRINT, trace_addr,
                 IARG_BRANCH_TAKEN,
                 IARG_RETURN_REGS, ScratchReg,
                 IARG_END);

  //  	    thread_ctx_t *temp = reinterpret_cast<thread_ctx_t *>(thread_ctx_ptr);
            INS_InsertFillBuffer(ins, IPOINT_TAKEN_BRANCH, bufId,
            		                IARG_REG_VALUE, ScratchReg, offsetof(struct TRACEREF, traceId),
 	 	     	                                       //  IARG_UINT32, TraceCount, offsetof(struct TRACEREF, traceCount),
 	 	     	       	 	     	                     IARG_END);

     	 	/*
            INS_InsertFillBuffer(ins, IPOINT_TAKEN_BRANCH, bufId,
            		                                    // IARG_ADDRINT, ((TRACE_Address(trace) & 0x00ffffff)<<8), offsetof(struct TRACEREF, traceId),
            		                                       IARG_REG_VALUE, ScratchReg, offsetof(struct TRACEREF, traceId),
            		                                    //  IARG_UINT32, TraceCount, offsetof(struct TRACEREF, traceCount),
 	 	     	       	 	     	                     IARG_END);
           */
    	/*
   	 	INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) setCJMP,
               IARG_FAST_ANALYSIS_CALL,
               IARG_BRANCH_TAKEN,
               IARG_END);
        INS_InsertFillBuffer(ins, IPOINT_TAKEN_BRANCH, bufId, IARG_ADDRINT, ((TraceAddr & 0x00ffffff)<<8|BBNumber), offsetof(struct TRACEREF, traceId), IARG_END);
        */
      }
    }
}

int main(int argc, char *argv[])
{

    // Initialize pin & symbol manager
    PIN_InitSymbols();
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    
    inputFile.open(KnobInputFile.Value().c_str());
    if(buildFuncList(inputFile))
	return Usage();

    if(strlen(KnobScriptPath.Value().c_str()) > 0)
    {
	scriptProvided = TRUE;

	int cmdLen = strlen(KnobScriptPath.Value().c_str()) + 2 + MAX_PID_DIGITS;
	scriptCMDPartI = (char*)malloc(cmdLen);
	if(scriptCMDPartI == NULL)
	{
	    cerr << "Couldn't malloc " << endl;
	    exit(-1);
	}
	snprintf(scriptCMDPartI, cmdLen, "%s %d", KnobScriptPath.Value().c_str(), getpid());
    }

    /* Register Image to be called to instrument functions.*/
    IMG_AddInstrumentFunction(Image, 0);

    /* Register Analysis routines to be called when a thread begins/ends */
    PIN_AddThreadStartFunction(ThreadStart, 0);
    PIN_AddThreadFiniFunction(ThreadFini, 0);
    
    /* Register the application-start function */
    PIN_AddApplicationStartFunction(ApplicationStart, 0);

    filter.Activate();

    /* Never returns */
    PIN_StartProgram();
    
    return 0;
    
}

// argc, argv are the entire command line, including pin -t <toolname> -- ...
int main(int argc, char * argv[])
{
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }

    out.open(KnobOutputFile.Value().c_str());

    TRACE_AddInstrumentFunction(Trace, 0);

    filter.Activate();

    PIN_AddFiniFunction(Fini, NULL);

    // Start the program, never returns
    PIN_StartProgram();
    return 0;
}

/*
 Initialize and begin program execution under the control of Pin
*/
int main(INT32 argc, CHAR **argv)
{
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    
    CODECACHE_AddCacheInitFunction(LimitTraces, 0);
    
    TRACE_AddInstrumentFunction(Trace, 0);

    PIN_AddFiniFunction(DumpTraceInfo, 0);
    
    filter.Activate();
    
    PIN_StartProgram();
    
    return 0;
}

int main(int argc, char * argv[])
{
    // Initialize pin
    if (PIN_Init(argc, argv)) return Usage();

    trace = fopen("cjmp-sequence.out", "w");

    // Register Instruction to be called to instrument instructions
    TRACE_AddInstrumentFunction(Trace, 0);

    // Register Fini to be called when the application exits
    PIN_AddFiniFunction(Fini, 0);
    
    filter.Activate();
    
    // Start the program, never returns
    PIN_StartProgram();
    
    return 0;
}

// Pin calls this function every time a new basic block is encountered
// It inserts a call to docount
VOID Trace(TRACE trace, VOID *v)
{
   	  if (!filter.SelectTrace(trace))
        return;

    TRACE_InsertCall(trace, IPOINT_BEFORE, AFUNPTR(print2), IARG_FAST_ANALYSIS_CALL, IARG_ADDRINT, TRACE_Address(trace), IARG_END);
    // Visit every basic block  in the trace
    for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
    {
      
       INS ins = BBL_InsTail(bbl); //Last instruction of bbl
      if (INS_IsBranchOrCall(ins) || INS_IsRet(ins))
      {
     
           	 	INS_InsertIfCall(ins, IPOINT_BEFORE, (AFUNPTR) setCJMP,
                       IARG_FAST_ANALYSIS_CALL,
                       IARG_BRANCH_TAKEN,
                       IARG_END); 
             //IPOINT_TAKEN_BRANCH
              INS_InsertThenCall(ins, IPOINT_BEFORE, (AFUNPTR) print, IARG_END);          
      }
    }    
}

VOID Trace(TRACE trace, VOID * val)
{
    if (!filter.SelectTrace(trace))
        return;

    for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
    {
        for (INS ins = BBL_InsHead(bbl); INS_Valid(ins); ins = INS_Next(ins))
        {
            out << hex << setw(8) << INS_Address(ins) << " ";

            RTN rtn = TRACE_Rtn(trace);
            if (RTN_Valid(rtn))
            {
                IMG img = SEC_Img(RTN_Sec(rtn));
                if (IMG_Valid(img)) {
                    out << IMG_Name(img) << ":" << RTN_Name(rtn) << " " ;
                }
            }

            out << INS_Disassemble(ins) << endl;
        }
    }
}

/*
 * Insert code to write data to a thread-specific buffer for instructions
 * that access memory.
 */
VOID Trace(TRACE trace, VOID *v)
{
    if (!filter.SelectTrace(trace))
        return;
       
    TRACE_InsertCall(trace, IPOINT_BEFORE, AFUNPTR(traceAddr), IARG_FAST_ANALYSIS_CALL, IARG_ADDRINT, TRACE_Address(trace), IARG_END);
    for(BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl=BBL_Next(bbl))
    {
    	INS ins = BBL_InsTail(bbl); //Last instruction of bbl
    	
 /*   	if (INS_IsDirectBranch(ins) && INS_Category(ins) == XED_CATEGORY_COND_BR)
    		{
    			INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId,
                                         IARG_ADDRINT,INS_NextAddress(ins), offsetof(struct TRACEREF, pc),
                                        // IARG_ADDRINT, memOp, offsetof(struct TRACEREF, ea),
                                        // IARG_UINT32, refSize, offsetof(struct TRACEREF, size), 
                                         IARG_BOOL, TRUE, offsetof(struct TRACEREF, direct),
                                         IARG_END);
    		}
    	
    	else if( INS_IsIndirectBranchOrCall(ins) )
    		{
    			
                    INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId,
                                         IARG_ADDRINT,INS_NextAddress(ins), offsetof(struct TRACEREF, pc),
                                        // IARG_ADDRINT, memOp, offsetof(struct TRACEREF, ea),
                                        // IARG_UINT32, refSize, offsetof(struct TRACEREF, size), 
                                         IARG_BOOL, FALSE, offsetof(struct TRACEREF, direct),
                                         IARG_END);
    		} */
     
      if (INS_IsBranchOrCall(ins) || INS_IsRet(ins))
      {
     	 	INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) setCJMP,
                 IARG_FAST_ANALYSIS_CALL,
                 IARG_BRANCH_TAKEN,
                 IARG_END);
     	 	if (BranchTaken)
     	 	{
     	 	 	 UINT32 addr_postfix = TraceAddr & 0x00ffffff;
     	 	 	 UINT32 trace_id = (addr_postfix<<8) | FLIP;
     	 	 	if(trace_id != PreviousTraceID)
     	 	 	{
     	 	 		if (TraceCount > 1)
     	 	 		{
     	 	     	 	INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId,
     	 	     	                                         IARG_ADDRINT,PreviousTraceID, offsetof(struct TRACEREF, traceId),
     	 	     	                                         IARG_UINT32,(TraceCount-1), offsetof(struct TRACEREF, traceCount),
     	 	     	       	 	     	                     IARG_END);
     	 	     	   TraceCount=1;
     	 	 		}

 	 	     	 	INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId,
 	 	     	                                         IARG_ADDRINT,trace_id, offsetof(struct TRACEREF, traceId),
 	 	     	                                         IARG_UINT32,TraceCount, offsetof(struct TRACEREF, traceCount),
 	 	     	       	 	     	                     IARG_END);
     	 	 	 PreviousTraceID = trace_id;
     	 	 	} // end of "if(trace_id != PreviousTraceID)"
     	 	 	else
     	 	 	{
     	 	 		TraceCount++;
     	 	 	}


     	 	 	TraceAddr=0;
     	 	 	MASK=0;
     	 	 	FLIP=0;
     	 	 	BranchTaken=0;
     	 	}

/*
 * Insert code to write data to a thread-specific buffer for instructions
 * that access memory.
 */
VOID Trace(TRACE trace, VOID *v)
{
    if (!filter.SelectTrace(trace))
        return;
       
  //  TRACE_InsertCall(trace, IPOINT_BEFORE, AFUNPTR(traceAddr), IARG_FAST_ANALYSIS_CALL, IARG_ADDRINT, TRACE_Address(trace), IARG_END);
  /*
    BBL bbl = TRACE_BblHead(trace);
    if (BBL_Valid(bbl))
    {
    	INS ins = BBL_InsHead(bbl);
    	if(INS_Valid(ins))
    	{
    		INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId,
    		 	 	     	                                         IARG_ADDRINT, TRACE_Address(trace), offsetof(struct TRACEREF, traceId),
    		 	 	     	                                       //  IARG_UINT32, TraceCount, offsetof(struct TRACEREF, traceCount),
    		 	 	     	       	 	     	                     IARG_END);
    	}
    }
  */
    for(BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl=BBL_Next(bbl))
    {

    	INS ins = BBL_InsTail(bbl); //Last instruction of bbl
    /*
    	if(INS_Valid(ins))
    	{
    		INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId, IARG_ADDRINT, BBL_Address(bbl), offsetof(struct TRACEREF, traceId),  IARG_END);
    	}
    */
    
    
    	if (likely(INS_IsDirectBranch(ins) && INS_Category(ins) == XED_CATEGORY_COND_BR))
    	    		{
    		//INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId, IARG_ADDRINT, (BBL_Address(bbl) & 0x0fffffff <<4), offsetof(struct TRACEREF, traceId),  IARG_END);
    		ADDRINT DirectBranchTarget = INS_DirectBranchOrCallTargetAddress(ins);
    		INS_InsertFillBuffer(ins, IPOINT_TAKEN_BRANCH, bufId, IARG_ADDRINT, DirectBranchTarget, offsetof(struct TRACEREF, traceId),  IARG_END);
    		ADDRINT DirectBranchFallThrough = INS_NextAddress(ins);
    		INS_InsertFillBuffer(ins, IPOINT_AFTER, bufId, IARG_ADDRINT, DirectBranchFallThrough, offsetof(struct TRACEREF, traceId),  IARG_END);
    	    		}
    	else if(unlikely(INS_IsIndirectBranchOrCall(ins)))
    		//INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId, IARG_ADDRINT, ((BBL_Address(bbl) & 0x0fffffff <<4)|0x1), offsetof(struct TRACEREF, traceId),  IARG_END);
    		INS_InsertFillBuffer(ins, IPOINT_BEFORE, bufId, IARG_BRANCH_TARGET_ADDR, offsetof(struct TRACEREF, traceId),  IARG_END);
    }
    
    
        
      

 /*
    for(BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl=BBL_Next(bbl))
    {
    	INS ins = BBL_InsTail(bbl); //Last instruction of bbl
     
      if (INS_IsBranchOrCall(ins) || INS_IsRet(ins))
      {
     	 	INS_InsertIfCall(ins, IPOINT_BEFORE, (AFUNPTR) setCJMP,
                 IARG_FAST_ANALYSIS_CALL,
                 IARG_BRANCH_TAKEN,
                 IARG_END);
       INS_InsertFillBufferThen(ins, IPOINT_BEFORE, bufId,
 	 	     	                                         IARG_ADDRINT, TraceId, offsetof(struct TRACEREF, traceId),
 	 	     	                                       //  IARG_UINT32, TraceCount, offsetof(struct TRACEREF, traceCount),
 	 	     	       	 	     	                     IARG_END);

      }
    }
   */
}