674 lines
23 KiB
C
674 lines
23 KiB
C
// Emacs style mode select -*- C++ -*-
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file
|
|
/// \brief Sources from GameDeveloper magazine article, January 1998, by Bruce Dawson.
|
|
/// this source file contains the exception handler for recording error
|
|
/// information after crashes.
|
|
|
|
|
|
#include <tchar.h>
|
|
#include "win_main.h"
|
|
#include "../doomdef.h" //just for VERSION
|
|
#include "win_dbg.h"
|
|
#include "../m_argv.h" //print the parameter in the log
|
|
|
|
LPTOP_LEVEL_EXCEPTION_FILTER prevExceptionFilter = NULL;
|
|
|
|
#ifdef BUGTRAP
|
|
|
|
|
|
typedef void (APIENTRY *BT_SETSUPPORTURL)(LPCTSTR pszSupportURL);
|
|
typedef void (APIENTRY *BT_SETFLAGS)(DWORD dwFlags);
|
|
typedef void (APIENTRY *BT_SETAPPNAME)(LPCTSTR pszAppName);
|
|
typedef void (APIENTRY *BT_SETAPPVERSION)(LPCTSTR pszAppVersion);
|
|
typedef void (APIENTRY *BT_SETSUPPORTSERVER)(LPCTSTR pszSupportHost, SHORT nSupportPort);
|
|
|
|
// BT constant definitions that we use, as given in the docs.
|
|
#define BTF_DETAILEDMODE 0x01
|
|
#define BTF_ATTACHREPORT 0x04
|
|
|
|
|
|
static HMODULE g_hmodBugTrap;
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Initialises the Bug Trap exception-handling library. Returns true iff
|
|
// successful.
|
|
// --------------------------------------------------------------------------
|
|
BOOL InitBugTrap(void)
|
|
{
|
|
BT_SETFLAGS lpfnBT_SetFlags;
|
|
BT_SETSUPPORTURL lpfnBT_SetSupportURL;
|
|
BT_SETAPPNAME lpfnBT_SetAppName;
|
|
BT_SETAPPVERSION lpfnBT_SetAppVersion;
|
|
BT_SETSUPPORTSERVER lpfnBT_SetSupportServer;
|
|
|
|
// Loading the library installs the exception handler.
|
|
#ifdef UNICODE
|
|
g_hmodBugTrap = LoadLibrary(L"BugTrapU.dll");
|
|
#else
|
|
g_hmodBugTrap = LoadLibrary("BugTrap.dll");
|
|
#endif
|
|
|
|
// Get the functions.
|
|
lpfnBT_SetFlags = (BT_SETFLAGS)GetProcAddress(g_hmodBugTrap, "BT_SetFlags");
|
|
lpfnBT_SetSupportURL = (BT_SETSUPPORTURL)GetProcAddress(g_hmodBugTrap, "BT_SetSupportURL");
|
|
lpfnBT_SetAppName = (BT_SETAPPNAME)GetProcAddress(g_hmodBugTrap, "BT_SetAppName");
|
|
lpfnBT_SetAppVersion = (BT_SETAPPVERSION)GetProcAddress(g_hmodBugTrap, "BT_SetAppVersion");
|
|
lpfnBT_SetSupportServer = (BT_SETSUPPORTSERVER)GetProcAddress(g_hmodBugTrap, "BT_SetSupportServer");
|
|
|
|
if (g_hmodBugTrap)
|
|
{
|
|
lpfnBT_SetAppName(TEXT("Sonic Robo Blast 2"));
|
|
lpfnBT_SetAppVersion(TEXT(VERSIONSTRING));
|
|
lpfnBT_SetFlags(BTF_DETAILEDMODE | BTF_ATTACHREPORT);
|
|
lpfnBT_SetSupportURL(TEXT("http://www.srb2.org/"));
|
|
lpfnBT_SetSupportServer(TEXT("srb2.org"), 9999);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Removes the BugTrap exception handler. Safe to call even if BT was never
|
|
// initialized.
|
|
// --------------------------------------------------------------------------
|
|
void ShutdownBugTrap(void)
|
|
{
|
|
if (g_hmodBugTrap) FreeLibrary(g_hmodBugTrap);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Simple test to check whether BugTrap is loaded without exposing its
|
|
// handle.
|
|
// --------------------------------------------------------------------------
|
|
BOOL IsBugTrapLoaded(void)
|
|
{
|
|
return !!g_hmodBugTrap;
|
|
}
|
|
|
|
#endif // (defined BUGTRAP)
|
|
|
|
|
|
#define NumCodeBytes 16 // Number of code bytes to record.
|
|
#define MaxStackDump 2048 // Maximum number of DWORDS in stack dumps.
|
|
#define StackColumns 8 // Number of columns in stack dump.
|
|
|
|
#define ONEK 1024
|
|
#define SIXTYFOURK (64*ONEK)
|
|
#define ONEM (ONEK*ONEK)
|
|
#define ONEG (ONEK*ONEK*ONEK)
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// return a description for an ExceptionCode
|
|
// --------------------------------------------------------------------------
|
|
static inline LPCSTR GetExceptionDescription(DWORD ExceptionCode)
|
|
{
|
|
size_t i;
|
|
|
|
struct ExceptionNames
|
|
{
|
|
DWORD ExceptionCode;
|
|
LPCSTR ExceptionName;
|
|
};
|
|
|
|
struct ExceptionNames ExceptionMap[] =
|
|
{
|
|
{EXCEPTION_ACCESS_VIOLATION, "an Access Violation"},
|
|
{EXCEPTION_ARRAY_BOUNDS_EXCEEDED, "a Array Bounds Exceeded"},
|
|
{EXCEPTION_BREAKPOINT, "a Breakpoint"},
|
|
{EXCEPTION_DATATYPE_MISALIGNMENT, "a Datatype Misalignment"},
|
|
{EXCEPTION_FLT_DENORMAL_OPERAND, "a Float Denormal Operand"},
|
|
{EXCEPTION_FLT_DIVIDE_BY_ZERO, "a Float Divide By Zero"},
|
|
{EXCEPTION_FLT_INEXACT_RESULT, "a Float Inexact Result"},
|
|
{EXCEPTION_FLT_INVALID_OPERATION, "a Float Invalid Operation"},
|
|
{EXCEPTION_FLT_OVERFLOW, "a Float Overflow"},
|
|
{EXCEPTION_FLT_STACK_CHECK, "a Float Stack Check"},
|
|
{EXCEPTION_FLT_UNDERFLOW, "a Float Underflow"},
|
|
{EXCEPTION_ILLEGAL_INSTRUCTION, "an Illegal Instruction"},
|
|
{EXCEPTION_IN_PAGE_ERROR, "an In Page Error"},
|
|
{EXCEPTION_INT_DIVIDE_BY_ZERO, "an Integer Divide By Zero"},
|
|
{EXCEPTION_INT_OVERFLOW, "an Integer Overflow"},
|
|
{EXCEPTION_INVALID_DISPOSITION, "an Invalid Disposition"},
|
|
{EXCEPTION_NONCONTINUABLE_EXCEPTION, "Noncontinuable Exception"},
|
|
{EXCEPTION_PRIV_INSTRUCTION, "a Privileged Instruction"},
|
|
{EXCEPTION_SINGLE_STEP, "a Single Step"},
|
|
{EXCEPTION_STACK_OVERFLOW, "a Stack Overflow"},
|
|
{0x40010005, "a Control-C"},
|
|
{0x40010008, "a Control-Break"},
|
|
{0xc0000006, "an In Page Error"},
|
|
{0xc0000017, "a No Memory"},
|
|
{0xc000001d, "an Illegal Instruction"},
|
|
{0xc0000025, "a Noncontinuable Exception"},
|
|
{0xc0000142, "a DLL Initialization Failed"},
|
|
{0xe06d7363, "a Microsoft C++ Exception"},
|
|
};
|
|
|
|
for (i = 0; i < (sizeof(ExceptionMap) / sizeof(ExceptionMap[0])); i++)
|
|
if (ExceptionCode == ExceptionMap[i].ExceptionCode)
|
|
return ExceptionMap[i].ExceptionName;
|
|
|
|
return "Unknown exception type";
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Directly output a formatted string to the errorlog file, using win32 funcs
|
|
// --------------------------------------------------------------------------
|
|
static VOID FPrintf(HANDLE fileHandle, LPCSTR lpFmt, ...)
|
|
{
|
|
CHAR str[1999];
|
|
va_list arglist;
|
|
DWORD bytesWritten;
|
|
|
|
va_start(arglist, lpFmt);
|
|
vsprintf(str, lpFmt, arglist);
|
|
va_end(arglist);
|
|
|
|
WriteFile(fileHandle, str, (DWORD)strlen(str), &bytesWritten, NULL);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Print the specified FILETIME to output in a human readable format,
|
|
// without using the C run time.
|
|
// --------------------------------------------------------------------------
|
|
static VOID PrintTime(LPSTR output, FILETIME TimeToPrint)
|
|
{
|
|
WORD Date, Time;
|
|
if (FileTimeToLocalFileTime(&TimeToPrint, &TimeToPrint) &&
|
|
FileTimeToDosDateTime(&TimeToPrint, &Date, &Time))
|
|
{
|
|
// What a silly way to print out the file date/time.
|
|
wsprintfA(output, "%d/%d/%d %02d:%02d:%02d",
|
|
(Date / 32) & 15, Date & 31, (Date / 512) + 1980,
|
|
(Time / 2048), (Time / 32) & 63, (Time & 31) * 2);
|
|
}
|
|
else
|
|
output[0] = 0;
|
|
}
|
|
|
|
|
|
static LPTSTR GetFilePart(LPTSTR source)
|
|
{
|
|
LPTSTR result = _tcsrchr(source, '\\');
|
|
if (result)
|
|
result++;
|
|
else
|
|
result = source;
|
|
return result;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Print information about a code module (DLL or EXE) such as its size,
|
|
// location, time stamp, etc.
|
|
// --------------------------------------------------------------------------
|
|
static VOID ShowModuleInfo(HANDLE LogFile, HMODULE ModuleHandle)
|
|
{
|
|
CHAR ModName[MAX_PATH];
|
|
IMAGE_DOS_HEADER *DosHeader;
|
|
IMAGE_NT_HEADERS *NTHeader;
|
|
HANDLE ModuleFile;
|
|
CHAR TimeBuffer[100] = "";
|
|
DWORD FileSize = 0;
|
|
#ifdef NO_SEH_MINGW
|
|
__try1(EXCEPTION_EXECUTE_HANDLER)
|
|
#else
|
|
__try
|
|
#endif
|
|
{
|
|
if (GetModuleFileNameA(ModuleHandle, ModName, sizeof(ModName)) > 0)
|
|
{
|
|
// If GetModuleFileName returns greater than zero then this must
|
|
// be a valid code module address. Therefore we can try to walk
|
|
// our way through its structures to find the link time stamp.
|
|
DosHeader = (IMAGE_DOS_HEADER*)ModuleHandle;
|
|
if (IMAGE_DOS_SIGNATURE != DosHeader->e_magic)
|
|
return;
|
|
NTHeader = (IMAGE_NT_HEADERS*)((char *)DosHeader
|
|
+ DosHeader->e_lfanew);
|
|
if (IMAGE_NT_SIGNATURE != NTHeader->Signature)
|
|
return;
|
|
// Open the code module file so that we can get its file date
|
|
// and size.
|
|
ModuleFile = CreateFileA(ModName, GENERIC_READ,
|
|
FILE_SHARE_READ, 0, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
if (ModuleFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
FILETIME LastWriteTime;
|
|
FileSize = GetFileSize(ModuleFile, 0);
|
|
if (GetFileTime(ModuleFile, 0, 0, &LastWriteTime))
|
|
{
|
|
wsprintfA(TimeBuffer, " - file date is ");
|
|
PrintTime(TimeBuffer + strlen(TimeBuffer), LastWriteTime);
|
|
}
|
|
CloseHandle(ModuleFile);
|
|
}
|
|
FPrintf(LogFile, "%s, loaded at 0x%08x - %d bytes - %08x%s\r\n",
|
|
ModName, ModuleHandle, FileSize,
|
|
NTHeader->FileHeader.TimeDateStamp, TimeBuffer);
|
|
}
|
|
}
|
|
// Handle any exceptions by continuing from this point.
|
|
#ifdef NO_SEH_MINGW
|
|
__except1
|
|
#else
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
#endif
|
|
{}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Scan memory looking for code modules (DLLs or EXEs). VirtualQuery is used
|
|
// to find all the blocks of address space that were reserved or committed,
|
|
// and ShowModuleInfo will display module information if they are code
|
|
// modules.
|
|
// --------------------------------------------------------------------------
|
|
static VOID RecordModuleList(HANDLE LogFile)
|
|
{
|
|
SYSTEM_INFO SystemInfo;
|
|
MEMORY_BASIC_INFORMATION MemInfo;
|
|
size_t PageSize;
|
|
size_t NumPages;
|
|
size_t pageNum = 0;
|
|
LPVOID LastAllocationBase = 0;
|
|
|
|
FPrintf(LogFile, "\r\n"
|
|
"\tModule list: names, addresses, sizes, time stamps "
|
|
"and file times:\r\n");
|
|
|
|
// Set NumPages to the number of pages in the 4GByte address space,
|
|
// while being careful to avoid overflowing ints.
|
|
GetSystemInfo(&SystemInfo);
|
|
PageSize = SystemInfo.dwPageSize;
|
|
NumPages = 4 * (size_t)(ONEG / PageSize);
|
|
while(pageNum < NumPages)
|
|
{
|
|
if (VirtualQuery((LPVOID)(pageNum * PageSize), &MemInfo,
|
|
sizeof(MemInfo)))
|
|
{
|
|
if (MemInfo.RegionSize > 0)
|
|
{
|
|
// Adjust the page number to skip over this block of memory.
|
|
pageNum += MemInfo.RegionSize / PageSize;
|
|
if (MemInfo.State == MEM_COMMIT && MemInfo.AllocationBase >
|
|
LastAllocationBase)
|
|
{
|
|
// Look for new blocks of committed memory, and try
|
|
// recording their module names - this will fail
|
|
// gracefully if they aren't code modules.
|
|
LastAllocationBase = MemInfo.AllocationBase;
|
|
ShowModuleInfo(LogFile, (HMODULE)LastAllocationBase);
|
|
}
|
|
}
|
|
else
|
|
pageNum += SIXTYFOURK / PageSize;
|
|
}
|
|
else
|
|
pageNum += SIXTYFOURK / PageSize;
|
|
// If VirtualQuery fails we advance by 64K because that is the
|
|
// granularity of address space doled out by VirtualAlloc().
|
|
}
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Record information about the user's system, such as processor type, amount
|
|
// of memory, etc.
|
|
// --------------------------------------------------------------------------
|
|
static VOID RecordSystemInformation(HANDLE fileHandle)
|
|
{
|
|
FILETIME CurrentTime;
|
|
CHAR TimeBuffer[100];
|
|
CHAR ModuleName[MAX_PATH];
|
|
CHAR UserName[200];
|
|
DWORD UserNameSize;
|
|
SYSTEM_INFO SystemInfo;
|
|
MEMORYSTATUS MemInfo;
|
|
|
|
GetSystemTimeAsFileTime(&CurrentTime);
|
|
PrintTime(TimeBuffer, CurrentTime);
|
|
FPrintf(fileHandle, "Error occurred at %s.\r\n", TimeBuffer);
|
|
|
|
if (GetModuleFileNameA(NULL, ModuleName, sizeof(ModuleName)) <= 0)
|
|
strcpy(ModuleName, "Unknown");
|
|
UserNameSize = sizeof(UserName);
|
|
if (!GetUserNameA(UserName, &UserNameSize))
|
|
strcpy(UserName, "Unknown");
|
|
FPrintf(fileHandle, "%s, run by %s.\r\n", ModuleName, UserName);
|
|
|
|
GetSystemInfo(&SystemInfo);
|
|
FPrintf(fileHandle, "%d processor(s), type %d %d.%d.\r\n"
|
|
"Program Memory from 0x%p to 0x%p\r\n",
|
|
SystemInfo.dwNumberOfProcessors,
|
|
SystemInfo.dwProcessorType,
|
|
SystemInfo.wProcessorLevel,
|
|
SystemInfo.wProcessorRevision,
|
|
SystemInfo.lpMinimumApplicationAddress,
|
|
SystemInfo.lpMaximumApplicationAddress);
|
|
|
|
MemInfo.dwLength = sizeof(MemInfo);
|
|
GlobalMemoryStatus(&MemInfo);
|
|
// Print out the amount of physical memory, rounded up.
|
|
FPrintf(fileHandle, "%d MBytes physical memory.\r\n", (MemInfo.dwTotalPhys +
|
|
ONEM - 1) / ONEM);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// What we do here is trivial : open a file, write out the register information
|
|
// from the PEXCEPTION_POINTERS structure, then return EXCEPTION_CONTINUE_SEARCH
|
|
// whose magic value tells Win32 to proceed with its normal error handling
|
|
// mechanism. This is important : an error dialog will popup if possible and
|
|
// the debugger will hopefully coexist peacefully with the structured exception
|
|
// handler.
|
|
// --------------------------------------------------------------------------
|
|
LONG WINAPI RecordExceptionInfo(PEXCEPTION_POINTERS data/*, LPCSTR Message, LPSTR lpCmdLine*/)
|
|
{
|
|
PEXCEPTION_RECORD Exception = NULL;
|
|
PCONTEXT Context = NULL;
|
|
TCHAR ModuleName[MAX_PATH];
|
|
TCHAR FileName[MAX_PATH] = TEXT("Unknown");
|
|
LPTSTR FilePart, lastperiod;
|
|
TCHAR CrashModulePathName[MAX_PATH];
|
|
LPCTSTR CrashModuleFileName = TEXT("Unknown");
|
|
MEMORY_BASIC_INFORMATION MemInfo;
|
|
static BOOL BeenHere = FALSE;
|
|
HANDLE fileHandle;
|
|
LPBYTE code = NULL;
|
|
int codebyte,i;
|
|
|
|
if (data)
|
|
{
|
|
Exception = data->ExceptionRecord;
|
|
Context = data->ContextRecord;
|
|
}
|
|
else if (prevExceptionFilter)
|
|
prevExceptionFilter(data);
|
|
else
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
|
|
if (BeenHere) // Going recursive! That must mean this routine crashed!
|
|
{
|
|
if (prevExceptionFilter)
|
|
return prevExceptionFilter(data);
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
BeenHere = TRUE;
|
|
|
|
if (Context)
|
|
{
|
|
#ifdef _X86_
|
|
code = (LPBYTE)(size_t)Context->Eip;
|
|
#elif defined (_AMD64_)
|
|
code = (LPBYTE)(size_t)Context->Rip;
|
|
#endif // || defined (_IA64_)
|
|
}
|
|
|
|
// Create a filename to record the error information to.
|
|
// Store it in the executable directory.
|
|
if (GetModuleFileName(NULL, ModuleName, sizeof(ModuleName)) <= 0)
|
|
ModuleName[0] = 0;
|
|
FilePart = GetFilePart(ModuleName);
|
|
|
|
// Extract the file name portion and remove it's file extension. We'll
|
|
// use that name shortly.
|
|
lstrcpy(FileName, FilePart);
|
|
lastperiod = _tcsrchr(FileName, '.');
|
|
if (lastperiod)
|
|
lastperiod[0] = 0;
|
|
// Replace the executable filename with our error log file name.
|
|
lstrcpy(FilePart, TEXT("errorlog.txt"));
|
|
fileHandle = CreateFile(ModuleName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL);
|
|
if (fileHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
OutputDebugString(TEXT("Error creating exception report"));
|
|
if (prevExceptionFilter)
|
|
prevExceptionFilter(data);
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
|
|
// Append to the error log.
|
|
SetFilePointer(fileHandle, 0, 0, FILE_END);
|
|
|
|
// Print out some blank lines to separate this error log from any previous ones.
|
|
FPrintf(fileHandle, "Email Sonic Team Junior so we can fix the bugs\r\n"); // Tails
|
|
FPrintf(fileHandle, "Make sure you tell us what you were doing to cause the crash, and if possible, record a demo!\r\n"); // Tails
|
|
FPrintf(fileHandle, "\r\n\r\n\r\n\r\n");
|
|
FPrintf(fileHandle, "SRB2 %s -ERROR LOG-\r\n\r\n", VERSIONSTRING);
|
|
FPrintf(fileHandle, "\r\n");
|
|
// VirtualQuery can be used to get the allocation base associated with a
|
|
// code address, which is the same as the ModuleHandle. This can be used
|
|
// to get the filename of the module that the crash happened in.
|
|
if (code && VirtualQuery(code, &MemInfo, sizeof(MemInfo)) &&
|
|
GetModuleFileName((HMODULE)MemInfo.AllocationBase,
|
|
CrashModulePathName,
|
|
sizeof(CrashModulePathName)) > 0)
|
|
CrashModuleFileName = GetFilePart(CrashModulePathName);
|
|
|
|
// Print out the beginning of the error log in a Win95 error window
|
|
// compatible format.
|
|
#ifdef _X86_
|
|
FPrintf(fileHandle, "%s caused %s in module %s at %04x:%08x.\r\n",
|
|
FileName, GetExceptionDescription(Exception->ExceptionCode),
|
|
CrashModuleFileName, Context->SegCs, Context->Eip);
|
|
#elif defined (_AMD64_)
|
|
FPrintf(fileHandle, "%s caused %s in module %s at %08x:%016x.\r\n",
|
|
FileName, GetExceptionDescription(Exception->ExceptionCode),
|
|
CrashModuleFileName, Context->SegCs, Context->Rip);
|
|
#else //defined (_IA64_)
|
|
FPrintf(fileHandle, "%s caused %s in module %s at ????.\r\n",
|
|
FileName, GetExceptionDescription(Exception->ExceptionCode),
|
|
CrashModuleFileName);
|
|
#endif
|
|
//if (&Message = Null)
|
|
FPrintf(fileHandle, "Exception handler called in %s.\r\n", "main thread");
|
|
//else
|
|
//FPrintf(fileHandle, "Exception handler called in %s.\r\n", Message);
|
|
|
|
RecordSystemInformation(fileHandle);
|
|
|
|
// If the exception was an access violation, print out some additional
|
|
// information, to the error log and the debugger.
|
|
if (Exception->ExceptionCode == STATUS_ACCESS_VIOLATION &&
|
|
Exception->NumberParameters >= 2)
|
|
{
|
|
TCHAR DebugMessage[1000];
|
|
LPCTSTR readwrite = TEXT("Read from");
|
|
if (Exception->ExceptionInformation[0])
|
|
readwrite = TEXT("Write to");
|
|
wsprintf(DebugMessage, TEXT("%s location %08x caused an access violation.\r\n"),
|
|
readwrite, Exception->ExceptionInformation[1]);
|
|
// The VisualC++ debugger doesn't actually tell you whether a read
|
|
// or a write caused the access violation, nor does it tell what
|
|
// address was being read or written. So I fixed that.
|
|
OutputDebugString(TEXT("Exception handler: "));
|
|
OutputDebugString(DebugMessage);
|
|
FPrintf(fileHandle, "%s", DebugMessage);
|
|
}
|
|
|
|
FPrintf(fileHandle, "\r\n");
|
|
|
|
// Print out the register values in a Win95 error window compatible format.
|
|
if ((Context->ContextFlags & CONTEXT_FULL) == CONTEXT_FULL)
|
|
{
|
|
FPrintf(fileHandle, "Registers:\r\n");
|
|
#ifdef _X86_
|
|
FPrintf(fileHandle, "EAX=%.8lx CS=%.4x EIP=%.8lx EFLGS=%.8lx\r\n",
|
|
Context->Eax,Context->SegCs,Context->Eip,Context->EFlags);
|
|
FPrintf(fileHandle, "EBX=%.8lx SS=%.4x ESP=%.8lx EBP=%.8lx\r\n",
|
|
Context->Ebx,Context->SegSs,Context->Esp,Context->Ebp);
|
|
FPrintf(fileHandle, "ECX=%.8lx DS=%.4x ESI=%.8lx FS=%.4x\r\n",
|
|
Context->Ecx,Context->SegDs,Context->Esi,Context->SegFs);
|
|
FPrintf(fileHandle, "EDX=%.8lx ES=%.4x EDI=%.8lx GS=%.4x\r\n",
|
|
Context->Edx,Context->SegEs,Context->Edi,Context->SegGs);
|
|
#elif defined (_AMD64_)
|
|
FPrintf(fileHandle, "RAX=%.16lx CS=%.8x RIP=%.16lx EFLGS=%.16lx\r\n",
|
|
Context->Rax,Context->SegCs,Context->Rip,Context->EFlags);
|
|
FPrintf(fileHandle, "RBX=%.16lx SS=%.8x RSP=%.16lx EBP=%.16lx\r\n",
|
|
Context->Rbx,Context->SegSs,Context->Rsp,Context->Rbp);
|
|
FPrintf(fileHandle, "RCX=%.16lx DS=%.8x RSI=%.16lx FS=%.8x\r\n",
|
|
Context->Rcx,Context->SegDs,Context->Rsi,Context->SegFs);
|
|
FPrintf(fileHandle, "RDX=%.16lx ES=%.8x RDI=%.16lx GS=%.8x\r\n",
|
|
Context->Rdx,Context->SegEs,Context->Rdi,Context->SegGs);
|
|
#else //defined (_IA64_)
|
|
FPrintf(fileHandle, "Unknown CPU type\r\n");
|
|
#endif
|
|
}
|
|
|
|
// moved down because it was causing the printout to stop
|
|
FPrintf(fileHandle, "Command Line parameters: ");
|
|
for(i = 1;i < myargc;i++)
|
|
FPrintf(fileHandle, "%s ", myargv[i]);
|
|
|
|
FPrintf(fileHandle, "Bytes at CS : EIP:\r\n");
|
|
|
|
// Print out the bytes of code at the instruction pointer. Since the
|
|
// crash may have been caused by an instruction pointer that was bad,
|
|
// this code needs to be wrapped in an exception handler, in case there
|
|
// is no memory to read. If the dereferencing of code[] fails, the
|
|
// exception handler will print '??'.
|
|
if (code)
|
|
for(codebyte = 0; codebyte < NumCodeBytes; codebyte++)
|
|
{
|
|
#ifdef NO_SEH_MINGW
|
|
__try1(EXCEPTION_EXECUTE_HANDLER)
|
|
#else
|
|
__try
|
|
#endif
|
|
{
|
|
FPrintf(fileHandle, "%02x ", code[codebyte]);
|
|
}
|
|
#ifdef NO_SEH_MINGW
|
|
__except1
|
|
#else
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
#endif
|
|
{
|
|
FPrintf(fileHandle, "?? ");
|
|
}
|
|
}
|
|
|
|
// Time to print part or all of the stack to the error log. This allows
|
|
// us to figure out the call stack, parameters, local variables, etc.
|
|
FPrintf(fileHandle, "\r\n"
|
|
"Stack dump:\r\n");
|
|
#ifdef NO_SEH_MINGW
|
|
__try1(EXCEPTION_EXECUTE_HANDLER)
|
|
#else
|
|
__try
|
|
#endif
|
|
{
|
|
// Esp contains the bottom of the stack, or at least the bottom of
|
|
// the currently used area.
|
|
LPDWORD pStack = NULL;
|
|
LPDWORD pStackTop = NULL;
|
|
size_t Count = 0;
|
|
TCHAR buffer[1000] = TEXT("");
|
|
const int safetyzone = 50;
|
|
LPTSTR nearend = buffer + sizeof(buffer) - safetyzone*sizeof(TCHAR);
|
|
LPTSTR output = buffer;
|
|
LPCVOID Suffix;
|
|
|
|
#ifdef _X86_
|
|
pStack = (LPDWORD)(size_t)Context->Esp;
|
|
#elif defined (_AMD64_)
|
|
pStack = (LPDWORD)(size_t)Context->Rsp;
|
|
#endif // defined (_IA64_)
|
|
|
|
|
|
// Load the top (highest address) of the stack from the
|
|
// thread information block. It will be found there in
|
|
// Win9x and Windows NT.
|
|
#ifdef _X86_
|
|
#ifdef __GNUC__
|
|
__asm__("movl %%fs : 4, %%eax": "=a"(pStackTop));
|
|
#elif defined (_MSC_VER)
|
|
__asm
|
|
{
|
|
mov eax, fs:[4]
|
|
mov pStackTop, eax
|
|
}
|
|
#endif
|
|
#elif defined (_AMD64_)
|
|
#ifdef __GNUC__
|
|
__asm__("mov %%gs : 4, %%rax": "=a"(pStackTop));
|
|
#elif defined (_MSC_VER)
|
|
/*
|
|
__asm
|
|
{
|
|
mov rax, fs:[4]
|
|
mov pStackTop, rax
|
|
}
|
|
*/
|
|
#endif
|
|
#endif
|
|
if (pStackTop == NULL)
|
|
goto StackSkip;
|
|
else if (pStackTop > pStack + MaxStackDump)
|
|
pStackTop = pStack + MaxStackDump;
|
|
// Too many calls to WriteFile can take a long time, causing
|
|
// confusing delays when programs crash. Therefore I implemented
|
|
// simple buffering for the stack dumping code instead of calling
|
|
// FPrintf directly.
|
|
while(pStack + 1 <= pStackTop)
|
|
{
|
|
if ((Count % StackColumns) == 0)
|
|
output += wsprintf(output, TEXT("%p: "), pStack);
|
|
if ((++Count % StackColumns) == 0 || pStack + 2 > pStackTop)
|
|
Suffix = TEXT("\r\n");
|
|
else
|
|
Suffix = TEXT(" ");
|
|
output += wsprintf(output, TEXT("%p%s"), *pStack, Suffix);
|
|
pStack++;
|
|
// Check for when the buffer is almost full, and flush it to disk.
|
|
if ( output > nearend)
|
|
{
|
|
FPrintf(fileHandle, "%s", buffer);
|
|
buffer[0] = 0;
|
|
output = buffer;
|
|
}
|
|
}
|
|
// Print out any final characters from the cache.
|
|
StackSkip:
|
|
FPrintf(fileHandle, "%s", buffer);
|
|
}
|
|
#ifdef NO_SEH_MINGW
|
|
__except1
|
|
#else
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
#endif
|
|
{
|
|
FPrintf(fileHandle, "Exception encountered during stack dump.\r\n");
|
|
}
|
|
|
|
RecordModuleList(fileHandle);
|
|
|
|
CloseHandle(fileHandle);
|
|
|
|
// Return the magic value which tells Win32 that this handler didn't
|
|
// actually handle the exception - so that things will proceed as per
|
|
// normal.
|
|
//BP: should put message for end user to send this file to fix any bug
|
|
if (prevExceptionFilter)
|
|
return prevExceptionFilter(data);
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|