int BinaryFile::Init(char *filename)
{
Destroy();
bfd_init();
_abfd = bfd_openr(filename, NULL);
if (_abfd == NULL) {
perror("bfd_openr");
return -1;
}
bfd_boolean ret = bfd_check_format(_abfd, bfd_object);
if (ret == false) {
perror("bfd_check_format_matches");
return -2;
}
int result = InitSymbols(_symbols, SYM_FUNC);
if (result < 0) {
fprintf(stderr, "get symbols error!\n");
return -3;
}
result = InitRelsym(_rels);
if (result < 0) {
fprintf(stderr, "get rels error!\n");
return -3;
}
return 0;
}
LONG WINAPI GetCrashReason(LPEXCEPTION_POINTERS ep)
{
if (!ep)
return EXCEPTION_CONTINUE_EXECUTION;
if (IsBadReadPtr(ep, sizeof(EXCEPTION_POINTERS)))
return EXCEPTION_CONTINUE_EXECUTION;
#ifdef _DEBUG
InitSymbols();
DWORD dwLineDisp = 0;
IMAGEHLP_LINE64 crashline = { sizeof(IMAGEHLP_LINE64), NULL, 0, NULL, 0 };
if (SymGetLineFromAddr64(GetCurrentProcess(), (DWORD64)ep->ExceptionRecord->ExceptionAddress, &dwLineDisp, &crashline))
{
char msg[2048];
sprintf(msg, "file: %s line: %i", crashline.FileName, (int)crashline.LineNumber);
MessageBox(NULL, msg, "An error has occurred", MB_OK | MB_ICONSTOP);
}
else
MessageBox(NULL, "Unknown error", "An error has occurred", MB_OK | MB_ICONSTOP);
KillSymbols();
#endif
#if 0
Gamma_Restore();
#endif
return EXCEPTION_EXECUTE_HANDLER;
}
TDSPPsk::TDSPPsk(char *name,
Int_t num,
UInt_t opt) : TDSPSymbolGenerator(name, num, opt){
// Book for num symbols
//
BookSymbols(num);
InitSymbols();
}
main(int argc,char **argv)
{
progname= argv[0]; /*Get the program name */
inpf= InitParser(argc,argv);
if (!inpf) exit(1); /*Abort in case of illegal input file */
LineSeek(0); /*Position on the begin of a file */
InitSymbols(predef_sym); /*Create the symbols table */
yyparse(); /*Do parsing */
Main(argc,argv); /*User applied 'main' program */
exit(0);
}
void ClassicLadder_InitAllDatas( void )
{
InitVars();
#ifdef OLD_TIMERS_MONOS_SUPPORT
InitTimers();
InitMonostables();
#endif
InitCounters();
InitTimersIEC();
InitArithmExpr();
InitRungs();
InitSections( );
#ifdef SEQUENTIAL_SUPPORT
InitSequential( );
#endif
InitSymbols( );
}
int StackTrace::GetCallStack(void* vcontext, Address* callStack, int maxDepth,
int entriesToSkip)
{
uintptr_t* ebpReg;
uintptr_t espReg;
__asm mov [ebpReg], ebp
__asm mov [espReg], esp
InitSymbols();
STACKFRAME64 stackFrame;
memset(&stackFrame, 0, sizeof(stackFrame));
PCONTEXT context = (PCONTEXT)vcontext;
if (context == 0)
{
stackFrame.AddrPC.Offset = ebpReg[1];
stackFrame.AddrFrame.Offset = ebpReg[0];
stackFrame.AddrStack.Offset = espReg;
}
else
{
InitStackFrameFromContext(context, stackFrame);
}
stackFrame.AddrPC.Mode = AddrModeFlat;
stackFrame.AddrFrame.Mode = AddrModeFlat;
stackFrame.AddrStack.Mode = AddrModeFlat;
HANDLE process = GetCurrentProcess();
HANDLE thread = GetCurrentThread();
int numEntries(0);
while (::StackWalk64(IMAGE_FILE_MACHINE_I386, process, thread,
&stackFrame, context, 0, SymFunctionTableAccess64, SymGetModuleBase64, NULL) &&
stackFrame.AddrFrame.Offset != 0 && numEntries < maxDepth)
{
if (entriesToSkip > 0)
--entriesToSkip;
else
callStack[numEntries++] = reinterpret_cast<Address>(stackFrame.AddrPC.Offset);
}
return numEntries;
}
bool appSymbolName(address_t addr, char *buffer, int size)
{
InitSymbols();
char SymBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)SymBuffer;
pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
pSymbol->MaxNameLen = MAX_SYM_NAME;
DWORD64 dwDisplacement = 0;
if (SymFromAddr(hProcess, addr, &dwDisplacement, pSymbol))
{
char OffsetBuffer[32];
if (dwDisplacement)
appSprintf(ARRAY_ARG(OffsetBuffer), "+%X", dwDisplacement);
else
OffsetBuffer[0] = 0;
#if EXTRA_UNDECORATE
char undecBuffer[256];
if (UnDecorateSymbolName(pSymbol->Name, ARRAY_ARG(undecBuffer),
UNDNAME_NO_LEADING_UNDERSCORES|UNDNAME_NO_LEADING_UNDERSCORES|UNDNAME_NO_ALLOCATION_LANGUAGE|UNDNAME_NO_ACCESS_SPECIFIERS))
{
StripPrefix(undecBuffer, "virtual ");
StripPrefix(undecBuffer, "class ");
StripPrefix(undecBuffer, "struct ");
appSprintf(buffer, size, "%s%s", undecBuffer, OffsetBuffer);
}
else
{
appSprintf(buffer, size, "%s%s", pSymbol->Name, OffsetBuffer);
}
#else
appSprintf(buffer, size, "%s%s", pSymbol->Name, OffsetBuffer);
#endif // EXTRA_UNDECORATE
}
else
{
appSprintf(buffer, size, "%08X", addr);
}
return true;
}
void StackTrace::GetCallStack(void* vcontext, bool includeArguments,
char* symbol, int maxSymbolLen)
{
PCONTEXT context = (PCONTEXT)vcontext;
if (context == 0)
return;
InitSymbols();
STACKFRAME64 stackFrame;
memset(&stackFrame, 0, sizeof(stackFrame));
InitStackFrameFromContext(context, stackFrame);
stackFrame.AddrPC.Mode = AddrModeFlat;
stackFrame.AddrFrame.Mode = AddrModeFlat;
stackFrame.AddrStack.Mode = AddrModeFlat;
while (maxSymbolLen > 0 &&
::StackWalk64(IMAGE_FILE_MACHINE_I386,
::GetCurrentProcess(), ::GetCurrentThread(), &stackFrame,
context, NULL, /*Internal_ReadProcessMemory,*/
SymFunctionTableAccess64, SymGetModuleBase64, NULL) != FALSE &&
stackFrame.AddrFrame.Offset != 0)
{
Address addr = reinterpret_cast<Address>(stackFrame.AddrPC.Offset);
int charsAdded = GetSymbolInfo(addr, symbol, maxSymbolLen);
maxSymbolLen -= charsAdded;
symbol += charsAdded;
if (maxSymbolLen > 0 && includeArguments)
{
charsAdded = _snprintf_s(symbol, maxSymbolLen, _TRUNCATE,
" (0x%08X 0x%08X 0x%08X 0x%08x)\n", stackFrame.Params[0],
stackFrame.Params[1], stackFrame.Params[2], stackFrame.Params[3]);
maxSymbolLen -= charsAdded;
symbol += charsAdded;
}
}
}
void PE_Debug::DumpSymbolInfo(std::ostream& dumpBuffer, DWORD relativeAddress )
{
// Variables to keep track of function symbols
PIMAGE_SYMBOL currentSym = COFFSymbolTable ;
PIMAGE_SYMBOL fnSymbol = NULL ;
DWORD maxFnAddress = 0 ;
#ifdef DUMPRAM
InitSymbols();
#endif
// Variables to keep track of file symbols
PIMAGE_SYMBOL fileSymbol = NULL ;
PIMAGE_SYMBOL latestFileSymbol = NULL ;
for ( int i = 0; i < COFFSymbolCount; i++ ) {
// Look for .text section where relativeAddress belongs to.
// Keep track of the filename the .text section belongs to.
if ( currentSym->StorageClass == IMAGE_SYM_CLASS_FILE ) {
latestFileSymbol = currentSym;
}
// Borland uses "CODE" instead of the standard ".text" entry
// Microsoft uses sections that only _begin_ with .text
const char* symName = GetSymbolName( currentSym ) ;
if ( strnicmp( symName, ".text", 5 ) == 0 || strcmpi( symName, "CODE" ) == 0 ) {
if ( currentSym->Value <= relativeAddress ) {
PIMAGE_AUX_SYMBOL auxSym = (PIMAGE_AUX_SYMBOL)(currentSym + 1) ;
if ( currentSym->Value + auxSym->Section.Length >= relativeAddress ) {
fileSymbol = latestFileSymbol ;
}
}
}
// Look for the function with biggest address <= relativeAddress
BOOL isFunction = ISFCN( currentSym->Type ); // Type == 0x20, See WINNT.H
if ( isFunction && ( currentSym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL || currentSym->StorageClass == IMAGE_SYM_CLASS_STATIC ) ) {
if ( currentSym->Value <= relativeAddress && currentSym->Value > maxFnAddress ) {
maxFnAddress = currentSym->Value ;
fnSymbol = currentSym ;
}
}
#ifdef DUMPRAM
if ( !isFunction && (currentSym->SectionNumber >= 0) ) {
if ( (symName[0]=='_' && symName[1]!='$') || (symName[0]=='?') ) {
char pretty_module[1024];
if ( fileSymbol ) {
const char* auxSym = (const char*)(latestFileSymbol + 1) ;
char tmpFile[ VA_MAX_FILENAME_LEN ] ;
strcpy_s( tmpFile, auxSym ) ;
strcpy_s( pretty_module, tmpFile );
char *p = pretty_module+strlen(pretty_module)-1;
// Move p to point to first letter of EXE filename
while( (*p!='\\') && (*p!='/') && (*p!=':') )
p--;
p++;
if ( strlen(p) < 1 ) {
strcpy_s( pretty_module, "<unknown>" );
} else {
memmove( pretty_module, p, strlen(p)+1 );
}
} else {
strcpy_s( pretty_module, "" );
}
Add_Symbol( currentSym->SectionNumber, currentSym->Value, symName, pretty_module );
}
}
#endif
// Advance counters, skip aux symbols
i += currentSym->NumberOfAuxSymbols ;
currentSym += currentSym->NumberOfAuxSymbols ;
currentSym++ ;
}
#ifdef DUMPRAM
DumpSymbols();
#endif
// dump symbolic info if found
if ( fileSymbol ) {
const char* auxSym = (const char*)(fileSymbol + 1) ;
if( strcmpi( latestFile, auxSym ) ) {
strcpy_s( latestFile, auxSym ) ;
//JAS dumpBuffer.Printf( " file: %s\r\n", auxSym ) ;
}
} else {
latestFile[ 0 ] = 0 ;
//JAS dumpBuffer.Printf( " file: unknown\r\n" ) ;
}
if ( fnSymbol ) {
char tmp_name[1024];
unmangle(tmp_name, GetSymbolName( fnSymbol ) );
dumpBuffer << " " << tmp_name << "()";
} else {
dumpBuffer << " <unknown>";
}
}
int StackTrace::GetSymbolInfo(Address address, char* symbol, int maxSymbolLen)
{
if (!InitSymbols())
return 0;
// Start with address.
int charsAdded =
_snprintf_s(symbol, maxSymbolLen, _TRUNCATE, "%p ", address);
symbol += charsAdded;
maxSymbolLen -= charsAdded;
if (maxSymbolLen < 0)
return charsAdded;
const DWORD64 address64 = (DWORD64)address;
// Module name
IMAGEHLP_MODULE64 moduleInfo;
ZeroMemory(&moduleInfo, sizeof(moduleInfo));
moduleInfo.SizeOfStruct = sizeof(moduleInfo);
const HANDLE hCurrentProcess = GetCurrentProcess();
if (SymGetModuleInfo64(hCurrentProcess, address64, &moduleInfo))
{
char moduleName[_MAX_PATH + 1];
GetFileFromPath(moduleInfo.ImageName, moduleName, _MAX_PATH);
const int moduleLen = (int)strlen(moduleName);
strncpy_s(symbol, maxSymbolLen, moduleName, _TRUNCATE);
symbol += moduleLen;
charsAdded += moduleLen;
maxSymbolLen -= moduleLen;
}
if (maxSymbolLen <= 0)
return charsAdded;
// Symbol name
ULONG64 symbolBuffer[(sizeof(SYMBOL_INFO) + MAX_SYM_NAME*sizeof(TCHAR) +
sizeof(ULONG64) - 1) / sizeof(ULONG64)] = { 0 };
IMAGEHLP_SYMBOL64* symbolInfo = reinterpret_cast<IMAGEHLP_SYMBOL64*>(symbolBuffer);
symbolInfo->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
symbolInfo->MaxNameLength = MAX_SYM_NAME;
DWORD64 disp(0);
if (SymGetSymFromAddr64(hCurrentProcess, address64, &disp, symbolInfo))
{
const int symbolChars =
_snprintf_s(symbol, maxSymbolLen, _TRUNCATE, " %s + 0x%X", symbolInfo->Name, disp);
symbol += symbolChars;
maxSymbolLen -= symbolChars;
charsAdded += symbolChars;
}
if (maxSymbolLen <= 0)
return charsAdded;
// File + line
DWORD displacementLine;
IMAGEHLP_LINE64 lineInfo;
ZeroMemory(&lineInfo, sizeof(lineInfo));
lineInfo.SizeOfStruct = sizeof(lineInfo);
if (SymGetLineFromAddr64(hCurrentProcess, address64, &displacementLine, &lineInfo))
{
char fileName[_MAX_PATH + 1];
GetFileFromPath(lineInfo.FileName, fileName, _MAX_PATH);
int fileLineChars(0);
if (displacementLine > 0)
{
fileLineChars = _snprintf_s(symbol, maxSymbolLen, _TRUNCATE,
" %s(%d+%04d byte(s))", fileName, lineInfo.LineNumber, displacementLine);
}
else
{
fileLineChars = _snprintf_s(symbol, maxSymbolLen, _TRUNCATE,
" %s(%d)", fileName, lineInfo.LineNumber);
}
symbol += fileLineChars;
maxSymbolLen -= fileLineChars;
charsAdded += fileLineChars;
}
return charsAdded;
}
