479 lines
15 KiB
C
479 lines
15 KiB
C
/* Structured Exception Handling (SEH) runtime interface routines.
|
||
Copyright (C) 2010-2020 Free Software Foundation, Inc.
|
||
|
||
This file is part of GCC.
|
||
|
||
GCC 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 3, or (at your option)
|
||
any later version.
|
||
|
||
GCC 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.
|
||
|
||
Under Section 7 of GPL version 3, you are granted additional
|
||
permissions described in the GCC Runtime Library Exception, version
|
||
3.1, as published by the Free Software Foundation.
|
||
|
||
You should have received a copy of the GNU General Public License and
|
||
a copy of the GCC Runtime Library Exception along with this program;
|
||
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
||
<http://www.gnu.org/licenses/>. */
|
||
|
||
#include "tconfig.h"
|
||
#include "tsystem.h"
|
||
#include "coretypes.h"
|
||
#include "tm.h"
|
||
#include "unwind.h"
|
||
|
||
#if defined (__SEH__) && !defined (__USING_SJLJ_EXCEPTIONS__)
|
||
|
||
/* At the moment everything is written for x64, but in theory this could
|
||
also be used for i386, arm, mips and other extant embedded Windows. */
|
||
#ifndef __x86_64__
|
||
#error "Unsupported architecture."
|
||
#endif
|
||
|
||
/* Define GCC's exception codes. See
|
||
http://msdn.microsoft.com/en-us/library/het71c37(v=VS.80).aspx
|
||
In particular, MS defines bits:
|
||
[31:30] = 3 (error), 2 (warning), 1 (info), 0 (success)
|
||
[29] = 1 (user-defined)
|
||
[28] = 0 (reserved)
|
||
We define bits:
|
||
[24:27] = type
|
||
[0:23] = magic
|
||
We set "magic" to "GCC", which is similar to MVC++ which uses "msc"
|
||
as the low 3 bytes of its user-defined codes for C++ exceptions.
|
||
|
||
We define the ExceptionInformation entries as follows:
|
||
[0] = _Unwind_Exception pointer
|
||
[1] = target frame
|
||
[2] = target ip
|
||
[3] = target rdx
|
||
*/
|
||
|
||
#define STATUS_USER_DEFINED (1U << 29)
|
||
|
||
#define GCC_MAGIC (('G' << 16) | ('C' << 8) | 'C')
|
||
#define GCC_EXCEPTION(TYPE) \
|
||
(STATUS_USER_DEFINED | ((TYPE) << 24) | GCC_MAGIC)
|
||
|
||
#define STATUS_GCC_THROW GCC_EXCEPTION (0)
|
||
#define STATUS_GCC_UNWIND GCC_EXCEPTION (1)
|
||
#define STATUS_GCC_FORCED GCC_EXCEPTION (2)
|
||
|
||
|
||
struct _Unwind_Context
|
||
{
|
||
_Unwind_Word cfa;
|
||
_Unwind_Word ra;
|
||
_Unwind_Word reg[2];
|
||
PDISPATCHER_CONTEXT disp;
|
||
};
|
||
|
||
/* Get the value of register INDEX as saved in CONTEXT. */
|
||
|
||
_Unwind_Word
|
||
_Unwind_GetGR (struct _Unwind_Context *c, int index)
|
||
{
|
||
if (index < 0 || index >= 2)
|
||
abort ();
|
||
return c->reg[index];
|
||
}
|
||
|
||
/* Overwrite the saved value for register INDEX in CONTEXT with VAL. */
|
||
|
||
void
|
||
_Unwind_SetGR (struct _Unwind_Context *c, int index, _Unwind_Word val)
|
||
{
|
||
if (index < 0 || index >= 2)
|
||
abort ();
|
||
c->reg[index] = val;
|
||
}
|
||
|
||
/* Get the value of the CFA as saved in CONTEXT. */
|
||
|
||
_Unwind_Word
|
||
_Unwind_GetCFA (struct _Unwind_Context *c)
|
||
{
|
||
return c->cfa;
|
||
}
|
||
|
||
/* Retrieve the return address for CONTEXT. */
|
||
|
||
_Unwind_Ptr
|
||
_Unwind_GetIP (struct _Unwind_Context *c)
|
||
{
|
||
return c->ra;
|
||
}
|
||
|
||
/* Retrieve the return address and flag whether that IP is before
|
||
or after first not yet fully executed instruction. */
|
||
|
||
_Unwind_Ptr
|
||
_Unwind_GetIPInfo (struct _Unwind_Context *c, int *ip_before_insn)
|
||
{
|
||
/* ??? Is there a concept of a signal context properly? There's
|
||
obviously an UNWP_PUSH_MACHFRAME opcode, but the runtime might
|
||
have arranged for that not to matter, really. */
|
||
*ip_before_insn = 0;
|
||
return c->ra;
|
||
}
|
||
|
||
/* Overwrite the return address for CONTEXT with VAL. */
|
||
|
||
void
|
||
_Unwind_SetIP (struct _Unwind_Context *c, _Unwind_Ptr val)
|
||
{
|
||
c->ra = val;
|
||
}
|
||
|
||
void *
|
||
_Unwind_GetLanguageSpecificData (struct _Unwind_Context *c)
|
||
{
|
||
return c->disp->HandlerData;
|
||
}
|
||
|
||
_Unwind_Ptr
|
||
_Unwind_GetRegionStart (struct _Unwind_Context *c)
|
||
{
|
||
return c->disp->FunctionEntry->BeginAddress + c->disp->ImageBase;
|
||
}
|
||
|
||
void *
|
||
_Unwind_FindEnclosingFunction (void *pc)
|
||
{
|
||
PRUNTIME_FUNCTION entry;
|
||
ULONG64 ImageBase;
|
||
|
||
entry = RtlLookupFunctionEntry ((ULONG64)pc, &ImageBase, NULL);
|
||
|
||
return (entry ? (void *)(entry->BeginAddress + ImageBase) : NULL);
|
||
}
|
||
|
||
_Unwind_Ptr
|
||
_Unwind_GetDataRelBase (struct _Unwind_Context *c ATTRIBUTE_UNUSED)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
_Unwind_Ptr
|
||
_Unwind_GetTextRelBase (struct _Unwind_Context *c)
|
||
{
|
||
return c->disp->ImageBase;
|
||
}
|
||
|
||
|
||
/* The two-phase unwind process that GCC uses is ordered differently
|
||
from the two-phase unwind process that SEH uses. The mechansism
|
||
that GCC uses is to have the filter return _URC_HANDER_FOUND; the
|
||
mechanism that SEH uses is for the filter function call back into
|
||
the unwinder.
|
||
|
||
An Ideal port to SEH would have GCC emit handler functions that
|
||
can be called, given a pointer to the "EstablisherFrame" (i.e.
|
||
the frame pointer base of the user-level function) can manipulate
|
||
the user-level variables within the user-level function's stack
|
||
frame. Once done manipulating the variables, it would return
|
||
a ExceptionContinueSearch, and the unwind process would continue.
|
||
|
||
GCC has always done things a bit differently. We continue to
|
||
transfer control back into the user-level function which, once
|
||
done manipulating the user-level variables, re-throws the exception. */
|
||
|
||
/* The "real" language-specific personality handler forwards to here
|
||
where we handle the MS SEH state and transforms it into the GCC
|
||
unwind state as per GCC's <unwind.h>, at which point we defer to
|
||
the regular language-specfic exception handler, which is passed in. */
|
||
|
||
EXCEPTION_DISPOSITION
|
||
_GCC_specific_handler (PEXCEPTION_RECORD ms_exc, void *this_frame,
|
||
PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp,
|
||
_Unwind_Personality_Fn gcc_per)
|
||
{
|
||
DWORD ms_flags = ms_exc->ExceptionFlags;
|
||
DWORD ms_code = ms_exc->ExceptionCode;
|
||
|
||
struct _Unwind_Exception *gcc_exc
|
||
= (struct _Unwind_Exception *) ms_exc->ExceptionInformation[0];
|
||
struct _Unwind_Context gcc_context;
|
||
_Unwind_Action gcc_action;
|
||
_Unwind_Reason_Code gcc_reason;
|
||
|
||
if (ms_flags & EXCEPTION_TARGET_UNWIND)
|
||
{
|
||
/* This frame is known to be the target frame. We've already
|
||
"installed" the target_ip and RAX value via the arguments
|
||
to RtlUnwindEx. All that's left is to set the RDX value
|
||
and "continue" to have the context installed. */
|
||
ms_disp->ContextRecord->Rdx = ms_exc->ExceptionInformation[3];
|
||
return ExceptionContinueSearch;
|
||
}
|
||
|
||
if (ms_code == STATUS_GCC_UNWIND)
|
||
{
|
||
/* This is a colliding exception that we threw so that we could
|
||
cancel the already in-flight exception and stop in a frame
|
||
that wanted to perform some unwind action. The only relevant
|
||
test is that we're the target frame. */
|
||
if (ms_exc->ExceptionInformation[1] == (_Unwind_Ptr) this_frame)
|
||
{
|
||
RtlUnwindEx (this_frame, (PVOID) ms_exc->ExceptionInformation[2],
|
||
ms_exc, gcc_exc, ms_orig_context,
|
||
ms_disp->HistoryTable);
|
||
abort ();
|
||
}
|
||
return ExceptionContinueSearch;
|
||
}
|
||
|
||
gcc_context.cfa = ms_disp->ContextRecord->Rsp;
|
||
gcc_context.ra = ms_disp->ControlPc;
|
||
gcc_context.reg[0] = 0xdeadbeef; /* These are write-only. */
|
||
gcc_context.reg[1] = 0xdeadbeef;
|
||
gcc_context.disp = ms_disp;
|
||
|
||
if (ms_code == STATUS_GCC_FORCED)
|
||
{
|
||
_Unwind_Stop_Fn stop = (_Unwind_Stop_Fn) gcc_exc->private_[0];
|
||
void *stop_argument = (void *) gcc_exc->private_[4];
|
||
|
||
gcc_action = _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE;
|
||
|
||
stop (1, gcc_action, gcc_exc->exception_class, gcc_exc,
|
||
&gcc_context, stop_argument);
|
||
|
||
goto phase2;
|
||
}
|
||
|
||
/* ??? TODO: handling non-gcc user-defined exceptions as foreign. */
|
||
if (ms_code != STATUS_GCC_THROW)
|
||
return ExceptionContinueSearch;
|
||
|
||
if (ms_flags & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND))
|
||
{
|
||
/* This is Phase 2. */
|
||
/* We know this isn't the target frame because we've already tested
|
||
EXCEPTION_TARGET_UNWIND. The remaining possibility is that the
|
||
gcc personality has unwind code to run. */
|
||
|
||
gcc_action = _UA_CLEANUP_PHASE;
|
||
phase2:
|
||
gcc_reason = gcc_per (1, gcc_action, gcc_exc->exception_class,
|
||
gcc_exc, &gcc_context);
|
||
|
||
if (gcc_reason == _URC_CONTINUE_UNWIND)
|
||
return ExceptionContinueSearch;
|
||
|
||
if (gcc_reason == _URC_INSTALL_CONTEXT)
|
||
{
|
||
/* Scratch space for the bits for the unwind catch. */
|
||
ms_exc->ExceptionInformation[1] = (_Unwind_Ptr) this_frame;
|
||
ms_exc->ExceptionInformation[2] = gcc_context.ra;
|
||
ms_exc->ExceptionInformation[3] = gcc_context.reg[1];
|
||
|
||
/* Cancel the current exception by raising another. */
|
||
RaiseException (STATUS_GCC_UNWIND, EXCEPTION_NONCONTINUABLE,
|
||
4, ms_exc->ExceptionInformation);
|
||
|
||
/* Is RaiseException declared noreturn? */
|
||
}
|
||
|
||
/* In _Unwind_RaiseException_Phase2 we return _URC_FATAL_PHASE2_ERROR. */
|
||
}
|
||
else
|
||
{
|
||
/* This is Phase 1. */
|
||
gcc_reason = gcc_per (1, _UA_SEARCH_PHASE, gcc_exc->exception_class,
|
||
gcc_exc, &gcc_context);
|
||
|
||
if (gcc_reason == _URC_CONTINUE_UNWIND)
|
||
return ExceptionContinueSearch;
|
||
|
||
if (gcc_reason == _URC_HANDLER_FOUND)
|
||
{
|
||
/* We really need some of the information that GCC's personality
|
||
routines compute during phase 2 right now, like the target IP.
|
||
Go ahead and ask for it now, and cache it. */
|
||
gcc_reason = gcc_per (1, _UA_CLEANUP_PHASE | _UA_HANDLER_FRAME,
|
||
gcc_exc->exception_class, gcc_exc,
|
||
&gcc_context);
|
||
if (gcc_reason != _URC_INSTALL_CONTEXT)
|
||
abort ();
|
||
|
||
gcc_exc->private_[1] = (_Unwind_Ptr) this_frame;
|
||
gcc_exc->private_[2] = gcc_context.ra;
|
||
gcc_exc->private_[3] = gcc_context.reg[1];
|
||
|
||
ms_exc->NumberParameters = 4;
|
||
ms_exc->ExceptionInformation[1] = (_Unwind_Ptr) this_frame;
|
||
ms_exc->ExceptionInformation[2] = gcc_context.ra;
|
||
ms_exc->ExceptionInformation[3] = gcc_context.reg[1];
|
||
|
||
/* Begin phase 2. Perform the unwinding. */
|
||
RtlUnwindEx (this_frame, (PVOID)gcc_context.ra, ms_exc,
|
||
(PVOID)gcc_context.reg[0], ms_orig_context,
|
||
ms_disp->HistoryTable);
|
||
}
|
||
|
||
/* In _Unwind_RaiseException we return _URC_FATAL_PHASE1_ERROR. */
|
||
}
|
||
abort ();
|
||
}
|
||
|
||
/* Raise an exception, passing along the given exception object. */
|
||
|
||
_Unwind_Reason_Code
|
||
_Unwind_RaiseException (struct _Unwind_Exception *exc)
|
||
{
|
||
memset (exc->private_, 0, sizeof (exc->private_));
|
||
|
||
/* The ExceptionInformation array will have only 1 element, EXC. */
|
||
RaiseException (STATUS_GCC_THROW, 0, 1, (ULONG_PTR *)&exc);
|
||
|
||
/* The exception handler installed in crt0 will continue any GCC
|
||
exception that reaches there (and isn't marked non-continuable).
|
||
Returning allows the C++ runtime to call std::terminate. */
|
||
return _URC_END_OF_STACK;
|
||
}
|
||
|
||
/* Resume propagation of an existing exception. This is used after
|
||
e.g. executing cleanup code, and not to implement rethrowing. */
|
||
|
||
void
|
||
_Unwind_Resume (struct _Unwind_Exception *gcc_exc)
|
||
{
|
||
UNWIND_HISTORY_TABLE ms_history;
|
||
EXCEPTION_RECORD ms_exc;
|
||
CONTEXT ms_context;
|
||
|
||
memset (&ms_exc, 0, sizeof(ms_exc));
|
||
memset (&ms_history, 0, sizeof(ms_history));
|
||
|
||
/* ??? Not 100% perfect, since we aren't passing on the *original*
|
||
exception context, but should be good enough. */
|
||
ms_exc.ExceptionCode = STATUS_GCC_THROW;
|
||
ms_exc.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
|
||
ms_exc.NumberParameters = 4;
|
||
ms_exc.ExceptionInformation[0] = (ULONG_PTR) gcc_exc;
|
||
ms_exc.ExceptionInformation[1] = gcc_exc->private_[1];
|
||
ms_exc.ExceptionInformation[2] = gcc_exc->private_[2];
|
||
ms_exc.ExceptionInformation[3] = gcc_exc->private_[3];
|
||
|
||
ms_context.ContextFlags = CONTEXT_ALL;
|
||
RtlCaptureContext (&ms_context);
|
||
|
||
RtlUnwindEx ((void *) gcc_exc->private_[1], (PVOID)gcc_exc->private_[2],
|
||
&ms_exc, gcc_exc, &ms_context, &ms_history);
|
||
|
||
/* Is RtlUnwindEx declared noreturn? */
|
||
abort ();
|
||
}
|
||
|
||
static _Unwind_Reason_Code
|
||
_Unwind_ForcedUnwind_Phase2 (struct _Unwind_Exception *exc)
|
||
{
|
||
_Unwind_Stop_Fn stop;
|
||
void * stop_argument;
|
||
|
||
RaiseException (STATUS_GCC_FORCED, 0, 1, (ULONG_PTR *)&exc);
|
||
|
||
/* If we get here, we got to top-of-stack. */
|
||
/* ??? We no longer have a context pointer to pass in. */
|
||
|
||
stop = (_Unwind_Stop_Fn) exc->private_[0];
|
||
stop_argument = (void *) exc->private_[4];
|
||
stop (1, _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK,
|
||
exc->exception_class, exc, NULL, stop_argument);
|
||
|
||
return _UA_END_OF_STACK;
|
||
}
|
||
|
||
_Unwind_Reason_Code
|
||
_Unwind_Resume_or_Rethrow (struct _Unwind_Exception *exc)
|
||
{
|
||
if (exc->private_[0] == 0)
|
||
_Unwind_RaiseException (exc);
|
||
else
|
||
_Unwind_ForcedUnwind_Phase2 (exc);
|
||
abort ();
|
||
}
|
||
|
||
/* Raise an exception for forced unwinding. */
|
||
|
||
_Unwind_Reason_Code
|
||
_Unwind_ForcedUnwind (struct _Unwind_Exception *exc,
|
||
_Unwind_Stop_Fn stop, void * stop_argument)
|
||
{
|
||
/* ??? This is a hack that only works with _GCC_specific_handler.
|
||
There's no way to invoke STOP within frames that use a different
|
||
exception handler. This is essentially just good enough to run
|
||
the code within the gcc testsuite. */
|
||
|
||
memset (exc->private_, 0, sizeof (exc->private_));
|
||
exc->private_[0] = (_Unwind_Ptr) stop;
|
||
exc->private_[4] = (_Unwind_Ptr) stop_argument;
|
||
|
||
return _Unwind_ForcedUnwind_Phase2 (exc);
|
||
}
|
||
|
||
/* A convenience function that calls the exception_cleanup field. */
|
||
|
||
void
|
||
_Unwind_DeleteException (struct _Unwind_Exception *exc)
|
||
{
|
||
if (exc->exception_cleanup)
|
||
(*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
|
||
}
|
||
|
||
/* Perform stack backtrace through unwind data. */
|
||
|
||
_Unwind_Reason_Code
|
||
_Unwind_Backtrace(_Unwind_Trace_Fn trace,
|
||
void *trace_argument)
|
||
{
|
||
UNWIND_HISTORY_TABLE ms_history;
|
||
CONTEXT ms_context;
|
||
struct _Unwind_Context gcc_context;
|
||
DISPATCHER_CONTEXT disp_context;
|
||
|
||
memset (&ms_history, 0, sizeof(ms_history));
|
||
memset (&gcc_context, 0, sizeof(gcc_context));
|
||
memset (&disp_context, 0, sizeof(disp_context));
|
||
|
||
ms_context.ContextFlags = CONTEXT_ALL;
|
||
RtlCaptureContext (&ms_context);
|
||
|
||
gcc_context.disp = &disp_context;
|
||
gcc_context.disp->ContextRecord = &ms_context;
|
||
gcc_context.disp->HistoryTable = &ms_history;
|
||
|
||
while (1)
|
||
{
|
||
gcc_context.disp->ControlPc = ms_context.Rip;
|
||
gcc_context.disp->FunctionEntry
|
||
= RtlLookupFunctionEntry (ms_context.Rip, &gcc_context.disp->ImageBase,
|
||
&ms_history);
|
||
|
||
if (!gcc_context.disp->FunctionEntry)
|
||
return _URC_END_OF_STACK;
|
||
|
||
gcc_context.disp->LanguageHandler
|
||
= RtlVirtualUnwind (0, gcc_context.disp->ImageBase, ms_context.Rip,
|
||
gcc_context.disp->FunctionEntry, &ms_context,
|
||
&gcc_context.disp->HandlerData,
|
||
&gcc_context.disp->EstablisherFrame, NULL);
|
||
|
||
/* Call trace function. */
|
||
if (trace (&gcc_context, trace_argument) != _URC_NO_REASON)
|
||
return _URC_FATAL_PHASE1_ERROR;
|
||
|
||
/* ??? Check for invalid stack pointer. */
|
||
if (ms_context.Rip == 0)
|
||
return _URC_END_OF_STACK;
|
||
}
|
||
}
|
||
#endif /* __SEH__ && !defined (__USING_SJLJ_EXCEPTIONS__) */
|