Pin
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
Macros | Typedefs | Enumerations | Functions | Variables
message.cpp File Reference
#include "level_base.H"
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <stdarg.h>
#include <iostream>
#include <fstream>
#include "my_unistd.H"

Macros

#define QMESSAGE(t, m)   do{ if(t.on()) t.Message(m); }while(0)
 
#define QMESSAGE0(t, m, p, e)   do{ if(t.on()) t.Message(m,p,e,0); }while(0)
 
#define QMESSAGE0_NORETURN(t, m, p, e)   do{ if(t.on()) t.MessageNoReturn(m,p,e,0); }while(0)
 
#define QMESSAGE1(t, m, p, e, a1)   do{ if(t.on()) t.Message(m,p,e,1,a1); }while(0)
 
#define QMESSAGE1_NORETURN(t, m, p, e, a1)   do{ if(t.on()) t.MessageNoReturn(m,p,e,1,a1); }while(0)
 
#define QMESSAGE2(t, m, p, e, a1, a2)   do{ if(t.on()) t.Message(m,p,e,2,a1,a2); }while(0)
 
#define QMESSAGE2_NORETURN(t, m, p, e, a1, a2)   do{ if(t.on()) t.MessageNoReturn(m,p,e,2,a1,a2); }while(0)
 
#define QMESSAGEP(t, m, p)   do{ if(t.on()) t.Message(m,p); }while(0)
 
#define QMESSAGE_LIMIT(t, m, max)   do{ static int qqq = 0; if( qqq++ >= max) break; if(t.on()) t.Message(m);}while(0)
 
#define ASSERTQ(message)   QMESSAGE0_NORETURN(LEVEL_BASE::MessageTypeAssert, message, TRUE, PIN_ERR_ASSERT)
 
#define PIN_ASSERT_FILE   __FILE__
 
#define ASSERT(condition, message)
 
#define ASSERTX(condition)   ASSERT(condition,"assertion failed: " #condition "\n")
 
#define ASSERTSLOW(condition, message)
 
#define ASSERTXSLOW(condition)   ASSERTSLOW(condition,"assertion failed: " #condition "\n")
 
#define NYI()   ASSERT(0, "Not Yet Implemented\n")
 
#define PIN_ERROR_DEBUGGER(message)   QMESSAGE0_NORETURN(MessageTypeError, message, TRUE, PIN_ERR_DEBUGGER)
 
#define PIN_ERROR(message)   QMESSAGE0_NORETURN(MessageTypeError, message, TRUE, PIN_ERR_INTERNAL)
 
#define PIN_ERROR0(message, type)   QMESSAGE0_NORETURN(MessageTypeError, message, TRUE, type)
 
#define PIN_ERROR1(message, type, arg1)   QMESSAGE1_NORETURN(MessageTypeError, message, TRUE, type, arg1)
 
#define PIN_ERROR2(message, type, arg1, arg2)   QMESSAGE2_NORETURN(MessageTypeError, message, TRUE, type, arg1, arg2)
 
#define PIN_FATAL_ERROR(message)   { PIN_ERROR(message); MESSAGE_TYPE::PrintMessageAndExit(message, "E: ", PIN_ERR_INTERNAL );}
 
#define PIN_NON_FATAL_ERROR(message)   QMESSAGE0(MessageTypeNonFatalError, message, TRUE, PIN_ERR_INTERNAL)
 
#define PIN_NON_FATAL_ERROR0(message, type)   QMESSAGE0(MessageTypeNonFatalError, message, TRUE, type)
 
#define PIN_NON_FATAL_ERROR1(message, type, arg1)   QMESSAGE1(MessageTypeNonFatalError, message, TRUE, type, arg1)
 
#define PIN_CRITICAL_ERROR(message)   QMESSAGE0(MessageTypeCriticalError, message, TRUE, PIN_ERR_INTERNAL)
 
#define PIN_CRITICAL_ERROR0(message, type)   QMESSAGE0(MessageTypeCriticalError, message, TRUE, type)
 
#define PIN_CRITICAL_ERROR1(message, type, arg1)   QMESSAGE1(MessageTypeCriticalError, message, TRUE, type, arg1)
 
#define PIN_CRITICAL_ERROR2(message, type, arg1, arg2)   QMESSAGE2(MessageTypeCriticalError, message, TRUE, type, arg1, arg2)
 
#define PIN_OUT_OF_MEMORY(message)   MESSAGE_TYPE::PrintMessageAndExit(message, "Pin is out of memory: ", PIN_ERR_OUT_OF_MEMORY )
 
#define CONSOLE(message)   QMESSAGE(MessageTypeConsole, message)
 
#define CONSOLE_NOPREFIX(message)   QMESSAGE(MessageTypeConsoleNoPrefix, message)
 
#define PHASE(message)   QMESSAGE( MessageTypePhase, message)
 
#define WARNING(message)   QMESSAGE( MessageTypeWarning,message)
 
#define WARNING_LIMIT(message, n)   QMESSAGE_LIMIT( MessageTypeWarning, message, n)
 
#define KNOWN(message)   QMESSAGE( MessageTypeKnown, message)
 
#define KNOWN_LIMIT(message, n)   QMESSAGE_LIMIT( MessageTypeKnown, message, n)
 
#define LOG(message)   QMESSAGE(MessageTypeLog, message)
 
#define INFO(message)   QMESSAGE(MessageTypeInfo,message)
 
#define INFO_LIMIT(message, n)   QMESSAGE_LIMIT(MessageTypeInfo, message, n)
 
#define OPPORTUNITY(message)   QMESSAGE(MessageTypeOpportunity,message)
 
#define OPPORTUNITY_LIMIT(message, n)   QMESSAGE_LIMIT(MessageTypeOpportunity,message, n)
 
#define PIN_DEBUG(message)   QMESSAGE(MessageTypeDebug, message)
 
#define STATS(message)   QMESSAGE(MessageTypeStats, message)
 

Typedefs

typedef BOOL(* LEVEL_BASE::MESSAGE_CALLBACK )(const string &message, PIN_ERRTYPE type, INT32 userType, INT32 severity, INT32 numArgs, va_list ap)
 

Enumerations

enum  LOGTYPE {
  LEVEL_BASE::LOGTYPE_CONSOLE,
  LEVEL_BASE::LOGTYPE_LOGFILE,
  LEVEL_BASE::LOGTYPE_CONSOLE_AND_LOGFILE
}
 

Functions

MESSAGE_TYPE LEVEL_BASE::MessageTypeNonFatalError ("non_fatal_error","NFE: ", false, false, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"errors")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeError ("error","E:", true, false, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"errors")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeCriticalError ("critical_error","E: ", false, false, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"errors")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeWarning ("warning","W:", false, false, true, false, LOGTYPE_LOGFILE,"warnings")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeConsole ("console","C:", false, false, true, false, LOGTYPE_CONSOLE,"console")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeConsoleNoPrefix ("console_noprefix","", false, false, true, false, LOGTYPE_CONSOLE,"console")
 
MESSAGE_TYPE_ALWAYS_ON LEVEL_BASE::MessageTypeAssert ("assert","A:", true, true, false, LOGTYPE_CONSOLE_AND_LOGFILE,"assert")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypePhase ("phase","P:", false, false, true, true, LOGTYPE_CONSOLE,"phase")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeKnown ("known","K:", false, false, true, false, LOGTYPE_CONSOLE,"known problem")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeInfo ("info","I:", false, false, true, false, LOGTYPE_CONSOLE,"info")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeDebug ("debug","D:", false, false, false, false, LOGTYPE_CONSOLE,"generic debug")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeOpportunity ("opportunity","O:", false, false, true, false, LOGTYPE_CONSOLE,"generic optimization opportunity")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeStats ("stats","S:", false, false, true, false, LOGTYPE_CONSOLE,"statistic")
 
MESSAGE_TYPE LEVEL_BASE::MessageTypeLog ("log","", false, false, true, false, LOGTYPE_LOGFILE,"generic log")
 
const string LEVEL_BASE::Line1 (80,'#')
 
const string LEVEL_BASE::Line2 (80,'=')
 
const string LEVEL_BASE::Line3 (80,'-')
 
const string LEVEL_BASE::Line4 (80,'.')
 
UINT64 LEVEL_BASE::MilliSecondsElapsed ()
 
UINT64 LEVEL_BASE::KiloBytesUsed ()
 
string LEVEL_BASE::ResourceInfo ()
 
string LEVEL_BASE::AssertString (const char *fileName, const char *functionName, unsigned line, const std::string &message)
 
LOCALVAR KNOB< UINT32 > LEVEL_BASE::PauseAbortKnob (KNOB_MODE_WRITEONCE,"supported:basic","pause_abort","0","Pause and print pid so gdb can attach before pin aborts")
 
LOCALFUN int LEVEL_BASE::cmp (const void *x1, const void *x2)
 
VOID LEVEL_BASE::BreakMe ()
 
UINT32 LEVEL_BASE::DivZero (UINT32 x)
 
VOID LEVEL_BASE::SegFault ()
 
LOCALFUN VOID LEVEL_BASE::SignalHandler (int arg)
 
VOID LEVEL_BASE::InstallSignalHandlers ()
 

Variables

LOCALVAR
PINVM::PINSYNC_SAFEPOD_LOCK 
LEVEL_BASE::MessageLock
 

Detailed Description

This module contains routines and classes for the handling error messages

Macro Definition Documentation

#define ASSERT (   condition,
  message 
)
Value:
do{ if(!(condition)) \
ASSERTQ(LEVEL_BASE::AssertString(PIN_ASSERT_FILE, __FUNCTION__, __LINE__, std::string("") + message));} while(0)
#define ASSERTSLOW (   condition,
  message 
)
Value:
do{ if(KnobSlowAsserts && !(condition)) \
ASSERTQ(LEVEL_BASE::AssertString(PIN_ASSERT_FILE, __FUNCTION__, __LINE__, std::string("") + message));} while(0)