VOID docount()
{
// Periodically flush the cache
// every 50,000 instructions
if ((icount%50000) == 0)
PIN_RemoveInstrumentation();
icount++;
}
VOID InsertTaintInstrumentation()
{
TAINT_Analysis_On = true;
if (!TAINT_Instrumentation_On)
{
TAINT_Instrumentation_On = true;
PIN_RemoveInstrumentation();
}
}
BOOL SignalHandler(THREADID, INT32, CONTEXT *, BOOL, const EXCEPTION_INFO *, void *)
{
// If we receive the signal, enable instrumentation. We call
// PIN_RemoveInstrumentation() to remove any existing instrumentation
// from Pin's code cache.
//
EnableInstrumentation = TRUE;
PIN_RemoveInstrumentation();
// Tell Pin NOT to pass the signal to the application.
//
return FALSE;
}
VOID SwitchFrom2To1()
{
doInstrumentation1 = TRUE;
numRemovals2++;
PIN_RemoveInstrumentation();
}
VOID SwitchFrom1To2()
{
doInstrumentation1 = FALSE;
numRemovals1++;
PIN_RemoveInstrumentation();
}
/*
* This call-back implements the extended debugger commands.
*
* tid[in] Pin thread ID for debugger's "focus" thread.
* ctxt[in,out] Register state for the debugger's "focus" thread.
* cmd[in] Text of the extended command.
* result[out] Text that the debugger prints when the command finishes.
*
* Returns: TRUE if we recognize this extended command.
*/
static BOOL DebugInterpreter(THREADID tid, CONTEXT *ctxt, const string &cmd, string *result, VOID *)
{
TINFO_MAP::iterator it = ThreadInfos.find(tid);
if (it == ThreadInfos.end())
return FALSE;
TINFO *tinfo = it->second;
std::string line = TrimWhitespace(cmd);
*result = "";
if (line == "help")
{
result->append("stacktrace on -- Enable tracing of stack usage.\n");
result->append("stacktrace off -- Disable tracing of stack usage.\n");
result->append("stats -- Show stack usage for current thread.\n");
result->append("stackbreak newmax -- Break when any thread stack reaches new maximum usage.\n");
result->append("stackbreak <number> -- Break when any thread stack usage exceeds <number> bytes.\n");
result->append("stackbreak off -- Disable stack breakpoints.\n");
return TRUE;
}
else if (line == "stats")
{
ADDRINT sp = PIN_GetContextReg(ctxt, REG_STACK_PTR);
tinfo->_os.str("");
if (sp <= tinfo->_stackBase)
tinfo->_os << "Current stack usage: " << std::dec << (tinfo->_stackBase - sp) << " bytes.\n";
else
tinfo->_os << "Current stack usage: -" << std::dec << (sp - tinfo->_stackBase) << " bytes.\n";
tinfo->_os << "Maximum stack usage: " << tinfo->_max << " bytes.\n";
*result = tinfo->_os.str();
return TRUE;
}
else if (line == "stacktrace on")
{
if (!EnableInstrumentation)
{
PIN_RemoveInstrumentation();
EnableInstrumentation = true;
*result = "Stack tracing enabled.\n";
}
return TRUE;
}
else if (line == "stacktrace off")
{
if (EnableInstrumentation)
{
PIN_RemoveInstrumentation();
EnableInstrumentation = false;
*result = "Stack tracing disabled.\n";
}
return TRUE;
}
else if (line == "stackbreak newmax")
{
if (!EnableInstrumentation)
{
PIN_RemoveInstrumentation();
EnableInstrumentation = true;
}
BreakOnNewMax = true;
BreakOnSize = 0;
*result = "Will break when thread reaches new stack usage max.\n";
return TRUE;
}
else if (line == "stackbreak off")
{
BreakOnNewMax = false;
BreakOnSize = 0;
return TRUE;
}
else if (line.find("stackbreak ") == 0)
{
std::istringstream is(&line.c_str()[sizeof("stackbreak ")-1]);
size_t size;
is >> size;
if (!is)
{
*result = "Please specify a numeric size (in bytes)\n";
return TRUE;
}
if (!EnableInstrumentation)
{
PIN_RemoveInstrumentation();
EnableInstrumentation = true;
}
BreakOnNewMax = false;
BreakOnSize = size;
tinfo->_os.str("");
tinfo->_os << "Will break when thread uses more than " << size << " bytes of stack.\n";
*result = tinfo->_os.str();
return TRUE;
}
