bd6ecbe48a
Previously, the SEH version of _Unwind_Backtrace did unwind the stack and call the provided callback function as intended, but there was little the caller could do within the callback to actually get any info about that particular level in the unwind. Set the ra and cfa pointers, which are used by _Unwind_GetIP and _Unwind_GetCFA, to allow using these functions from the callacb to inspect the state at each stack frame. 2020-09-08 Martin Storsjö <martin@martin.st> libgcc/ * unwind-seh.c (_Unwind_Backtrace): Set the ra and cfa pointers before calling the callback.
484 lines
15 KiB
C
484 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);
|
||
|
||
/* Set values that the callback can inspect via _Unwind_GetIP
|
||
* and _Unwind_GetCFA. */
|
||
gcc_context.ra = ms_context.Rip;
|
||
gcc_context.cfa = ms_context.Rsp;
|
||
|
||
/* 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__) */
|