__declspec(noreturn) void __cdecl __raise_securityfailure(
PEXCEPTION_POINTERS const exception_pointers
)
{
#ifdef _VCRT_BUILD
DebuggerWasPresent = IsDebuggerPresent();
_CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_GSFAILURE);
#endif // _VCRT_BUILD
SetUnhandledExceptionFilter(NULL);
UnhandledExceptionFilter(exception_pointers);
#ifdef _VCRT_BUILD
// If we make it back from Watson, then the user may have asked to debug
// the app. If we weren't under a debugger before invoking Watson,
// re-signal the VS CRT debugger hook, so a newly attached debugger gets
// a chance to break into the process.
if (!DebuggerWasPresent)
{
_CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_GSFAILURE);
}
#endif // _VCRT_BUILD
TerminateProcess(GetCurrentProcess(), STATUS_SECURITY_CHECK_FAILURE);
}
__inline DWORD WINAPI OrpcBreakpointFilter(
LPEXCEPTION_POINTERS lpExcptPtr,
BOOL *lpAeDebugAttached ) \
{
BOOL fAeDebugAttached = FALSE;
DWORD dwRet;
if ( lpExcptPtr->ExceptionRecord->ExceptionCode == EXCEPTION_ORPC_DEBUG )
{
if ( UnhandledExceptionFilter(lpExcptPtr) == EXCEPTION_CONTINUE_SEARCH )
{
// It is important that we don't return EXCEPTION_CONTINUE_SEARCH.
// This is because there might an handler up the stack which could
// handle this exception. Just set the flag indicating that a
// debugger is now attached.
fAeDebugAttached = TRUE;
}
dwRet = EXCEPTION_EXECUTE_HANDLER;
}
else
{
// Not one of our exceptions.
dwRet = EXCEPTION_CONTINUE_SEARCH;
}
if ( lpAeDebugAttached != NULL )
(*lpAeDebugAttached) = fAeDebugAttached;
return dwRet;
}
unsigned long CrashFilter(LPEXCEPTION_POINTERS pException, int exceptionCode)
{
unsigned long result;
if ((result = UnhandledExceptionFilter(pException)) != EXCEPTION_EXECUTE_HANDLER)
{
return result;
}
else if (avmthane::show_error)
{
// if -error option dont do a dump
return EXCEPTION_CONTINUE_SEARCH;
}
AvmLog("avmplus crash: exception 0x%08lX occurred\n", exceptionCode);
typedef BOOL (WINAPI *MINIDUMP_WRITE_DUMP)(
HANDLE hProcess,
DWORD ProcessId,
HANDLE hFile,
MINIDUMP_TYPE DumpType,
PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
HMODULE hDbgHelp = LoadLibrary("dbghelp.dll");
MINIDUMP_WRITE_DUMP MiniDumpWriteDump_ = (MINIDUMP_WRITE_DUMP)GetProcAddress(hDbgHelp,
"MiniDumpWriteDump");
if (MiniDumpWriteDump_)
{
MINIDUMP_EXCEPTION_INFORMATION M;
const char DumpPath[] = "avmplusCrash.dmp";
M.ThreadId = GetCurrentThreadId();
M.ExceptionPointers = pException;
M.ClientPointers = 0;
AvmLog("Writing minidump crash log to %s\n", DumpPath);
HANDLE hDumpFile = CreateFile(DumpPath, GENERIC_WRITE, 0,
NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
MiniDumpWriteDump_(GetCurrentProcess(),
GetCurrentProcessId(),
hDumpFile,
MiniDumpNormal,
(pException) ? &M : NULL, NULL, NULL);
CloseHandle(hDumpFile);
}
else
{
AvmLog("minidump not available, no crash log written.\n");
}
return result;
}
LONG __stdcall myExceptFilterProc( LPEXCEPTION_POINTERS param )
{
if (IsDebuggerPresent())
{
return UnhandledExceptionFilter(param);
}
else
{
//DumpCrashInfo( param );
TerminateProcess( GetCurrentProcess(), 0 );
return 0;// never reached
}
}
__declspec(noreturn) void __cdecl
__report_gsfailure (ULONG_PTR StackCookie)
{
volatile UINT_PTR cookie[2] __MINGW_ATTRIB_UNUSED;
#if defined(_WIN64) && !defined(__aarch64__)
ULONG64 controlPC, imgBase, establisherFrame;
PRUNTIME_FUNCTION fctEntry;
PVOID hndData;
RtlCaptureContext (&GS_ContextRecord);
controlPC = GS_ContextRecord.Rip;
fctEntry = RtlLookupFunctionEntry (controlPC, &imgBase, NULL);
if (fctEntry != NULL)
{
RtlVirtualUnwind (UNW_FLAG_NHANDLER, imgBase, controlPC, fctEntry,
&GS_ContextRecord, &hndData, &establisherFrame, NULL);
}
else
#endif /* _WIN64 */
{
#if defined(__x86_64__) || defined(_AMD64_)
GS_ContextRecord.Rip = (ULONGLONG) _ReturnAddress();
GS_ContextRecord.Rsp = (ULONGLONG) _AddressOfReturnAddress() + 8;
#elif defined(__i386__) || defined(_X86_)
GS_ContextRecord.Eip = (DWORD) _ReturnAddress();
GS_ContextRecord.Esp = (DWORD) _AddressOfReturnAddress() + 4;
#elif defined(__arm__) || defined(_ARM_)
GS_ContextRecord.Pc = (DWORD) _ReturnAddress();
GS_ContextRecord.Sp = (DWORD) _AddressOfReturnAddress() + 4;
#endif /* _WIN64 */
}
#if defined(__x86_64__) || defined(_AMD64_)
GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Rip;
GS_ContextRecord.Rcx = StackCookie;
#elif defined(__i386__) || defined(_X86_)
GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Eip;
GS_ContextRecord.Ecx = StackCookie;
#elif defined(__arm__) || defined(_ARM_)
GS_ExceptionRecord.ExceptionAddress = (PVOID) GS_ContextRecord.Pc;
UNUSED_PARAM(StackCookie);
#endif /* _WIN64 */
GS_ExceptionRecord.ExceptionCode = STATUS_STACK_BUFFER_OVERRUN;
GS_ExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
cookie[0] = __security_cookie;
cookie[1] = __security_cookie_complement;
SetUnhandledExceptionFilter (NULL);
UnhandledExceptionFilter ((EXCEPTION_POINTERS *) &GS_ExceptionPointers);
TerminateProcess (GetCurrentProcess (), STATUS_STACK_BUFFER_OVERRUN);
abort();
}
/* FUNCTIONS *****************************************************************/
static
LONG BaseThreadExceptionFilter(EXCEPTION_POINTERS * ExceptionInfo)
{
LONG ExceptionDisposition = EXCEPTION_EXECUTE_HANDLER;
if (GlobalTopLevelExceptionFilter != NULL)
{
_SEH2_TRY
{
ExceptionDisposition = GlobalTopLevelExceptionFilter(ExceptionInfo);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExceptionDisposition = UnhandledExceptionFilter(ExceptionInfo);
}
_SEH2_END;
}
static
LONG BaseThreadExceptionFilter(EXCEPTION_POINTERS * ExceptionInfo)
{
LONG ExceptionDisposition = EXCEPTION_EXECUTE_HANDLER;
LPTOP_LEVEL_EXCEPTION_FILTER RealFilter;
RealFilter = RtlDecodePointer(GlobalTopLevelExceptionFilter);
if (RealFilter != NULL)
{
_SEH2_TRY
{
ExceptionDisposition = RealFilter(ExceptionInfo);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExceptionDisposition = UnhandledExceptionFilter(ExceptionInfo);
}
_SEH2_END;
}
int __cdecl _XcptFilter (
unsigned long xcptnum,
PEXCEPTION_POINTERS pxcptinfoptrs
)
{
struct _XCPT_ACTION * pxcptact;
_PHNDLR phandler;
void *oldpxcptinfoptrs;
int oldfpecode;
int indx;
_ptiddata ptd = _getptd_noexit();
if (!ptd) {
// we can't deal with it - pass it on.
return( UnhandledExceptionFilter(pxcptinfoptrs) );
}
pxcptact = xcptlookup(xcptnum, ptd->_pxcptacttab);
if (pxcptact == NULL)
{
phandler = SIG_DFL;
}
else
{
phandler = pxcptact->XcptAction;
}
/*
* first, take care of all unrecognized exceptions and exceptions with
* XcptAction values of SIG_DFL.
*/
if ( phandler == SIG_DFL )
/*
* pass the buck to the UnhandledExceptionFilter
*/
return( UnhandledExceptionFilter(pxcptinfoptrs) );
/*
* next, weed out all of the exceptions that need to be handled by
* dying, perhaps with a runtime error message
*/
if ( phandler == SIG_DIE ) {
/*
* reset XcptAction (in case of recursion) and drop into the
* except-clause.
*/
pxcptact->XcptAction = SIG_DFL;
return(EXCEPTION_EXECUTE_HANDLER);
}
/*
* next, weed out all of the exceptions that are simply ignored
*/
if ( phandler == SIG_IGN )
/*
* resume execution
*/
return(EXCEPTION_CONTINUE_EXECUTION);
/*
* the remaining exceptions all correspond to C signals which have
* signal handlers associated with them. for some, special setup
* is required before the signal handler is called. in all cases,
* if the signal handler returns, -1 is returned by this function
* to resume execution at the point where the exception occurred.
*/
/*
* save the old value of _pxcptinfoptrs (in case this is a nested
* exception/signal) and store the current one.
*/
oldpxcptinfoptrs = PXCPTINFOPTRS;
PXCPTINFOPTRS = pxcptinfoptrs;
/*
* call the user-supplied signal handler
*
* floating point exceptions must be handled specially since, from
* the C point-of-view, there is only one signal. the exact identity
* of the exception is passed in the global variable _fpecode.
*/
if ( pxcptact->SigNum == SIGFPE ) {
/*
* reset the XcptAction field to the default for all entries
* corresponding to SIGFPE.
*/
for ( indx = _First_FPE_Indx ;
indx < _First_FPE_Indx + _Num_FPE ;
indx++ )
{
( (struct _XCPT_ACTION *)(ptd->_pxcptacttab) +
indx )->XcptAction = SIG_DFL;
}
/*
* Save the current _fpecode in case it is a nested floating
* point exception (not clear that we need to support this,
* but it's easy).
*/
oldfpecode = FPECODE;
/*
* there are no exceptions corresponding to
* following _FPE_xxx codes:
*
* _FPE_UNEMULATED
* _FPE_SQRTNEG
*
* futhermore, STATUS_FLOATING_STACK_CHECK is
* raised for both floating point stack under-
* flow and overflow. thus, the exception does
* not distinguish between _FPE_STACKOVERLOW
* and _FPE_STACKUNDERFLOW. arbitrarily, _fpecode
* is set to the former value.
*
* the following should be a switch statement but, alas, the
* compiler doesn't like switching on unsigned longs...
*/
if ( pxcptact->XcptNum == STATUS_FLOAT_DIVIDE_BY_ZERO )
FPECODE = _FPE_ZERODIVIDE;
else if ( pxcptact->XcptNum == STATUS_FLOAT_INVALID_OPERATION )
FPECODE = _FPE_INVALID;
else if ( pxcptact->XcptNum == STATUS_FLOAT_OVERFLOW )
FPECODE = _FPE_OVERFLOW;
else if ( pxcptact->XcptNum == STATUS_FLOAT_UNDERFLOW )
FPECODE = _FPE_UNDERFLOW;
else if ( pxcptact->XcptNum == STATUS_FLOAT_DENORMAL_OPERAND )
FPECODE = _FPE_DENORMAL;
else if ( pxcptact->XcptNum == STATUS_FLOAT_INEXACT_RESULT )
FPECODE = _FPE_INEXACT;
else if ( pxcptact->XcptNum == STATUS_FLOAT_STACK_CHECK )
FPECODE = _FPE_STACKOVERFLOW;
/*
* call the SIGFPE handler. note the special code to support
* old MS-C programs whose SIGFPE handlers expect two args.
*
* NOTE: THE CAST AND CALL BELOW DEPEND ON __cdecl BEING
* CALLER CLEANUP!
*/
(*(void (__cdecl *)(int, int))phandler)(SIGFPE, FPECODE);
/*
* restore the old value of _fpecode
*/
FPECODE = oldfpecode;
}
else {
/*
* reset the XcptAction field to the default, then call the
* user-supplied handler
*/
pxcptact->XcptAction = SIG_DFL;
(*phandler)(pxcptact->SigNum);
}
/*
* restore the old value of _pxcptinfoptrs
*/
PXCPTINFOPTRS = oldpxcptinfoptrs;
return(EXCEPTION_CONTINUE_EXECUTION);
}
_CRTIMP void __cdecl _invoke_watson(
const wchar_t *pszExpression,
const wchar_t *pszFunction,
const wchar_t *pszFile,
unsigned int nLine,
uintptr_t pReserved
)
{
/* Fake an exception to call reportfault. */
EXCEPTION_RECORD ExceptionRecord;
CONTEXT ContextRecord;
EXCEPTION_POINTERS ExceptionPointers;
BOOL wasDebuggerPresent = FALSE;
DWORD ret = 0;
(pszExpression);
(pszFunction);
(pszFile);
(nLine);
(pReserved);
#ifdef _X86_
__asm {
mov dword ptr [ContextRecord.Eax], eax
mov dword ptr [ContextRecord.Ecx], ecx
mov dword ptr [ContextRecord.Edx], edx
mov dword ptr [ContextRecord.Ebx], ebx
mov dword ptr [ContextRecord.Esi], esi
mov dword ptr [ContextRecord.Edi], edi
mov word ptr [ContextRecord.SegSs], ss
mov word ptr [ContextRecord.SegCs], cs
mov word ptr [ContextRecord.SegDs], ds
mov word ptr [ContextRecord.SegEs], es
mov word ptr [ContextRecord.SegFs], fs
mov word ptr [ContextRecord.SegGs], gs
pushfd
pop [ContextRecord.EFlags]
}
ContextRecord.ContextFlags = CONTEXT_CONTROL;
#pragma warning(push)
#pragma warning(disable:4311)
ContextRecord.Eip = (ULONG)_ReturnAddress();
ContextRecord.Esp = (ULONG)_AddressOfReturnAddress();
#pragma warning(pop)
ContextRecord.Ebp = *((ULONG *)_AddressOfReturnAddress()-1);
#elif defined (_IA64_) || defined (_AMD64_)
/* Need to fill up the Context in IA64 and AMD64. */
RtlCaptureContext(&ContextRecord);
#else /* defined (_IA64_) || defined (_AMD64_) */
ZeroMemory(&ContextRecord, sizeof(ContextRecord));
#endif /* defined (_IA64_) || defined (_AMD64_) */
ZeroMemory(&ExceptionRecord, sizeof(ExceptionRecord));
ExceptionRecord.ExceptionCode = STATUS_INVALID_PARAMETER;
ExceptionRecord.ExceptionAddress = _ReturnAddress();
ExceptionPointers.ExceptionRecord = &ExceptionRecord;
ExceptionPointers.ContextRecord = &ContextRecord;
wasDebuggerPresent = IsDebuggerPresent();
/* Make sure any filter already in place is deleted. */
SetUnhandledExceptionFilter(NULL);
ret = UnhandledExceptionFilter(&ExceptionPointers);
// if no handler found and no debugger previously attached
// the execution must stop into the debugger hook.
if (ret == EXCEPTION_CONTINUE_SEARCH && !wasDebuggerPresent) {
_CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_INVALIDPARAMETER);
}
TerminateProcess(GetCurrentProcess(), STATUS_INVALID_PARAMETER);
}
