random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/ExceptionHandler.cpp

854 lines
23 KiB
C++
Raw Permalink Blame History

/*
* ExceptionHandler.cpp
* --------------------
* Purpose: Code for handling crashes (unhandled exceptions) in OpenMPT.
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Mainfrm.h"
#include "Mptrack.h"
#include "AboutDialog.h"
#include "InputHandler.h"
#include "openmpt/sounddevice/SoundDevice.hpp"
#include "Moddoc.h"
#include <shlwapi.h>
#include "ExceptionHandler.h"
#include "../misc/WriteMemoryDump.h"
#include "../common/version.h"
#include "../common/mptFileIO.h"
#include "../soundlib/mod_specifications.h"
#include <atomic>
OPENMPT_NAMESPACE_BEGIN
// Write full memory dump instead of minidump.
bool ExceptionHandler::fullMemDump = false;
bool ExceptionHandler::stopSoundDeviceOnCrash = true;
bool ExceptionHandler::stopSoundDeviceBeforeDump = false;
// Delegate to system-specific crash processing once our own crash handler is
// finished. This is useful to allow attaching a debugger.
bool ExceptionHandler::delegateToWindowsHandler = false;
// Allow debugging the unhandled exception filter. Normally, if a debugger is
// attached, no exceptions are unhandled because the debugger handles them. If
// debugExceptionHandler is true, an additional __try/__catch is inserted around
// InitInstance(), ExitInstance() and the main message loop, which will call our
// filter, which then can be stepped through in a debugger.
bool ExceptionHandler::debugExceptionHandler = false;
bool ExceptionHandler::useAnyCrashHandler = false;
bool ExceptionHandler::useImplicitFallbackSEH = false;
bool ExceptionHandler::useExplicitSEH = false;
bool ExceptionHandler::handleStdTerminate = false;
bool ExceptionHandler::handleMfcExceptions = false;
static thread_local ExceptionHandler::Context *g_Context = nullptr;
static LPTOP_LEVEL_EXCEPTION_FILTER g_OriginalUnhandledExceptionFilter = nullptr;
static std::terminate_handler g_OriginalTerminateHandler = nullptr;
static UINT g_OriginalErrorMode = 0;
ExceptionHandler::Context *ExceptionHandler::SetContext(Context *newContext) noexcept
{
Context *oldContext = g_Context;
g_Context = newContext;
return oldContext;
}
static std::atomic<int> & g_CrashCount()
{
static std::atomic<int> s_CrashCount(0);
return s_CrashCount;
}
static std::atomic<int> & g_TaintCountDriver()
{
static std::atomic<int> s_TaintCountDriver(0);
return s_TaintCountDriver;
}
static std::atomic<int> & g_TaintCountPlugin()
{
static std::atomic<int> s_TaintCountPlugin(0);
return s_TaintCountPlugin;
}
void ExceptionHandler::TaintProcess(ExceptionHandler::TaintReason reason)
{
switch(reason)
{
case ExceptionHandler::TaintReason::Driver:
g_TaintCountDriver().fetch_add(1);
break;
case ExceptionHandler::TaintReason::Plugin:
g_TaintCountPlugin().fetch_add(1);
break;
default:
MPT_ASSERT_NOTREACHED();
break;
}
}
enum DumpMode
{
DumpModeCrash = 0, // crash
DumpModeWarning = 1, // assert
DumpModeDebug = 2, // debug output (e.g. trace log)
};
struct CrashOutputDirectory
{
bool valid;
mpt::PathString path;
CrashOutputDirectory()
: valid(true)
{
const mpt::PathString timestampDir = mpt::PathString::FromCString((CTime::GetCurrentTime()).Format(_T("%Y-%m-%d %H.%M.%S\\")));
// Create a crash directory
path = mpt::GetTempDirectory() + P_("OpenMPT Crash Files\\");
if(!path.IsDirectory())
{
CreateDirectory(path.AsNative().c_str(), nullptr);
}
// Set compressed attribute in order to save disk space.
// Debugging information should clutter the users computer as little as possible.
// Performance is not important here.
// Ignore any errors.
SetFilesystemCompression(path);
// Compression will be inherited by children directories and files automatically.
path += timestampDir;
if(!path.IsDirectory())
{
if(!CreateDirectory(path.AsNative().c_str(), nullptr))
{
valid = false;
}
}
}
};
class DebugReporter
{
private:
int crashCount;
int taintCountDriver;
int taintCountPlugin;
bool stateFrozen;
const DumpMode mode;
const CrashOutputDirectory crashDirectory;
bool writtenMiniDump;
bool writtenTraceLog;
int rescuedFiles;
private:
static bool FreezeState(DumpMode mode);
static bool Cleanup(DumpMode mode);
bool GenerateDump(_EXCEPTION_POINTERS *pExceptionInfo);
bool GenerateTraceLog();
int RescueFiles();
bool HasWrittenDebug() const { return writtenMiniDump || writtenTraceLog; }
static void StopSoundDevice();
public:
DebugReporter(DumpMode mode, _EXCEPTION_POINTERS *pExceptionInfo);
~DebugReporter();
void ReportError(mpt::ustring errorMessage);
};
DebugReporter::DebugReporter(DumpMode mode, _EXCEPTION_POINTERS *pExceptionInfo)
: crashCount(g_CrashCount().fetch_add(1) + 1)
, taintCountDriver(g_TaintCountDriver().load())
, taintCountPlugin(g_TaintCountPlugin().load())
, stateFrozen(FreezeState(mode))
, mode(mode)
, writtenMiniDump(false)
, writtenTraceLog(false)
, rescuedFiles(0)
{
if(mode == DumpModeCrash || mode == DumpModeWarning)
{
writtenMiniDump = GenerateDump(pExceptionInfo);
}
if(mode == DumpModeCrash || mode == DumpModeWarning || mode == DumpModeDebug)
{
writtenTraceLog = GenerateTraceLog();
}
if(mode == DumpModeCrash || mode == DumpModeWarning)
{
rescuedFiles = RescueFiles();
}
}
DebugReporter::~DebugReporter()
{
Cleanup(mode);
}
bool DebugReporter::GenerateDump(_EXCEPTION_POINTERS *pExceptionInfo)
{
return WriteMemoryDump(pExceptionInfo, (crashDirectory.path + P_("crash.dmp")).AsNative().c_str(), ExceptionHandler::fullMemDump);
}
bool DebugReporter::GenerateTraceLog()
{
return mpt::log::Trace::Dump(crashDirectory.path + P_("trace.log"));
}
static void SaveDocumentSafe(CModDoc *pModDoc, const mpt::PathString &filename)
{
__try
{
pModDoc->OnSaveDocument(filename);
} __except(EXCEPTION_EXECUTE_HANDLER)
{
// nothing
}
}
// Rescue modified files...
int DebugReporter::RescueFiles()
{
int numFiles = 0;
auto documents = theApp.GetOpenDocuments();
for(auto modDoc : documents)
{
if(modDoc->IsModified())
{
if(numFiles == 0)
{
// Show the rescue directory in Explorer...
CTrackApp::OpenDirectory(crashDirectory.path);
}
mpt::PathString filename;
filename += crashDirectory.path;
filename += mpt::PathString::FromUnicode(mpt::ufmt::val(++numFiles));
filename += P_("_");
filename += mpt::PathString::FromCString(modDoc->GetTitle()).SanitizeComponent();
filename += P_(".");
filename += mpt::PathString::FromUTF8(modDoc->GetSoundFile().GetModSpecifications().fileExtension);
try
{
SaveDocumentSafe(modDoc, filename);
} catch(...)
{
continue;
}
}
}
return numFiles;
}
void DebugReporter::ReportError(mpt::ustring errorMessage)
{
if(!crashDirectory.valid)
{
errorMessage += UL_("\n\n");
errorMessage += UL_("Could not create the following directory for saving debug information and modified files to:\n");
errorMessage += crashDirectory.path.ToUnicode();
}
if(HasWrittenDebug())
{
errorMessage += UL_("\n\n");
errorMessage += UL_("Debug information has been saved to\n");
errorMessage += crashDirectory.path.ToUnicode();
}
if(rescuedFiles > 0)
{
errorMessage += UL_("\n\n");
if(rescuedFiles == 1)
{
errorMessage += UL_("1 modified file has been rescued, but it cannot be guaranteed that it is still intact.");
} else
{
errorMessage += MPT_UFORMAT("{} modified files have been rescued, but it cannot be guaranteed that they are still intact.")(rescuedFiles);
}
}
errorMessage += UL_("\n\n");
errorMessage += MPT_UFORMAT("OpenMPT {} {} ({} ({}))")
( Build::GetVersionStringExtended()
, mpt::OS::Windows::Name(mpt::OS::Windows::GetProcessArchitecture())
, SourceInfo::Current().GetUrlWithRevision()
, SourceInfo::Current().GetStateString()
);
errorMessage += UL_("\n\n");
errorMessage += MPT_UFORMAT("Session error count: {}\n")(crashCount);
if(taintCountDriver > 0 || taintCountPlugin > 0)
{
errorMessage += UL_("Process is in tainted state!\n");
errorMessage += MPT_UFORMAT("Previously masked driver crashes: {}\n")(taintCountDriver);
errorMessage += MPT_UFORMAT("Previously masked plugin crashes: {}\n")(taintCountPlugin);
}
errorMessage += UL_("\n");
{
mpt::SafeOutputFile sf(crashDirectory.path + P_("error.txt"), std::ios::binary, mpt::FlushMode::Full);
mpt::ofstream& f = sf;
f.imbue(std::locale::classic());
f << mpt::replace(mpt::ToCharset(mpt::Charset::UTF8, errorMessage), std::string("\n"), std::string("\r\n"));
}
if(auto ih = CMainFrame::GetInputHandler(); ih != nullptr)
{
mpt::SafeOutputFile sf(crashDirectory.path + P_("last-commands.txt"), std::ios::binary, mpt::FlushMode::Full);
mpt::ofstream &f = sf;
f.imbue(std::locale::classic());
const auto commandSet = ih->m_activeCommandSet.get();
f << "Last commands:\n";
for(size_t i = 0; i < ih->m_lastCommands.size(); i++)
{
CommandID id = ih->m_lastCommands[(ih->m_lastCommandPos + i) % ih->m_lastCommands.size()];
if(id == kcNull)
continue;
f << mpt::afmt::val(id);
if(commandSet)
f << " (" << mpt::ToCharset(mpt::Charset::UTF8, commandSet->GetCommandText(id)) << ")";
f << "\n";
}
}
{
mpt::SafeOutputFile sf(crashDirectory.path + P_("threads.txt"), std::ios::binary, mpt::FlushMode::Full);
mpt::ofstream& f = sf;
f.imbue(std::locale::classic());
f << MPT_AFORMAT("current : {}")(mpt::afmt::hex0<8>(GetCurrentThreadId())) << "\r\n";
f << MPT_AFORMAT("GUI : {}")(mpt::afmt::hex0<8>(mpt::log::Trace::GetThreadId(mpt::log::Trace::ThreadKindGUI))) << "\r\n";
f << MPT_AFORMAT("Audio : {}")(mpt::afmt::hex0<8>(mpt::log::Trace::GetThreadId(mpt::log::Trace::ThreadKindAudio))) << "\r\n";
f << MPT_AFORMAT("Notify : {}")(mpt::afmt::hex0<8>(mpt::log::Trace::GetThreadId(mpt::log::Trace::ThreadKindNotify))) << "\r\n";
f << MPT_AFORMAT("WatchDir: {}")(mpt::afmt::hex0<8>(mpt::log::Trace::GetThreadId(mpt::log::Trace::ThreadKindWatchdir))) << "\r\n";
}
static constexpr struct { const mpt::uchar * section; const mpt::uchar * key; } configAnonymize[] =
{
{ UL_("Version"), UL_("InstallGUID") },
{ UL_("Recent File List"), nullptr },
};
{
mpt::SafeOutputFile sf(crashDirectory.path + P_("active-settings.txt"), std::ios::binary, mpt::FlushMode::Full);
mpt::ofstream& f = sf;
f.imbue(std::locale::classic());
if(theApp.GetpSettings())
{
SettingsContainer &settings = theApp.GetSettings();
for(const auto &it : settings)
{
bool skipPath = false;
for(const auto &path : configAnonymize)
{
if((path.key == nullptr && path.section == it.first.GetRefSection()) // Omit entire section
|| (path.key != nullptr && it.first == SettingPath(path.section, path.key))) // Omit specific key
{
skipPath = true;
}
}
if(skipPath)
{
continue;
}
f
<< mpt::ToCharset(mpt::Charset::UTF8, it.first.FormatAsString() + U_(" = ") + it.second.GetRefValue().FormatValueAsString())
<< std::endl;
}
}
}
{
const mpt::PathString crashStoredSettingsFilename = crashDirectory.path + P_("stored-mptrack.ini");
CopyFile
( theApp.GetConfigFileName().AsNative().c_str()
, crashStoredSettingsFilename.AsNative().c_str()
, FALSE
);
IniFileSettingsContainer crashStoredSettings{crashStoredSettingsFilename};
for(const auto &path : configAnonymize)
{
if(path.key)
{
crashStoredSettings.Write(SettingPath(path.section, path.key), SettingValue(mpt::ustring()));
} else
{
crashStoredSettings.Remove(path.section);
}
}
crashStoredSettings.Flush();
}
/*
// This is very slow, we instead write active-settings.txt above.
{
IniFileSettingsBackend f(crashDirectory.path + P_("active-mptrack.ini"));
if(theApp.GetpSettings())
{
SettingsContainer & settings = theApp.GetSettings();
for(const auto &it : settings)
{
f.WriteSetting(it.first, it.second.GetRefValue());
}
}
}
*/
{
mpt::SafeOutputFile sf(crashDirectory.path + P_("about-openmpt.txt"), std::ios::binary, mpt::FlushMode::Full);
mpt::ofstream& f = sf;
f.imbue(std::locale::classic());
f << mpt::ToCharset(mpt::Charset::UTF8, CAboutDlg::GetTabText(0));
}
{
mpt::SafeOutputFile sf(crashDirectory.path + P_("about-components.txt"), std::ios::binary, mpt::FlushMode::Full);
mpt::ofstream& f = sf;
f.imbue(std::locale::classic());
f << mpt::ToCharset(mpt::Charset::UTF8, CAboutDlg::GetTabText(1));
}
Reporting::Error(errorMessage, (mode == DumpModeWarning) ? "OpenMPT Warning" : "OpenMPT Crash", CMainFrame::GetMainFrame());
}
// Freezes the state as much as possible in order to avoid further confusion by
// other (possibly still running) threads
bool DebugReporter::FreezeState(DumpMode mode)
{
MPT_TRACE();
// seal the trace log as early as possible
mpt::log::Trace::Seal();
if(mode == DumpModeCrash || mode == DumpModeWarning)
{
if(CMainFrame::GetMainFrame() && CMainFrame::GetMainFrame()->gpSoundDevice && CMainFrame::GetMainFrame()->gpSoundDevice->DebugIsFragileDevice())
{
// For fragile devices, always stop the device. Stop before the dumping if not in realtime context.
if(!CMainFrame::GetMainFrame()->gpSoundDevice->DebugInRealtimeCallback())
{
StopSoundDevice();
}
} else
{
if(ExceptionHandler::stopSoundDeviceOnCrash && ExceptionHandler::stopSoundDeviceBeforeDump)
{
StopSoundDevice();
}
}
}
return true;
}
static void StopSoundDeviceSafe(CMainFrame *pMainFrame)
{
__try
{
if(pMainFrame->gpSoundDevice)
{
pMainFrame->gpSoundDevice->Close();
}
if(pMainFrame->m_NotifyTimer)
{
pMainFrame->KillTimer(pMainFrame->m_NotifyTimer);
pMainFrame->m_NotifyTimer = 0;
}
} __except(EXCEPTION_EXECUTE_HANDLER)
{
// nothing
}
}
void DebugReporter::StopSoundDevice()
{
CMainFrame* pMainFrame = CMainFrame::GetMainFrame();
if(pMainFrame)
{
try
{
StopSoundDeviceSafe(pMainFrame);
} catch(...)
{
// nothing
}
}
}
bool DebugReporter::Cleanup(DumpMode mode)
{
MPT_TRACE();
if(mode == DumpModeCrash || mode == DumpModeWarning)
{
if(CMainFrame::GetMainFrame() && CMainFrame::GetMainFrame()->gpSoundDevice && CMainFrame::GetMainFrame()->gpSoundDevice->DebugIsFragileDevice())
{
// For fragile devices, always stop the device. Stop after the dumping if in realtime context.
if(CMainFrame::GetMainFrame()->gpSoundDevice->DebugInRealtimeCallback())
{
StopSoundDevice();
}
} else
{
if(ExceptionHandler::stopSoundDeviceOnCrash && !ExceptionHandler::stopSoundDeviceBeforeDump)
{
StopSoundDevice();
}
}
}
return true;
}
// Different entry points for different situations in which we want to dump some information
static bool IsCxxException(_EXCEPTION_POINTERS *pExceptionInfo)
{
if (!pExceptionInfo)
return false;
if (!pExceptionInfo->ExceptionRecord)
return false;
if (pExceptionInfo->ExceptionRecord->ExceptionCode != 0xE06D7363u)
return false;
return true;
}
template <typename E>
static const E * GetCxxException(_EXCEPTION_POINTERS *pExceptionInfo)
{
// https://blogs.msdn.microsoft.com/oldnewthing/20100730-00/?p=13273
struct info_a_t
{
DWORD bitmask; // Probably: 1=Const, 2=Volatile
DWORD destructor; // RVA (Relative Virtual Address) of destructor for that exception object
DWORD unknown;
DWORD catchableTypesPtr; // RVA of instance of type "B"
};
struct info_c_t
{
DWORD someBitmask;
DWORD typeInfo; // RVA of std::type_info for that type
DWORD memberDisplacement; // Add to ExceptionInformation[1] in EXCEPTION_RECORD to obtain 'this' pointer.
DWORD virtBaseRelated1; // -1 if no virtual base
DWORD virtBaseRelated2; // ?
DWORD objectSize; // Size of the object in bytes
DWORD probablyCopyCtr; // RVA of copy constructor (?)
};
if(!pExceptionInfo)
return nullptr;
if (!pExceptionInfo->ExceptionRecord)
return nullptr;
if(pExceptionInfo->ExceptionRecord->ExceptionCode != 0xE06D7363u)
return nullptr;
#ifdef _WIN64
if(pExceptionInfo->ExceptionRecord->NumberParameters != 4)
return nullptr;
#else
if(pExceptionInfo->ExceptionRecord->NumberParameters != 3)
return nullptr;
#endif
if(pExceptionInfo->ExceptionRecord->ExceptionInformation[0] != 0x19930520u)
return nullptr;
std::uintptr_t base_address = 0;
#ifdef _WIN64
base_address = pExceptionInfo->ExceptionRecord->ExceptionInformation[3];
#else
base_address = 0;
#endif
std::uintptr_t obj_address = pExceptionInfo->ExceptionRecord->ExceptionInformation[1];
if(!obj_address)
return nullptr;
std::uintptr_t info_a_address = pExceptionInfo->ExceptionRecord->ExceptionInformation[2];
if(!info_a_address)
return nullptr;
const info_a_t * info_a = reinterpret_cast<const info_a_t *>(info_a_address);
std::uintptr_t info_b_offset = info_a->catchableTypesPtr;
if(!info_b_offset)
return nullptr;
const DWORD * info_b = reinterpret_cast<const DWORD *>(base_address + info_b_offset);
for(DWORD type = 1; type <= info_b[0]; ++type)
{
std::uintptr_t info_c_offset = info_b[type];
if(!info_c_offset)
continue;
const info_c_t * info_c = reinterpret_cast<const info_c_t *>(base_address + info_c_offset);
if(!info_c->typeInfo)
continue;
const std::type_info * ti = reinterpret_cast<const std::type_info *>(base_address + info_c->typeInfo);
if(*ti != typeid(E))
continue;
const E * e = reinterpret_cast<const E *>(obj_address + info_c->memberDisplacement);
return e;
}
return nullptr;
}
void ExceptionHandler::UnhandledMFCException(CException * e, const MSG * pMsg)
{
DebugReporter report(DumpModeCrash, nullptr);
mpt::ustring errorMessage;
if(e && dynamic_cast<CSimpleException*>(e))
{
TCHAR tmp[1024 + 1];
MemsetZero(tmp);
if(dynamic_cast<CSimpleException*>(e)->GetErrorMessage(tmp, static_cast<UINT>(std::size(tmp) - 1)) != 0)
{
tmp[1024] = 0;
errorMessage = MPT_UFORMAT("Unhandled MFC exception occurred while processming window message '{}': {}.")
(mpt::ufmt::dec(pMsg ? pMsg->message : 0)
, mpt::ToUnicode(CString(tmp))
);
} else
{
errorMessage = MPT_UFORMAT("Unhandled MFC exception occurred while processming window message '{}': {}.")
(mpt::ufmt::dec(pMsg ? pMsg->message : 0)
, mpt::ToUnicode(CString(tmp))
);
}
}
else
{
errorMessage = MPT_UFORMAT("Unhandled MFC exception occurred while processming window message '{}'.")
( mpt::ufmt::dec(pMsg ? pMsg->message : 0)
);
}
report.ReportError(errorMessage);
}
static void UnhandledExceptionFilterImpl(_EXCEPTION_POINTERS *pExceptionInfo)
{
DebugReporter report(DumpModeCrash, pExceptionInfo);
mpt::ustring errorMessage;
const std::exception * pE = GetCxxException<std::exception>(pExceptionInfo);
if(g_Context)
{
if(!g_Context->description.empty())
{
errorMessage += MPT_UFORMAT("OpenMPT detected a crash in '{}'.\nThis is very likely not an OpenMPT bug. Please report the problem to the respective software author.\n")(g_Context->description);
} else
{
errorMessage += MPT_UFORMAT("OpenMPT detected a crash in unknown foreign code.\nThis is likely not an OpenMPT bug.\n")();
}
}
if(pE)
{
const std::exception & e = *pE;
errorMessage += MPT_UFORMAT("Unhandled C++ exception '{}' occurred at address 0x{}: '{}'.")
( mpt::ToUnicode(mpt::Charset::ASCII, typeid(e).name())
, mpt::ufmt::hex0<mpt::pointer_size*2>(reinterpret_cast<std::uintptr_t>(pExceptionInfo->ExceptionRecord->ExceptionAddress))
, mpt::get_exception_text<mpt::ustring>(e)
);
} else
{
errorMessage += MPT_UFORMAT("Unhandled exception 0x{} at address 0x{} occurred.")
( mpt::ufmt::HEX0<8>(pExceptionInfo->ExceptionRecord->ExceptionCode)
, mpt::ufmt::hex0<mpt::pointer_size*2>(reinterpret_cast<std::uintptr_t>(pExceptionInfo->ExceptionRecord->ExceptionAddress))
);
}
report.ReportError(errorMessage);
}
LONG ExceptionHandler::UnhandledExceptionFilterContinue(_EXCEPTION_POINTERS *pExceptionInfo)
{
UnhandledExceptionFilterImpl(pExceptionInfo);
// Disable the call to std::terminate() as that would re-renter the crash
// handler another time, but with less information available.
#if 0
// MSVC implements calling std::terminate by its own UnhandledExeptionFilter.
// However, we do overwrite it here, thus we have to call std::terminate
// ourselves.
if (IsCxxException(pExceptionInfo))
{
std::terminate();
}
#endif
// Let a potential debugger handle the exception...
return EXCEPTION_CONTINUE_SEARCH;
}
LONG ExceptionHandler::ExceptionFilter(_EXCEPTION_POINTERS *pExceptionInfo)
{
UnhandledExceptionFilterImpl(pExceptionInfo);
// Let a potential debugger handle the exception...
return EXCEPTION_EXECUTE_HANDLER;
}
static void mpt_unexpected_handler();
static void mpt_terminate_handler();
void ExceptionHandler::Register()
{
if(useImplicitFallbackSEH)
{
g_OriginalUnhandledExceptionFilter = ::SetUnhandledExceptionFilter(&UnhandledExceptionFilterContinue);
}
if(handleStdTerminate)
{
g_OriginalTerminateHandler = std::set_terminate(&mpt_terminate_handler);
}
}
void ExceptionHandler::ConfigureSystemHandler()
{
#if (_WIN32_WINNT >= 0x0600)
if(delegateToWindowsHandler)
{
//SetErrorMode(0);
g_OriginalErrorMode = ::GetErrorMode();
} else
{
g_OriginalErrorMode = ::SetErrorMode(::GetErrorMode() | SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
}
#else // _WIN32_WINNT < 0x0600
if(delegateToWindowsHandler)
{
g_OriginalErrorMode = ::SetErrorMode(0);
} else
{
g_OriginalErrorMode = ::SetErrorMode(::SetErrorMode(0) | SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
}
#endif // _WIN32_WINNT
}
void ExceptionHandler::UnconfigureSystemHandler()
{
::SetErrorMode(g_OriginalErrorMode);
g_OriginalErrorMode = 0;
}
void ExceptionHandler::Unregister()
{
if(handleStdTerminate)
{
std::set_terminate(g_OriginalTerminateHandler);
g_OriginalTerminateHandler = nullptr;
}
if(useImplicitFallbackSEH)
{
::SetUnhandledExceptionFilter(g_OriginalUnhandledExceptionFilter);
g_OriginalUnhandledExceptionFilter = nullptr;
}
}
static void mpt_terminate_handler()
{
DebugReporter(DumpModeCrash, nullptr).ReportError(U_("A C++ runtime crash occurred: std::terminate() called."));
#if 1
std::abort();
#else
if(g_OriginalTerminateHandler)
{
g_OriginalTerminateHandler();
} else
{
std::abort();
}
#endif
}
#if defined(MPT_ASSERT_HANDLER_NEEDED)
MPT_NOINLINE void AssertHandler(const mpt::source_location &loc, const char *expr, const char *msg)
{
DebugReporter report(msg ? DumpModeWarning : DumpModeCrash, nullptr);
if(IsDebuggerPresent())
{
OutputDebugString(_T("ASSERT("));
OutputDebugString(mpt::ToWin(mpt::Charset::ASCII, expr).c_str());
OutputDebugString(_T(") failed\n"));
DebugBreak();
} else
{
mpt::ustring errorMessage;
if(msg)
{
errorMessage = MPT_UFORMAT("Internal state inconsistency detected at {}({}). This is just a warning that could potentially lead to a crash later on: {} [{}].")
( mpt::ToUnicode(mpt::Charset::ASCII, loc.file_name() ? loc.file_name() : "")
, loc.line()
, mpt::ToUnicode(mpt::Charset::ASCII, msg)
, mpt::ToUnicode(mpt::Charset::ASCII, loc.function_name() ? loc.function_name() : "")
);
} else
{
errorMessage = MPT_UFORMAT("Internal error occurred at {}({}): ASSERT({}) failed in [{}].")
( mpt::ToUnicode(mpt::Charset::ASCII, loc.file_name() ? loc.file_name() : "")
, loc.line()
, mpt::ToUnicode(mpt::Charset::ASCII, expr)
, mpt::ToUnicode(mpt::Charset::ASCII, loc.function_name() ? loc.function_name() : "")
);
}
report.ReportError(errorMessage);
}
}
#endif // MPT_ASSERT_HANDLER_NEEDED
void DebugInjectCrash()
{
DebugReporter(DumpModeCrash, nullptr).ReportError(U_("Injected crash."));
}
void DebugTraceDump()
{
DebugReporter report(DumpModeDebug, nullptr);
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink