630 lines
21 KiB
C
630 lines
21 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
|
|
|
|
|
|
#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 LPCSTR GetExceptionDescription (DWORD ExceptionCode)
|
|
{
|
|
unsigned int 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;
|
|
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 * (unsigned int)(ONEG / PageSize);
|
|
while (pageNum < NumPages)
|
|
{
|
|
MEMORY_BASIC_INFORMATION MemInfo;
|
|
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.
|
|
// --------------------------------------------------------------------------
|
|
int __cdecl RecordExceptionInfo (PEXCEPTION_POINTERS data/*, LPCSTR Message, LPSTR lpCmdLine*/)
|
|
{
|
|
PEXCEPTION_RECORD Exception;
|
|
PCONTEXT Context;
|
|
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 int BeenHere = false;
|
|
HANDLE fileHandle;
|
|
UINT8 *code;
|
|
int codebyte,i;
|
|
|
|
if (data)
|
|
{
|
|
Exception = data->ExceptionRecord;
|
|
Context = data->ContextRecord;
|
|
}
|
|
else
|
|
{
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
|
|
if (BeenHere) // Going recursive! That must mean this routine crashed!
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
BeenHere = true;
|
|
|
|
// 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"));
|
|
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 (VirtualQuery ((LPVOID)(size_t)Context->Eip, &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.
|
|
FPrintf (fileHandle, "%s caused an %s in module %s at %04x:%08x.\r\n",
|
|
FileName, GetExceptionDescription(Exception->ExceptionCode),
|
|
CrashModuleFileName, Context->SegCs, Context->Eip);
|
|
//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]);
|
|
#ifdef _DEBUG
|
|
// 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);
|
|
#endif
|
|
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");
|
|
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);
|
|
}
|
|
|
|
// 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 '??'.
|
|
code = (UINT8 *)(size_t)Context->Eip;
|
|
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.
|
|
DWORD* pStack = (DWORD *)(size_t)Context->Esp;
|
|
DWORD* 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;
|
|
const void *Suffix;
|
|
|
|
// Load the top (highest address) of the stack from the
|
|
// thread information block. It will be found there in
|
|
// Win9x and Windows NT.
|
|
#ifdef __GNUC__
|
|
__asm__("movl %%fs : 4, %%eax": "=a"(pStackTop));
|
|
#else
|
|
__asm
|
|
{
|
|
mov eax, fs:[4]
|
|
mov pStackTop, eax
|
|
}
|
|
#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("%08x: "), pStack);
|
|
if ((++Count % StackColumns) == 0 || pStack + 2 > pStackTop)
|
|
Suffix = TEXT("\r\n");
|
|
else
|
|
Suffix = TEXT(" ");
|
|
output += wsprintf(output, TEXT("%08x%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
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
|
|
/*
|
|
//
|
|
//FPrintf ("e-mail this file to legacy@newdoom.com, so that we can fix the problem.\r\n\r\n");
|
|
|
|
FPrintf ("Exception handler called in %s.\r\n", Message);
|
|
|
|
GetSystemTime (&systemTime);
|
|
FPrintf ("Error occured at %02d/%02d/%04d %02d:%02d:%02d.\r\n",
|
|
systemTime.wMonth, systemTime.wDay, systemTime.wYear,
|
|
systemTime.wHour, systemTime.wMinute, systemTime.wSecond);
|
|
|
|
|
|
FPrintf ("%s\r\n", filename);
|
|
FPrintf ("Cmd-line: %s\r\n", lpCmdLine);
|
|
|
|
// Nested exceptions can occur, get info for each one
|
|
|
|
nER = 1;
|
|
while (ER)
|
|
{
|
|
if (nER++>1)
|
|
FPrintf ("Exception Record %d.\r\n", nER);
|
|
|
|
FPrintf ("application caused an %s", GetExceptionCodeStr(Exception->ExceptionCode));
|
|
|
|
if (Context->ContextFlags & CONTEXT_CONTROL)
|
|
FPrintf (" at %.4x:%.8x.\r\n", Context->SegCs, Context->Eip);
|
|
|
|
// in case of..
|
|
if (Context->Eip != (unsigned long)Exception->ExceptionAddress)
|
|
FPrintf ("Exception Address = %.8x\r\n", Exception->ExceptionAddress);
|
|
|
|
if (Exception->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
|
|
{
|
|
FPrintf ("\r\n%s location 0x%x caused an access violation.\r\n",
|
|
(Exception->ExceptionInformation[0] ? "Write to" : "Read from"),
|
|
Exception->ExceptionInformation[1]);
|
|
}
|
|
|
|
ER = Exception->ExceptionRecord;
|
|
}
|
|
|
|
|
|
if (Context->ContextFlags & CONTEXT_DEBUG_REGISTERS)
|
|
{
|
|
FPrintf ("\r\nDebug Registers:\r\n");
|
|
FPrintf ("Dr0=%.8x Dr1=%.8x Dr2=%.8x\r\n"
|
|
"Dr3=%.8x Dr6=%.8x Dr7=%.8x\r\n",
|
|
Context->Dr0, Context->Dr1, Context->Dr2,
|
|
Context->Dr3, Context->Dr6, Context->Dr7);
|
|
}
|
|
|
|
if (Context->ContextFlags & CONTEXT_FLOATING_POINT)
|
|
{
|
|
FPrintf ("\r\nFloating Save Area:\r\n");
|
|
FPrintf ("ControlWord =%.8x TagWord =%.8x ErrorSelector=%.8x DataSelector =%.8x\r\n"
|
|
"StatusWord =%.8x ErrorOffset =%.8x DataOffset =%.8x Cr0NpxState =%.8x\r\n",
|
|
Context->FloatSave.ControlWord, Context->FloatSave.TagWord, Context->FloatSave.ErrorSelector, Context->FloatSave.DataSelector,
|
|
Context->FloatSave.StatusWord, Context->FloatSave.ErrorOffset, Context->FloatSave.DataOffset, Context->FloatSave.Cr0NpxState
|
|
);
|
|
|
|
//BYTE RegisterArea[SIZE_OF_80387_REGISTERS];
|
|
}
|
|
|
|
|
|
// in case of...
|
|
if ((Context->ContextFlags & CONTEXT_FULL) != CONTEXT_FULL)
|
|
{
|
|
if (!(Context->ContextFlags & CONTEXT_SEGMENTS))
|
|
FPrintf ("Note! GS,FS,ES,DS are unspecified\r\n");
|
|
if (!(Context->ContextFlags & CONTEXT_INTEGER))
|
|
FPrintf ("Note! EDI,ESI,EBX,EDX,ECX,EAX are unspecified\r\n");
|
|
if (!(Context->ContextFlags & CONTEXT_CONTROL))
|
|
FPrintf ("Note! EBP,CS : EIP,EFlags,SS : ESP are unspecified\r\n");
|
|
}
|
|
|
|
FPrintf ("\r\nBytes at CS : EIP:\r\n");
|
|
ucptr = (UINT8 *)Context->Eip;
|
|
for (i = 0; i < 16; i++)
|
|
FPrintf ("%.2x ", *ucptr++);
|
|
|
|
FPrintf ("\r\n\r\nStack dump:\r\n");
|
|
ulptr = (unsigned long*)Context->Esp;
|
|
for (i = 0; i < 16; i++)
|
|
FPrintf ("%.8x ", *ulptr++);
|
|
|
|
//FPrintf ("Bytes at CS : EIP:\r\n");
|
|
//FPrintf ("%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x ");
|
|
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
FPrintf ("%x
|
|
}
|
|
*/
|