mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-11-28 16:11:29 +00:00
Add support for SEH unwinding on Windows.
Summary: I've tested this implementation on x86-64 to ensure that it works. All `libc++abi` tests pass, as do all `libc++` exception-related tests. ARM still remains to be implemented (@compnerd?). Special thanks to KJK::Hyperion for his excellent series of articles on how EH works on x86-64 Windows. (Seriously, check it out. It's awesome.) I'm actually not sure if this should go in as is. I particularly don't like that I duplicated the UnwindCursor class for this special case. Reviewers: mstorsjo, rnk, compnerd, smeenai, javed.absar Subscribers: mgorny, kristof.beyls, christof, chrib, cfe-commits, compnerd, llvm-commits Differential Revision: https://reviews.llvm.org/D50564 llvm-svn: 341125
This commit is contained in:
Charles Davis
parent
c11a780ed6
commit
a7e3a6d802
@ -34,7 +34,11 @@
|
||||
# define _LIBUNWIND_TARGET_X86_64 1
|
||||
# if defined(_WIN64)
|
||||
# define _LIBUNWIND_CONTEXT_SIZE 54
|
||||
# define _LIBUNWIND_CURSOR_SIZE 66
|
||||
# ifdef __SEH__
|
||||
# define _LIBUNWIND_CURSOR_SIZE 204
|
||||
# else
|
||||
# define _LIBUNWIND_CURSOR_SIZE 66
|
||||
# endif
|
||||
# else
|
||||
# define _LIBUNWIND_CONTEXT_SIZE 21
|
||||
# define _LIBUNWIND_CURSOR_SIZE 33
|
||||
@ -57,7 +61,10 @@
|
||||
# define _LIBUNWIND_HIGHEST_DWARF_REGISTER _LIBUNWIND_HIGHEST_DWARF_REGISTER_ARM64
|
||||
# elif defined(__arm__)
|
||||
# define _LIBUNWIND_TARGET_ARM 1
|
||||
# if defined(__ARM_WMMX)
|
||||
# if defined(__SEH__)
|
||||
# define _LIBUNWIND_CONTEXT_SIZE 42
|
||||
# define _LIBUNWIND_CURSOR_SIZE 85
|
||||
# elif defined(__ARM_WMMX)
|
||||
# define _LIBUNWIND_CONTEXT_SIZE 61
|
||||
# define _LIBUNWIND_CURSOR_SIZE 68
|
||||
# else
|
||||
|
||||
@ -19,8 +19,9 @@
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
|
||||
#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__) && defined(_WIN32)
|
||||
#include <windows.h>
|
||||
#include <ntverp.h>
|
||||
#endif
|
||||
|
||||
#if defined(__APPLE__)
|
||||
@ -378,12 +379,19 @@ extern void *__deregister_frame_info_bases(const void *fde)
|
||||
LIBUNWIND_UNAVAIL;
|
||||
|
||||
#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
|
||||
#ifndef _WIN32
|
||||
typedef struct _EXCEPTION_RECORD EXCEPTION_RECORD;
|
||||
typedef struct _CONTEXT CONTEXT;
|
||||
typedef struct _DISPATCHER_CONTEXT DISPATCHER_CONTEXT;
|
||||
#elif !defined(__MINGW32__) && VER_PRODUCTBUILD < 8000
|
||||
typedef struct _DISPATCHER_CONTEXT DISPATCHER_CONTEXT;
|
||||
#endif
|
||||
// This is the common wrapper for GCC-style personality functions with SEH.
|
||||
extern EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD exc,
|
||||
PVOID frame,
|
||||
PCONTEXT ctx,
|
||||
PDISPATCHER_CONTEXT disp,
|
||||
_Unwind_Personality_Fn pers);
|
||||
extern EXCEPTION_DISPOSITION _GCC_specific_handler(EXCEPTION_RECORD *exc,
|
||||
void *frame,
|
||||
CONTEXT *ctx,
|
||||
DISPATCHER_CONTEXT *disp,
|
||||
__personality_routine pers);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
@ -155,7 +155,7 @@ namespace libunwind {
|
||||
struct UnwindInfoSections {
|
||||
#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) || defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) || \
|
||||
defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
|
||||
// No dso_base for ARM EHABI.
|
||||
// No dso_base for SEH or ARM EHABI.
|
||||
uintptr_t dso_base;
|
||||
#endif
|
||||
#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
|
||||
@ -454,6 +454,10 @@ inline bool LocalAddressSpace::findUnwindSections(pint_t targetAddr,
|
||||
}
|
||||
}
|
||||
return false;
|
||||
#elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32)
|
||||
// Don't even bother, since Windows has functions that do all this stuff
|
||||
// for us.
|
||||
return true;
|
||||
#elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__) && \
|
||||
(__ANDROID_API__ < 21)
|
||||
int length = 0;
|
||||
|
||||
@ -2,7 +2,8 @@
|
||||
|
||||
set(LIBUNWIND_CXX_SOURCES
|
||||
libunwind.cpp
|
||||
Unwind-EHABI.cpp)
|
||||
Unwind-EHABI.cpp
|
||||
Unwind-seh.cpp)
|
||||
append_if(LIBUNWIND_CXX_SOURCES APPLE Unwind_AppleExtras.cpp)
|
||||
|
||||
set(LIBUNWIND_C_SOURCES
|
||||
|
||||
468
libunwind/src/Unwind-seh.cpp
Normal file
468
libunwind/src/Unwind-seh.cpp
Normal file
@ -0,0 +1,468 @@
|
||||
//===--------------------------- Unwind-seh.cpp ---------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Implements SEH-based Itanium C++ exceptions.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
|
||||
#include <unwind.h>
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <windef.h>
|
||||
#include <excpt.h>
|
||||
#include <winnt.h>
|
||||
#include <ntstatus.h>
|
||||
|
||||
#include "libunwind_ext.h"
|
||||
#include "UnwindCursor.hpp"
|
||||
|
||||
using namespace libunwind;
|
||||
|
||||
#define STATUS_USER_DEFINED (1u << 29)
|
||||
|
||||
#define STATUS_GCC_MAGIC (('G' << 16) | ('C' << 8) | 'C')
|
||||
|
||||
#define MAKE_CUSTOM_STATUS(s, c) \
|
||||
((NTSTATUS)(((s) << 30) | STATUS_USER_DEFINED | (c)))
|
||||
#define MAKE_GCC_EXCEPTION(c) \
|
||||
MAKE_CUSTOM_STATUS(STATUS_SEVERITY_SUCCESS, STATUS_GCC_MAGIC | ((c) << 24))
|
||||
|
||||
/// SEH exception raised by libunwind when the program calls
|
||||
/// \c _Unwind_RaiseException.
|
||||
#define STATUS_GCC_THROW MAKE_GCC_EXCEPTION(0) // 0x20474343
|
||||
/// SEH exception raised by libunwind to initiate phase 2 of exception
|
||||
/// handling.
|
||||
#define STATUS_GCC_UNWIND MAKE_GCC_EXCEPTION(1) // 0x21474343
|
||||
|
||||
/// Class of foreign exceptions based on unrecognized SEH exceptions.
|
||||
static const uint64_t kSEHExceptionClass = 0x434C4E4753454800; // CLNGSEH\0
|
||||
|
||||
/// Exception cleanup routine used by \c _GCC_specific_handler to
|
||||
/// free foreign exceptions.
|
||||
static void seh_exc_cleanup(_Unwind_Reason_Code urc, _Unwind_Exception *exc) {
|
||||
if (exc->exception_class != kSEHExceptionClass)
|
||||
_LIBUNWIND_ABORT("SEH cleanup called on non-SEH exception");
|
||||
free(exc);
|
||||
}
|
||||
|
||||
static int _unw_init_seh(unw_cursor_t *cursor, CONTEXT *ctx);
|
||||
static DISPATCHER_CONTEXT *_unw_seh_get_disp_ctx(unw_cursor_t *cursor);
|
||||
static void _unw_seh_set_disp_ctx(unw_cursor_t *cursor, DISPATCHER_CONTEXT *disp);
|
||||
|
||||
/// Common implementation of SEH-style handler functions used by Itanium-
|
||||
/// style frames. Depending on how and why it was called, it may do one of:
|
||||
/// a) Delegate to the given Itanium-style personality function; or
|
||||
/// b) Initiate a collided unwind to halt unwinding.
|
||||
_LIBUNWIND_EXPORT EXCEPTION_DISPOSITION
|
||||
_GCC_specific_handler(PEXCEPTION_RECORD ms_exc, PVOID frame, PCONTEXT ms_ctx,
|
||||
DISPATCHER_CONTEXT *disp, __personality_routine pers) {
|
||||
unw_context_t uc;
|
||||
unw_cursor_t cursor;
|
||||
_Unwind_Exception *exc;
|
||||
_Unwind_Action action;
|
||||
struct _Unwind_Context *ctx = nullptr;
|
||||
_Unwind_Reason_Code urc;
|
||||
uintptr_t retval, target;
|
||||
bool ours = false;
|
||||
|
||||
_LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler(%#010x(%x), %p)", ms_exc->ExceptionCode, ms_exc->ExceptionFlags, frame);
|
||||
if (ms_exc->ExceptionCode == STATUS_GCC_UNWIND) {
|
||||
if (IS_TARGET_UNWIND(ms_exc->ExceptionFlags)) {
|
||||
// Set up the upper return value (the lower one and the target PC
|
||||
// were set in the call to RtlUnwindEx()) for the landing pad.
|
||||
#ifdef __x86_64__
|
||||
disp->ContextRecord->Rdx = ms_exc->ExceptionInformation[3];
|
||||
#elif defined(__arm__)
|
||||
disp->ContextRecord->R1 = ms_exc->ExceptionInformation[3];
|
||||
#endif
|
||||
}
|
||||
// This is the collided unwind to the landing pad. Nothing to do.
|
||||
return ExceptionContinueSearch;
|
||||
}
|
||||
|
||||
if (ms_exc->ExceptionCode == STATUS_GCC_THROW) {
|
||||
// This is (probably) a libunwind-controlled exception/unwind. Recover the
|
||||
// parameters which we set below, and pass them to the personality function.
|
||||
ours = true;
|
||||
exc = (_Unwind_Exception *)ms_exc->ExceptionInformation[0];
|
||||
if (!IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1) {
|
||||
ctx = (struct _Unwind_Context *)ms_exc->ExceptionInformation[1];
|
||||
action = (_Unwind_Action)ms_exc->ExceptionInformation[2];
|
||||
}
|
||||
} else {
|
||||
// Foreign exception.
|
||||
exc = (_Unwind_Exception *)malloc(sizeof(_Unwind_Exception));
|
||||
exc->exception_class = kSEHExceptionClass;
|
||||
exc->exception_cleanup = seh_exc_cleanup;
|
||||
memset(exc->private_, 0, sizeof(exc->private_));
|
||||
}
|
||||
if (!ctx) {
|
||||
_unw_init_seh(&cursor, disp->ContextRecord);
|
||||
_unw_seh_set_disp_ctx(&cursor, disp);
|
||||
unw_set_reg(&cursor, UNW_REG_IP, disp->ControlPc-1);
|
||||
ctx = (struct _Unwind_Context *)&cursor;
|
||||
|
||||
if (!IS_UNWINDING(ms_exc->ExceptionFlags)) {
|
||||
if (ours && ms_exc->NumberParameters > 1)
|
||||
action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_FORCE_UNWIND);
|
||||
else
|
||||
action = _UA_SEARCH_PHASE;
|
||||
} else {
|
||||
if (ours && ms_exc->ExceptionInformation[1] == (ULONG_PTR)frame)
|
||||
action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME);
|
||||
else
|
||||
action = _UA_CLEANUP_PHASE;
|
||||
}
|
||||
}
|
||||
|
||||
_LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler() calling personality function %p(1, %d, %llx, %p, %p)", pers, action, exc->exception_class, exc, ctx);
|
||||
urc = pers(1, action, exc->exception_class, exc, ctx);
|
||||
_LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler() personality returned %d", urc);
|
||||
switch (urc) {
|
||||
case _URC_CONTINUE_UNWIND:
|
||||
// If we're in phase 2, and the personality routine said to continue
|
||||
// at the target frame, we're in real trouble.
|
||||
if (action & _UA_HANDLER_FRAME)
|
||||
_LIBUNWIND_ABORT("Personality continued unwind at the target frame!");
|
||||
return ExceptionContinueSearch;
|
||||
case _URC_HANDLER_FOUND:
|
||||
// If we were called by __libunwind_seh_personality(), indicate that
|
||||
// a handler was found; otherwise, initiate phase 2 by unwinding.
|
||||
if (ours && ms_exc->NumberParameters > 1)
|
||||
return 4 /* ExecptionExecuteHandler in mingw */;
|
||||
// This should never happen in phase 2.
|
||||
if (IS_UNWINDING(ms_exc->ExceptionFlags))
|
||||
_LIBUNWIND_ABORT("Personality indicated exception handler in phase 2!");
|
||||
exc->private_[1] = (ULONG_PTR)frame;
|
||||
if (ours) {
|
||||
ms_exc->NumberParameters = 4;
|
||||
ms_exc->ExceptionInformation[1] = (ULONG_PTR)frame;
|
||||
}
|
||||
// FIXME: Indicate target frame in foreign case!
|
||||
// phase 2: the clean up phase
|
||||
RtlUnwindEx(frame, (PVOID)disp->ControlPc, ms_exc, exc, ms_ctx, disp->HistoryTable);
|
||||
_LIBUNWIND_ABORT("RtlUnwindEx() failed");
|
||||
case _URC_INSTALL_CONTEXT: {
|
||||
// If we were called by __libunwind_seh_personality(), indicate that
|
||||
// a handler was found; otherwise, it's time to initiate a collided
|
||||
// unwind to the target.
|
||||
if (ours && !IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1)
|
||||
return 4 /* ExecptionExecuteHandler in mingw */;
|
||||
// This should never happen in phase 1.
|
||||
if (!IS_UNWINDING(ms_exc->ExceptionFlags))
|
||||
_LIBUNWIND_ABORT("Personality installed context during phase 1!");
|
||||
exc->private_[2] = disp->TargetIp;
|
||||
#ifdef __x86_64__
|
||||
unw_get_reg(&cursor, UNW_X86_64_RAX, &retval);
|
||||
unw_get_reg(&cursor, UNW_X86_64_RDX, &exc->private_[3]);
|
||||
#elif defined(__arm__)
|
||||
unw_get_reg(&cursor, UNW_ARM_R0, &retval);
|
||||
unw_get_reg(&cursor, UNW_ARM_R1, &exc->private_[3]);
|
||||
#endif
|
||||
unw_get_reg(&cursor, UNW_REG_IP, &target);
|
||||
ms_exc->ExceptionCode = STATUS_GCC_UNWIND;
|
||||
ms_exc->ExceptionInformation[2] = disp->TargetIp;
|
||||
ms_exc->ExceptionInformation[3] = exc->private_[3];
|
||||
// Give NTRTL some scratch space to keep track of the collided unwind.
|
||||
// Don't use the one that was passed in; we don't want to overwrite the
|
||||
// context in the DISPATCHER_CONTEXT.
|
||||
CONTEXT new_ctx;
|
||||
RtlUnwindEx(frame, (PVOID)target, ms_exc, (PVOID)retval, &new_ctx, disp->HistoryTable);
|
||||
_LIBUNWIND_ABORT("RtlUnwindEx() failed");
|
||||
}
|
||||
// Anything else indicates a serious problem.
|
||||
default: return ExceptionContinueExecution;
|
||||
}
|
||||
}
|
||||
|
||||
/// Personality function returned by \c unw_get_proc_info() in SEH contexts.
|
||||
/// This is a wrapper that calls the real SEH handler function, which in
|
||||
/// turn (at least, for Itanium-style frames) calls the real Itanium
|
||||
/// personality function (see \c _GCC_specific_handler()).
|
||||
extern "C" _Unwind_Reason_Code
|
||||
__libunwind_seh_personality(int version, _Unwind_Action state,
|
||||
uint64_t klass, _Unwind_Exception *exc,
|
||||
struct _Unwind_Context *context) {
|
||||
EXCEPTION_RECORD ms_exc;
|
||||
bool phase2 = (state & (_UA_SEARCH_PHASE|_UA_CLEANUP_PHASE)) == _UA_CLEANUP_PHASE;
|
||||
ms_exc.ExceptionCode = STATUS_GCC_THROW;
|
||||
ms_exc.ExceptionFlags = 0;
|
||||
ms_exc.NumberParameters = 3;
|
||||
ms_exc.ExceptionInformation[0] = (ULONG_PTR)exc;
|
||||
ms_exc.ExceptionInformation[1] = (ULONG_PTR)context;
|
||||
ms_exc.ExceptionInformation[2] = state;
|
||||
DISPATCHER_CONTEXT *disp_ctx = _unw_seh_get_disp_ctx((unw_cursor_t *)context);
|
||||
EXCEPTION_DISPOSITION ms_act = disp_ctx->LanguageHandler(&ms_exc,
|
||||
(PVOID)disp_ctx->EstablisherFrame,
|
||||
disp_ctx->ContextRecord,
|
||||
disp_ctx);
|
||||
switch (ms_act) {
|
||||
case ExceptionContinueSearch: return _URC_CONTINUE_UNWIND;
|
||||
case 4 /*ExceptionExecuteHandler*/:
|
||||
return phase2 ? _URC_INSTALL_CONTEXT : _URC_HANDLER_FOUND;
|
||||
default:
|
||||
return phase2 ? _URC_FATAL_PHASE2_ERROR : _URC_FATAL_PHASE1_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
static _Unwind_Reason_Code
|
||||
unwind_phase2_forced(unw_context_t *uc,
|
||||
_Unwind_Exception *exception_object,
|
||||
_Unwind_Stop_Fn stop, void *stop_parameter) {
|
||||
unw_cursor_t cursor2;
|
||||
unw_init_local(&cursor2, uc);
|
||||
|
||||
// Walk each frame until we reach where search phase said to stop
|
||||
while (unw_step(&cursor2) > 0) {
|
||||
|
||||
// Update info about this frame.
|
||||
unw_proc_info_t frameInfo;
|
||||
if (unw_get_proc_info(&cursor2, &frameInfo) != UNW_ESUCCESS) {
|
||||
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): unw_step "
|
||||
"failed => _URC_END_OF_STACK",
|
||||
(void *)exception_object);
|
||||
return _URC_FATAL_PHASE2_ERROR;
|
||||
}
|
||||
|
||||
// When tracing, print state information.
|
||||
if (_LIBUNWIND_TRACING_UNWINDING) {
|
||||
char functionBuf[512];
|
||||
const char *functionName = functionBuf;
|
||||
unw_word_t offset;
|
||||
if ((unw_get_proc_name(&cursor2, functionBuf, sizeof(functionBuf),
|
||||
&offset) != UNW_ESUCCESS) ||
|
||||
(frameInfo.start_ip + offset > frameInfo.end_ip))
|
||||
functionName = ".anonymous.";
|
||||
_LIBUNWIND_TRACE_UNWINDING(
|
||||
"unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIx64
|
||||
", func=%s, lsda=0x%" PRIx64 ", personality=0x%" PRIx64,
|
||||
(void *)exception_object, frameInfo.start_ip, functionName,
|
||||
frameInfo.lsda, frameInfo.handler);
|
||||
}
|
||||
|
||||
// Call stop function at each frame.
|
||||
_Unwind_Action action =
|
||||
(_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
|
||||
_Unwind_Reason_Code stopResult =
|
||||
(*stop)(1, action, exception_object->exception_class, exception_object,
|
||||
(struct _Unwind_Context *)(&cursor2), stop_parameter);
|
||||
_LIBUNWIND_TRACE_UNWINDING(
|
||||
"unwind_phase2_forced(ex_ojb=%p): stop function returned %d",
|
||||
(void *)exception_object, stopResult);
|
||||
if (stopResult != _URC_NO_REASON) {
|
||||
_LIBUNWIND_TRACE_UNWINDING(
|
||||
"unwind_phase2_forced(ex_ojb=%p): stopped by stop function",
|
||||
(void *)exception_object);
|
||||
return _URC_FATAL_PHASE2_ERROR;
|
||||
}
|
||||
|
||||
// If there is a personality routine, tell it we are unwinding.
|
||||
if (frameInfo.handler != 0) {
|
||||
__personality_routine p =
|
||||
(__personality_routine)(intptr_t)(frameInfo.handler);
|
||||
_LIBUNWIND_TRACE_UNWINDING(
|
||||
"unwind_phase2_forced(ex_ojb=%p): calling personality function %p",
|
||||
(void *)exception_object, (void *)(uintptr_t)p);
|
||||
_Unwind_Reason_Code personalityResult =
|
||||
(*p)(1, action, exception_object->exception_class, exception_object,
|
||||
(struct _Unwind_Context *)(&cursor2));
|
||||
switch (personalityResult) {
|
||||
case _URC_CONTINUE_UNWIND:
|
||||
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
|
||||
"personality returned "
|
||||
"_URC_CONTINUE_UNWIND",
|
||||
(void *)exception_object);
|
||||
// Destructors called, continue unwinding
|
||||
break;
|
||||
case _URC_INSTALL_CONTEXT:
|
||||
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
|
||||
"personality returned "
|
||||
"_URC_INSTALL_CONTEXT",
|
||||
(void *)exception_object);
|
||||
// We may get control back if landing pad calls _Unwind_Resume().
|
||||
unw_resume(&cursor2);
|
||||
break;
|
||||
default:
|
||||
// Personality routine returned an unknown result code.
|
||||
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
|
||||
"personality returned %d, "
|
||||
"_URC_FATAL_PHASE2_ERROR",
|
||||
(void *)exception_object, personalityResult);
|
||||
return _URC_FATAL_PHASE2_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Call stop function one last time and tell it we've reached the end
|
||||
// of the stack.
|
||||
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
|
||||
"function with _UA_END_OF_STACK",
|
||||
(void *)exception_object);
|
||||
_Unwind_Action lastAction =
|
||||
(_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
|
||||
(*stop)(1, lastAction, exception_object->exception_class, exception_object,
|
||||
(struct _Unwind_Context *)(&cursor2), stop_parameter);
|
||||
|
||||
// Clean up phase did not resume at the frame that the search phase said it
|
||||
// would.
|
||||
return _URC_FATAL_PHASE2_ERROR;
|
||||
}
|
||||
|
||||
/// Called by \c __cxa_throw(). Only returns if there is a fatal error.
|
||||
_LIBUNWIND_EXPORT _Unwind_Reason_Code
|
||||
_Unwind_RaiseException(_Unwind_Exception *exception_object) {
|
||||
_LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
|
||||
(void *)exception_object);
|
||||
|
||||
// Mark that this is a non-forced unwind, so _Unwind_Resume()
|
||||
// can do the right thing.
|
||||
memset(exception_object->private_, 0, sizeof(exception_object->private_));
|
||||
|
||||
// phase 1: the search phase
|
||||
// We'll let the system do that for us.
|
||||
RaiseException(STATUS_GCC_THROW, 0, 1, (ULONG_PTR *)&exception_object);
|
||||
|
||||
// If we get here, either something went horribly wrong or we reached the
|
||||
// top of the stack. Either way, let libc++abi call std::terminate().
|
||||
return _URC_END_OF_STACK;
|
||||
}
|
||||
|
||||
/// When \c _Unwind_RaiseException() is in phase2, it hands control
|
||||
/// to the personality function at each frame. The personality
|
||||
/// may force a jump to a landing pad in that function; the landing
|
||||
/// pad code may then call \c _Unwind_Resume() to continue with the
|
||||
/// unwinding. Note: the call to \c _Unwind_Resume() is from compiler
|
||||
/// geneated user code. All other \c _Unwind_* routines are called
|
||||
/// by the C++ runtime \c __cxa_* routines.
|
||||
///
|
||||
/// Note: re-throwing an exception (as opposed to continuing the unwind)
|
||||
/// is implemented by having the code call \c __cxa_rethrow() which
|
||||
/// in turn calls \c _Unwind_Resume_or_Rethrow().
|
||||
_LIBUNWIND_EXPORT void
|
||||
_Unwind_Resume(_Unwind_Exception *exception_object) {
|
||||
_LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object);
|
||||
|
||||
if (exception_object->private_[0] != 0) {
|
||||
unw_context_t uc;
|
||||
|
||||
unw_getcontext(&uc);
|
||||
unwind_phase2_forced(&uc, exception_object,
|
||||
(_Unwind_Stop_Fn) exception_object->private_[0],
|
||||
(void *)exception_object->private_[4]);
|
||||
} else {
|
||||
// Recover the parameters for the unwind from the exception object
|
||||
// so we can start unwinding again.
|
||||
EXCEPTION_RECORD ms_exc;
|
||||
CONTEXT ms_ctx;
|
||||
UNWIND_HISTORY_TABLE hist;
|
||||
|
||||
ms_exc.ExceptionCode = STATUS_GCC_THROW;
|
||||
ms_exc.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
|
||||
ms_exc.NumberParameters = 4;
|
||||
ms_exc.ExceptionInformation[0] = (ULONG_PTR)exception_object;
|
||||
ms_exc.ExceptionInformation[1] = exception_object->private_[1];
|
||||
ms_exc.ExceptionInformation[2] = exception_object->private_[2];
|
||||
ms_exc.ExceptionInformation[3] = exception_object->private_[3];
|
||||
RtlUnwindEx((PVOID)exception_object->private_[1],
|
||||
(PVOID)exception_object->private_[2], &ms_exc,
|
||||
exception_object, &ms_ctx, &hist);
|
||||
}
|
||||
|
||||
// Clients assume _Unwind_Resume() does not return, so all we can do is abort.
|
||||
_LIBUNWIND_ABORT("_Unwind_Resume() can't return");
|
||||
}
|
||||
|
||||
/// Not used by C++.
|
||||
/// Unwinds stack, calling "stop" function at each frame.
|
||||
/// Could be used to implement \c longjmp().
|
||||
_LIBUNWIND_EXPORT _Unwind_Reason_Code
|
||||
_Unwind_ForcedUnwind(_Unwind_Exception *exception_object,
|
||||
_Unwind_Stop_Fn stop, void *stop_parameter) {
|
||||
_LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)",
|
||||
(void *)exception_object, (void *)(uintptr_t)stop);
|
||||
unw_context_t uc;
|
||||
unw_getcontext(&uc);
|
||||
|
||||
// Mark that this is a forced unwind, so _Unwind_Resume() can do
|
||||
// the right thing.
|
||||
exception_object->private_[0] = (uintptr_t) stop;
|
||||
exception_object->private_[4] = (uintptr_t) stop_parameter;
|
||||
|
||||
// do it
|
||||
return unwind_phase2_forced(&uc, exception_object, stop, stop_parameter);
|
||||
}
|
||||
|
||||
/// Called by personality handler during phase 2 to get LSDA for current frame.
|
||||
_LIBUNWIND_EXPORT uintptr_t
|
||||
_Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
|
||||
uintptr_t result = (uintptr_t)_unw_seh_get_disp_ctx((unw_cursor_t *)context)->HandlerData;
|
||||
_LIBUNWIND_TRACE_API(
|
||||
"_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR,
|
||||
(void *)context, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/// Called by personality handler during phase 2 to find the start of the
|
||||
/// function.
|
||||
_LIBUNWIND_EXPORT uintptr_t
|
||||
_Unwind_GetRegionStart(struct _Unwind_Context *context) {
|
||||
DISPATCHER_CONTEXT *disp = _unw_seh_get_disp_ctx((unw_cursor_t *)context);
|
||||
uintptr_t result = (uintptr_t)disp->FunctionEntry->BeginAddress + disp->ImageBase;
|
||||
_LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR,
|
||||
(void *)context, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static int
|
||||
_unw_init_seh(unw_cursor_t *cursor, CONTEXT *context) {
|
||||
#ifdef _LIBUNWIND_TARGET_X86_64
|
||||
new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86_64>(
|
||||
context, LocalAddressSpace::sThisAddressSpace);
|
||||
auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
|
||||
co->setInfoBasedOnIPRegister();
|
||||
return UNW_ESUCCESS;
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm>(
|
||||
context, LocalAddressSpace::sThisAddressSpace);
|
||||
auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
|
||||
co->setInfoBasedOnIPRegister();
|
||||
return UNW_ESUCCESS;
|
||||
#else
|
||||
return UNW_EINVAL;
|
||||
#endif
|
||||
}
|
||||
|
||||
static DISPATCHER_CONTEXT *
|
||||
_unw_seh_get_disp_ctx(unw_cursor_t *cursor) {
|
||||
#ifdef _LIBUNWIND_TARGET_X86_64
|
||||
return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->getDispatcherContext();
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->getDispatcherContext();
|
||||
#else
|
||||
return nullptr;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void
|
||||
_unw_seh_set_disp_ctx(unw_cursor_t *cursor, DISPATCHER_CONTEXT *disp) {
|
||||
#ifdef _LIBUNWIND_TARGET_X86_64
|
||||
reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->setDispatcherContext(disp);
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->setDispatcherContext(disp);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
@ -18,10 +18,51 @@
|
||||
#include <stdlib.h>
|
||||
#include <unwind.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#include <ntverp.h>
|
||||
#endif
|
||||
#ifdef __APPLE__
|
||||
#include <mach-o/dyld.h>
|
||||
#endif
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
// Provide a definition for the DISPATCHER_CONTEXT struct for old (Win7 and
|
||||
// earlier) SDKs.
|
||||
// MinGW-w64 has always provided this struct.
|
||||
#if defined(_WIN32) && defined(_LIBUNWIND_TARGET_X86_64) && \
|
||||
!defined(__MINGW32__) && VER_PRODUCTBUILD < 8000
|
||||
struct _DISPATCHER_CONTEXT {
|
||||
ULONG64 ControlPc;
|
||||
ULONG64 ImageBase;
|
||||
PRUNTIME_FUNCTION FunctionEntry;
|
||||
ULONG64 EstablisherFrame;
|
||||
ULONG64 TargetIp;
|
||||
PCONTEXT ContextRecord;
|
||||
PEXCEPTION_ROUTINE LanguageHandler;
|
||||
PVOID HandlerData;
|
||||
PUNWIND_HISTORY_TABLE HistoryTable;
|
||||
ULONG ScopeIndex;
|
||||
ULONG Fill0;
|
||||
};
|
||||
#endif
|
||||
|
||||
struct UNWIND_INFO {
|
||||
uint8_t Version : 3;
|
||||
uint8_t Flags : 5;
|
||||
uint8_t SizeOfProlog;
|
||||
uint8_t CountOfCodes;
|
||||
uint8_t FrameRegister : 4;
|
||||
uint8_t FrameOffset : 4;
|
||||
uint16_t UnwindCodes[2];
|
||||
};
|
||||
|
||||
extern "C" _Unwind_Reason_Code __libunwind_seh_personality(
|
||||
int, _Unwind_Action, uint64_t, _Unwind_Exception *,
|
||||
struct _Unwind_Context *);
|
||||
|
||||
#endif
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include "AddressSpace.hpp"
|
||||
@ -412,6 +453,472 @@ public:
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32)
|
||||
|
||||
/// \c UnwindCursor contains all state (including all register values) during
|
||||
/// an unwind. This is normally stack-allocated inside a unw_cursor_t.
|
||||
template <typename A, typename R>
|
||||
class UnwindCursor : public AbstractUnwindCursor {
|
||||
typedef typename A::pint_t pint_t;
|
||||
public:
|
||||
UnwindCursor(unw_context_t *context, A &as);
|
||||
UnwindCursor(CONTEXT *context, A &as);
|
||||
UnwindCursor(A &as, void *threadArg);
|
||||
virtual ~UnwindCursor() {}
|
||||
virtual bool validReg(int);
|
||||
virtual unw_word_t getReg(int);
|
||||
virtual void setReg(int, unw_word_t);
|
||||
virtual bool validFloatReg(int);
|
||||
virtual unw_fpreg_t getFloatReg(int);
|
||||
virtual void setFloatReg(int, unw_fpreg_t);
|
||||
virtual int step();
|
||||
virtual void getInfo(unw_proc_info_t *);
|
||||
virtual void jumpto();
|
||||
virtual bool isSignalFrame();
|
||||
virtual bool getFunctionName(char *buf, size_t len, unw_word_t *off);
|
||||
virtual void setInfoBasedOnIPRegister(bool isReturnAddress = false);
|
||||
virtual const char *getRegisterName(int num);
|
||||
#ifdef __arm__
|
||||
virtual void saveVFPAsX();
|
||||
#endif
|
||||
|
||||
DISPATCHER_CONTEXT *getDispatcherContext() { return &_dispContext; }
|
||||
void setDispatcherContext(DISPATCHER_CONTEXT *disp) { _dispContext = *disp; }
|
||||
|
||||
private:
|
||||
|
||||
pint_t getLastPC() const { return _dispContext.ControlPc; }
|
||||
void setLastPC(pint_t pc) { _dispContext.ControlPc = pc; }
|
||||
RUNTIME_FUNCTION *lookUpSEHUnwindInfo(pint_t pc, pint_t *base) {
|
||||
_dispContext.FunctionEntry = RtlLookupFunctionEntry(pc,
|
||||
&_dispContext.ImageBase,
|
||||
_dispContext.HistoryTable);
|
||||
*base = _dispContext.ImageBase;
|
||||
return _dispContext.FunctionEntry;
|
||||
}
|
||||
bool getInfoFromSEH(pint_t pc);
|
||||
int stepWithSEHData() {
|
||||
_dispContext.LanguageHandler = RtlVirtualUnwind(UNW_FLAG_UHANDLER,
|
||||
_dispContext.ImageBase,
|
||||
_dispContext.ControlPc,
|
||||
_dispContext.FunctionEntry,
|
||||
_dispContext.ContextRecord,
|
||||
&_dispContext.HandlerData,
|
||||
&_dispContext.EstablisherFrame,
|
||||
NULL);
|
||||
// Update some fields of the unwind info now, since we have them.
|
||||
_info.lsda = reinterpret_cast<unw_word_t>(_dispContext.HandlerData);
|
||||
if (_dispContext.LanguageHandler) {
|
||||
_info.handler = reinterpret_cast<unw_word_t>(__libunwind_seh_personality);
|
||||
} else
|
||||
_info.handler = 0;
|
||||
return UNW_STEP_SUCCESS;
|
||||
}
|
||||
|
||||
A &_addressSpace;
|
||||
unw_proc_info_t _info;
|
||||
DISPATCHER_CONTEXT _dispContext;
|
||||
CONTEXT _msContext;
|
||||
UNWIND_HISTORY_TABLE _histTable;
|
||||
bool _unwindInfoMissing;
|
||||
};
|
||||
|
||||
|
||||
template <typename A, typename R>
|
||||
UnwindCursor<A, R>::UnwindCursor(unw_context_t *context, A &as)
|
||||
: _addressSpace(as), _unwindInfoMissing(false) {
|
||||
static_assert((check_fit<UnwindCursor<A, R>, unw_cursor_t>::does_fit),
|
||||
"UnwindCursor<> does not fit in unw_cursor_t");
|
||||
memset(&_info, 0, sizeof(_info));
|
||||
memset(&_histTable, 0, sizeof(_histTable));
|
||||
_dispContext.ContextRecord = &_msContext;
|
||||
_dispContext.HistoryTable = &_histTable;
|
||||
// Initialize MS context from ours.
|
||||
R r(context);
|
||||
_msContext.ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_FLOATING_POINT;
|
||||
#if defined(_LIBUNWIND_TARGET_X86_64)
|
||||
_msContext.Rax = r.getRegister(UNW_X86_64_RAX);
|
||||
_msContext.Rcx = r.getRegister(UNW_X86_64_RCX);
|
||||
_msContext.Rdx = r.getRegister(UNW_X86_64_RDX);
|
||||
_msContext.Rbx = r.getRegister(UNW_X86_64_RBX);
|
||||
_msContext.Rsp = r.getRegister(UNW_X86_64_RSP);
|
||||
_msContext.Rbp = r.getRegister(UNW_X86_64_RBP);
|
||||
_msContext.Rsi = r.getRegister(UNW_X86_64_RSI);
|
||||
_msContext.Rdi = r.getRegister(UNW_X86_64_RDI);
|
||||
_msContext.R8 = r.getRegister(UNW_X86_64_R8);
|
||||
_msContext.R9 = r.getRegister(UNW_X86_64_R9);
|
||||
_msContext.R10 = r.getRegister(UNW_X86_64_R10);
|
||||
_msContext.R11 = r.getRegister(UNW_X86_64_R11);
|
||||
_msContext.R12 = r.getRegister(UNW_X86_64_R12);
|
||||
_msContext.R13 = r.getRegister(UNW_X86_64_R13);
|
||||
_msContext.R14 = r.getRegister(UNW_X86_64_R14);
|
||||
_msContext.R15 = r.getRegister(UNW_X86_64_R15);
|
||||
_msContext.Rip = r.getRegister(UNW_REG_IP);
|
||||
union {
|
||||
v128 v;
|
||||
M128A m;
|
||||
} t;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM0);
|
||||
_msContext.Xmm0 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM1);
|
||||
_msContext.Xmm1 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM2);
|
||||
_msContext.Xmm2 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM3);
|
||||
_msContext.Xmm3 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM4);
|
||||
_msContext.Xmm4 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM5);
|
||||
_msContext.Xmm5 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM6);
|
||||
_msContext.Xmm6 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM7);
|
||||
_msContext.Xmm7 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM8);
|
||||
_msContext.Xmm8 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM9);
|
||||
_msContext.Xmm9 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM10);
|
||||
_msContext.Xmm10 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM11);
|
||||
_msContext.Xmm11 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM12);
|
||||
_msContext.Xmm12 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM13);
|
||||
_msContext.Xmm13 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM14);
|
||||
_msContext.Xmm14 = t.m;
|
||||
t.v = r.getVectorRegister(UNW_X86_64_XMM15);
|
||||
_msContext.Xmm15 = t.m;
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
_msContext.R0 = r.getRegister(UNW_ARM_R0);
|
||||
_msContext.R1 = r.getRegister(UNW_ARM_R1);
|
||||
_msContext.R2 = r.getRegister(UNW_ARM_R2);
|
||||
_msContext.R3 = r.getRegister(UNW_ARM_R3);
|
||||
_msContext.R4 = r.getRegister(UNW_ARM_R4);
|
||||
_msContext.R5 = r.getRegister(UNW_ARM_R5);
|
||||
_msContext.R6 = r.getRegister(UNW_ARM_R6);
|
||||
_msContext.R7 = r.getRegister(UNW_ARM_R7);
|
||||
_msContext.R8 = r.getRegister(UNW_ARM_R8);
|
||||
_msContext.R9 = r.getRegister(UNW_ARM_R9);
|
||||
_msContext.R10 = r.getRegister(UNW_ARM_R10);
|
||||
_msContext.R11 = r.getRegister(UNW_ARM_R11);
|
||||
_msContext.R12 = r.getRegister(UNW_ARM_R12);
|
||||
_msContext.Sp = r.getRegister(UNW_ARM_SP);
|
||||
_msContext.Lr = r.getRegister(UNW_ARM_LR);
|
||||
_msContext.Pc = r.getRegister(UNW_ARM_PC);
|
||||
for (int r = UNW_ARM_D0; r <= UNW_ARM_D31; ++r) {
|
||||
union {
|
||||
uint64_t w;
|
||||
double d;
|
||||
} d;
|
||||
d.d = r.getFloatRegister(r);
|
||||
_msContext.D[r - UNW_ARM_D0] = d.w;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename A, typename R>
|
||||
UnwindCursor<A, R>::UnwindCursor(CONTEXT *context, A &as)
|
||||
: _addressSpace(as), _unwindInfoMissing(false) {
|
||||
static_assert((check_fit<UnwindCursor<A, R>, unw_cursor_t>::does_fit),
|
||||
"UnwindCursor<> does not fit in unw_cursor_t");
|
||||
memset(&_info, 0, sizeof(_info));
|
||||
memset(&_histTable, 0, sizeof(_histTable));
|
||||
_dispContext.ContextRecord = &_msContext;
|
||||
_dispContext.HistoryTable = &_histTable;
|
||||
_msContext = *context;
|
||||
}
|
||||
|
||||
|
||||
template <typename A, typename R>
|
||||
bool UnwindCursor<A, R>::validReg(int regNum) {
|
||||
if (regNum == UNW_REG_IP || regNum == UNW_REG_SP) return true;
|
||||
#if defined(_LIBUNWIND_TARGET_X86_64)
|
||||
if (regNum >= UNW_X86_64_RAX && regNum <= UNW_X86_64_R15) return true;
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
if (regNum >= UNW_ARM_R0 && regNum <= UNW_ARM_R15) return true;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename A, typename R>
|
||||
unw_word_t UnwindCursor<A, R>::getReg(int regNum) {
|
||||
switch (regNum) {
|
||||
#if defined(_LIBUNWIND_TARGET_X86_64)
|
||||
case UNW_REG_IP: return _msContext.Rip;
|
||||
case UNW_X86_64_RAX: return _msContext.Rax;
|
||||
case UNW_X86_64_RDX: return _msContext.Rdx;
|
||||
case UNW_X86_64_RCX: return _msContext.Rcx;
|
||||
case UNW_X86_64_RBX: return _msContext.Rbx;
|
||||
case UNW_REG_SP:
|
||||
case UNW_X86_64_RSP: return _msContext.Rsp;
|
||||
case UNW_X86_64_RBP: return _msContext.Rbp;
|
||||
case UNW_X86_64_RSI: return _msContext.Rsi;
|
||||
case UNW_X86_64_RDI: return _msContext.Rdi;
|
||||
case UNW_X86_64_R8: return _msContext.R8;
|
||||
case UNW_X86_64_R9: return _msContext.R9;
|
||||
case UNW_X86_64_R10: return _msContext.R10;
|
||||
case UNW_X86_64_R11: return _msContext.R11;
|
||||
case UNW_X86_64_R12: return _msContext.R12;
|
||||
case UNW_X86_64_R13: return _msContext.R13;
|
||||
case UNW_X86_64_R14: return _msContext.R14;
|
||||
case UNW_X86_64_R15: return _msContext.R15;
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
case UNW_ARM_R0: return _msContext.R0;
|
||||
case UNW_ARM_R1: return _msContext.R1;
|
||||
case UNW_ARM_R2: return _msContext.R2;
|
||||
case UNW_ARM_R3: return _msContext.R3;
|
||||
case UNW_ARM_R4: return _msContext.R4;
|
||||
case UNW_ARM_R5: return _msContext.R5;
|
||||
case UNW_ARM_R6: return _msContext.R6;
|
||||
case UNW_ARM_R7: return _msContext.R7;
|
||||
case UNW_ARM_R8: return _msContext.R8;
|
||||
case UNW_ARM_R9: return _msContext.R9;
|
||||
case UNW_ARM_R10: return _msContext.R10;
|
||||
case UNW_ARM_R11: return _msContext.R11;
|
||||
case UNW_ARM_R12: return _msContext.R12;
|
||||
case UNW_REG_SP:
|
||||
case UNW_ARM_SP: return _msContext.Sp;
|
||||
case UNW_ARM_LR: return _msContext.Lr;
|
||||
case UNW_REG_IP:
|
||||
case UNW_ARM_PC: return _msContext.Pc;
|
||||
#endif
|
||||
}
|
||||
_LIBUNWIND_ABORT("unsupported register");
|
||||
}
|
||||
|
||||
template <typename A, typename R>
|
||||
void UnwindCursor<A, R>::setReg(int regNum, unw_word_t value) {
|
||||
switch (regNum) {
|
||||
#if defined(_LIBUNWIND_TARGET_X86_64)
|
||||
case UNW_REG_IP: _msContext.Rip = value; break;
|
||||
case UNW_X86_64_RAX: _msContext.Rax = value; break;
|
||||
case UNW_X86_64_RDX: _msContext.Rdx = value; break;
|
||||
case UNW_X86_64_RCX: _msContext.Rcx = value; break;
|
||||
case UNW_X86_64_RBX: _msContext.Rbx = value; break;
|
||||
case UNW_REG_SP:
|
||||
case UNW_X86_64_RSP: _msContext.Rsp = value; break;
|
||||
case UNW_X86_64_RBP: _msContext.Rbp = value; break;
|
||||
case UNW_X86_64_RSI: _msContext.Rsi = value; break;
|
||||
case UNW_X86_64_RDI: _msContext.Rdi = value; break;
|
||||
case UNW_X86_64_R8: _msContext.R8 = value; break;
|
||||
case UNW_X86_64_R9: _msContext.R9 = value; break;
|
||||
case UNW_X86_64_R10: _msContext.R10 = value; break;
|
||||
case UNW_X86_64_R11: _msContext.R11 = value; break;
|
||||
case UNW_X86_64_R12: _msContext.R12 = value; break;
|
||||
case UNW_X86_64_R13: _msContext.R13 = value; break;
|
||||
case UNW_X86_64_R14: _msContext.R14 = value; break;
|
||||
case UNW_X86_64_R15: _msContext.R15 = value; break;
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
case UNW_ARM_R0: _msContext.R0 = value; break;
|
||||
case UNW_ARM_R1: _msContext.R1 = value; break;
|
||||
case UNW_ARM_R2: _msContext.R2 = value; break;
|
||||
case UNW_ARM_R3: _msContext.R3 = value; break;
|
||||
case UNW_ARM_R4: _msContext.R4 = value; break;
|
||||
case UNW_ARM_R5: _msContext.R5 = value; break;
|
||||
case UNW_ARM_R6: _msContext.R6 = value; break;
|
||||
case UNW_ARM_R7: _msContext.R7 = value; break;
|
||||
case UNW_ARM_R8: _msContext.R8 = value; break;
|
||||
case UNW_ARM_R9: _msContext.R9 = value; break;
|
||||
case UNW_ARM_R10: _msContext.R10 = value; break;
|
||||
case UNW_ARM_R11: _msContext.R11 = value; break;
|
||||
case UNW_ARM_R12: _msContext.R12 = value; break;
|
||||
case UNW_REG_SP:
|
||||
case UNW_ARM_SP: _msContext.Sp = value; break;
|
||||
case UNW_ARM_LR: _msContext.Lr = value; break;
|
||||
case UNW_REG_IP:
|
||||
case UNW_ARM_PC: _msContext.Pc = value; break;
|
||||
#endif
|
||||
default:
|
||||
_LIBUNWIND_ABORT("unsupported register");
|
||||
}
|
||||
}
|
||||
|
||||
template <typename A, typename R>
|
||||
bool UnwindCursor<A, R>::validFloatReg(int regNum) {
|
||||
#if defined(_LIBUNWIND_TARGET_ARM)
|
||||
if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) return true;
|
||||
if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) return true;
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename A, typename R>
|
||||
unw_fpreg_t UnwindCursor<A, R>::getFloatReg(int regNum) {
|
||||
#if defined(_LIBUNWIND_TARGET_ARM)
|
||||
if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) {
|
||||
union {
|
||||
uint32_t w;
|
||||
float f;
|
||||
} d;
|
||||
d.w = _msContext.S[regNum - UNW_ARM_S0];
|
||||
return d.f;
|
||||
}
|
||||
if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) {
|
||||
union {
|
||||
uint64_t w;
|
||||
double d;
|
||||
} d;
|
||||
d.w = _msContext.D[regNum - UNW_ARM_D0];
|
||||
return d.d;
|
||||
}
|
||||
_LIBUNWIND_ABORT("unsupported float register");
|
||||
#else
|
||||
_LIBUNWIND_ABORT("float registers unimplemented");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename A, typename R>
|
||||
void UnwindCursor<A, R>::setFloatReg(int regNum, unw_fpreg_t value) {
|
||||
#if defined(_LIBUNWIND_TARGET_ARM)
|
||||
if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) {
|
||||
union {
|
||||
uint32_t w;
|
||||
float f;
|
||||
} d;
|
||||
d.f = value;
|
||||
_msContext.S[regNum - UNW_ARM_S0] = d.w;
|
||||
}
|
||||
if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) {
|
||||
union {
|
||||
uint64_t w;
|
||||
double d;
|
||||
} d;
|
||||
d.d = value;
|
||||
_msContext.D[regNum - UNW_ARM_D0] = d.w;
|
||||
}
|
||||
_LIBUNWIND_ABORT("unsupported float register");
|
||||
#else
|
||||
_LIBUNWIND_ABORT("float registers unimplemented");
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename A, typename R> void UnwindCursor<A, R>::jumpto() {
|
||||
RtlRestoreContext(&_msContext, nullptr);
|
||||
}
|
||||
|
||||
#ifdef __arm__
|
||||
template <typename A, typename R> void UnwindCursor<A, R>::saveVFPAsX() {}
|
||||
#endif
|
||||
|
||||
template <typename A, typename R>
|
||||
const char *UnwindCursor<A, R>::getRegisterName(int regNum) {
|
||||
switch (regNum) {
|
||||
#if defined(_LIBUNWIND_TARGET_X86_64)
|
||||
case UNW_REG_IP: return "rip";
|
||||
case UNW_X86_64_RAX: return "rax";
|
||||
case UNW_X86_64_RDX: return "rdx";
|
||||
case UNW_X86_64_RCX: return "rcx";
|
||||
case UNW_X86_64_RBX: return "rbx";
|
||||
case UNW_REG_SP:
|
||||
case UNW_X86_64_RSP: return "rsp";
|
||||
case UNW_X86_64_RBP: return "rbp";
|
||||
case UNW_X86_64_RSI: return "rsi";
|
||||
case UNW_X86_64_RDI: return "rdi";
|
||||
case UNW_X86_64_R8: return "r8";
|
||||
case UNW_X86_64_R9: return "r9";
|
||||
case UNW_X86_64_R10: return "r10";
|
||||
case UNW_X86_64_R11: return "r11";
|
||||
case UNW_X86_64_R12: return "r12";
|
||||
case UNW_X86_64_R13: return "r13";
|
||||
case UNW_X86_64_R14: return "r14";
|
||||
case UNW_X86_64_R15: return "r15";
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
case UNW_ARM_R0: return "r0";
|
||||
case UNW_ARM_R1: return "r1";
|
||||
case UNW_ARM_R2: return "r2";
|
||||
case UNW_ARM_R3: return "r3";
|
||||
case UNW_ARM_R4: return "r4";
|
||||
case UNW_ARM_R5: return "r5";
|
||||
case UNW_ARM_R6: return "r6";
|
||||
case UNW_ARM_R7: return "r7";
|
||||
case UNW_ARM_R8: return "r8";
|
||||
case UNW_ARM_R9: return "r9";
|
||||
case UNW_ARM_R10: return "r10";
|
||||
case UNW_ARM_R11: return "r11";
|
||||
case UNW_ARM_R12: return "r12";
|
||||
case UNW_REG_SP:
|
||||
case UNW_ARM_SP: return "sp";
|
||||
case UNW_ARM_LR: return "lr";
|
||||
case UNW_REG_IP:
|
||||
case UNW_ARM_PC: return "pc";
|
||||
case UNW_ARM_S0: return "s0";
|
||||
case UNW_ARM_S1: return "s1";
|
||||
case UNW_ARM_S2: return "s2";
|
||||
case UNW_ARM_S3: return "s3";
|
||||
case UNW_ARM_S4: return "s4";
|
||||
case UNW_ARM_S5: return "s5";
|
||||
case UNW_ARM_S6: return "s6";
|
||||
case UNW_ARM_S7: return "s7";
|
||||
case UNW_ARM_S8: return "s8";
|
||||
case UNW_ARM_S9: return "s9";
|
||||
case UNW_ARM_S10: return "s10";
|
||||
case UNW_ARM_S11: return "s11";
|
||||
case UNW_ARM_S12: return "s12";
|
||||
case UNW_ARM_S13: return "s13";
|
||||
case UNW_ARM_S14: return "s14";
|
||||
case UNW_ARM_S15: return "s15";
|
||||
case UNW_ARM_S16: return "s16";
|
||||
case UNW_ARM_S17: return "s17";
|
||||
case UNW_ARM_S18: return "s18";
|
||||
case UNW_ARM_S19: return "s19";
|
||||
case UNW_ARM_S20: return "s20";
|
||||
case UNW_ARM_S21: return "s21";
|
||||
case UNW_ARM_S22: return "s22";
|
||||
case UNW_ARM_S23: return "s23";
|
||||
case UNW_ARM_S24: return "s24";
|
||||
case UNW_ARM_S25: return "s25";
|
||||
case UNW_ARM_S26: return "s26";
|
||||
case UNW_ARM_S27: return "s27";
|
||||
case UNW_ARM_S28: return "s28";
|
||||
case UNW_ARM_S29: return "s29";
|
||||
case UNW_ARM_S30: return "s30";
|
||||
case UNW_ARM_S31: return "s31";
|
||||
case UNW_ARM_D0: return "d0";
|
||||
case UNW_ARM_D1: return "d1";
|
||||
case UNW_ARM_D2: return "d2";
|
||||
case UNW_ARM_D3: return "d3";
|
||||
case UNW_ARM_D4: return "d4";
|
||||
case UNW_ARM_D5: return "d5";
|
||||
case UNW_ARM_D6: return "d6";
|
||||
case UNW_ARM_D7: return "d7";
|
||||
case UNW_ARM_D8: return "d8";
|
||||
case UNW_ARM_D9: return "d9";
|
||||
case UNW_ARM_D10: return "d10";
|
||||
case UNW_ARM_D11: return "d11";
|
||||
case UNW_ARM_D12: return "d12";
|
||||
case UNW_ARM_D13: return "d13";
|
||||
case UNW_ARM_D14: return "d14";
|
||||
case UNW_ARM_D15: return "d15";
|
||||
case UNW_ARM_D16: return "d16";
|
||||
case UNW_ARM_D17: return "d17";
|
||||
case UNW_ARM_D18: return "d18";
|
||||
case UNW_ARM_D19: return "d19";
|
||||
case UNW_ARM_D20: return "d20";
|
||||
case UNW_ARM_D21: return "d21";
|
||||
case UNW_ARM_D22: return "d22";
|
||||
case UNW_ARM_D23: return "d23";
|
||||
case UNW_ARM_D24: return "d24";
|
||||
case UNW_ARM_D25: return "d25";
|
||||
case UNW_ARM_D26: return "d26";
|
||||
case UNW_ARM_D27: return "d27";
|
||||
case UNW_ARM_D28: return "d28";
|
||||
case UNW_ARM_D29: return "d29";
|
||||
case UNW_ARM_D30: return "d30";
|
||||
case UNW_ARM_D31: return "d31";
|
||||
#endif
|
||||
default:
|
||||
_LIBUNWIND_ABORT("unsupported register");
|
||||
}
|
||||
}
|
||||
|
||||
template <typename A, typename R> bool UnwindCursor<A, R>::isSignalFrame() {
|
||||
return false;
|
||||
}
|
||||
|
||||
#else // !defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) || !defined(_WIN32)
|
||||
|
||||
/// UnwindCursor contains all state (including all register values) during
|
||||
/// an unwind. This is normally stack allocated inside a unw_cursor_t.
|
||||
template <typename A, typename R>
|
||||
@ -651,6 +1158,20 @@ private:
|
||||
#endif
|
||||
#endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
// For runtime environments using SEH unwind data without Windows runtime
|
||||
// support.
|
||||
pint_t getLastPC() const { /* FIXME: Implement */ return 0; }
|
||||
void setLastPC(pint_t pc) { /* FIXME: Implement */ }
|
||||
RUNTIME_FUNCTION *lookUpSEHUnwindInfo(pint_t pc, pint_t *base) {
|
||||
/* FIXME: Implement */
|
||||
*base = 0;
|
||||
return nullptr;
|
||||
}
|
||||
bool getInfoFromSEH(pint_t pc);
|
||||
int stepWithSEHData() { /* FIXME: Implement */ return 0; }
|
||||
#endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
|
||||
|
||||
A &_addressSpace;
|
||||
R _registers;
|
||||
@ -727,6 +1248,8 @@ template <typename A, typename R> bool UnwindCursor<A, R>::isSignalFrame() {
|
||||
return _isSignalFrame;
|
||||
}
|
||||
|
||||
#endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
|
||||
#if defined(_LIBUNWIND_ARM_EHABI)
|
||||
struct EHABIIndexEntry {
|
||||
uint32_t functionOffset;
|
||||
@ -1261,6 +1784,55 @@ bool UnwindCursor<A, R>::getInfoFromCompactEncodingSection(pint_t pc,
|
||||
#endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
|
||||
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
template <typename A, typename R>
|
||||
bool UnwindCursor<A, R>::getInfoFromSEH(pint_t pc) {
|
||||
pint_t base;
|
||||
RUNTIME_FUNCTION *unwindEntry = lookUpSEHUnwindInfo(pc, &base);
|
||||
if (!unwindEntry) {
|
||||
_LIBUNWIND_DEBUG_LOG("\tpc not in table, pc=0x%llX", (uint64_t) pc);
|
||||
return false;
|
||||
}
|
||||
_info.gp = 0;
|
||||
_info.flags = 0;
|
||||
_info.format = 0;
|
||||
_info.unwind_info_size = sizeof(RUNTIME_FUNCTION);
|
||||
_info.unwind_info = reinterpret_cast<unw_word_t>(unwindEntry);
|
||||
_info.extra = base;
|
||||
_info.start_ip = base + unwindEntry->BeginAddress;
|
||||
#ifdef _LIBUNWIND_TARGET_X86_64
|
||||
_info.end_ip = base + unwindEntry->EndAddress;
|
||||
// Only fill in the handler and LSDA if they're stale.
|
||||
if (pc != getLastPC()) {
|
||||
UNWIND_INFO *xdata = reinterpret_cast<UNWIND_INFO *>(base + unwindEntry->UnwindData);
|
||||
if (xdata->Flags & (UNW_FLAG_EHANDLER|UNW_FLAG_UHANDLER)) {
|
||||
// The personality is given in the UNWIND_INFO itself. The LSDA immediately
|
||||
// follows the UNWIND_INFO. (This follows how both Clang and MSVC emit
|
||||
// these structures.)
|
||||
// N.B. UNWIND_INFO structs are DWORD-aligned.
|
||||
uint32_t lastcode = (xdata->CountOfCodes + 1) & ~1;
|
||||
const uint32_t *handler = reinterpret_cast<uint32_t *>(&xdata->UnwindCodes[lastcode]);
|
||||
_info.lsda = reinterpret_cast<unw_word_t>(handler+1);
|
||||
if (*handler) {
|
||||
_info.handler = reinterpret_cast<unw_word_t>(__libunwind_seh_personality);
|
||||
} else
|
||||
_info.handler = 0;
|
||||
} else {
|
||||
_info.lsda = 0;
|
||||
_info.handler = 0;
|
||||
}
|
||||
}
|
||||
#elif defined(_LIBUNWIND_TARGET_ARM)
|
||||
_info.end_ip = _info.start_ip + unwindEntry->FunctionLength;
|
||||
_info.lsda = 0; // FIXME
|
||||
_info.handler = 0; // FIXME
|
||||
#endif
|
||||
setLastPC(pc);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
template <typename A, typename R>
|
||||
void UnwindCursor<A, R>::setInfoBasedOnIPRegister(bool isReturnAddress) {
|
||||
pint_t pc = (pint_t)this->getReg(UNW_REG_IP);
|
||||
@ -1304,6 +1876,12 @@ void UnwindCursor<A, R>::setInfoBasedOnIPRegister(bool isReturnAddress) {
|
||||
}
|
||||
#endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
// If there is SEH unwind info, look there next.
|
||||
if (this->getInfoFromSEH(pc))
|
||||
return;
|
||||
#endif
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
|
||||
// If there is dwarf unwind info, look there next.
|
||||
if (sects.dwarf_section != 0) {
|
||||
@ -1396,12 +1974,15 @@ int UnwindCursor<A, R>::step() {
|
||||
int result;
|
||||
#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
|
||||
result = this->stepWithCompactEncoding();
|
||||
#elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
result = this->stepWithSEHData();
|
||||
#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
|
||||
result = this->stepWithDwarfFDE();
|
||||
#elif defined(_LIBUNWIND_ARM_EHABI)
|
||||
result = this->stepWithEHABI();
|
||||
#else
|
||||
#error Need _LIBUNWIND_SUPPORT_COMPACT_UNWIND or \
|
||||
_LIBUNWIND_SUPPORT_SEH_UNWIND or \
|
||||
_LIBUNWIND_SUPPORT_DWARF_UNWIND or \
|
||||
_LIBUNWIND_ARM_EHABI
|
||||
#endif
|
||||
|
||||
@ -25,6 +25,10 @@
|
||||
|
||||
#if defined(_LIBUNWIND_BUILD_ZERO_COST_APIS)
|
||||
|
||||
#if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
|
||||
#define private_1 private_[0]
|
||||
#endif
|
||||
|
||||
/// Called by __cxa_rethrow().
|
||||
_LIBUNWIND_EXPORT _Unwind_Reason_Code
|
||||
_Unwind_Resume_or_Rethrow(_Unwind_Exception *exception_object) {
|
||||
|
||||
@ -32,6 +32,8 @@
|
||||
|
||||
#if !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__)
|
||||
|
||||
#ifndef _LIBUNWIND_SUPPORT_SEH_UNWIND
|
||||
|
||||
static _Unwind_Reason_Code
|
||||
unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
|
||||
unw_init_local(cursor, uc);
|
||||
@ -449,6 +451,7 @@ _Unwind_GetRegionStart(struct _Unwind_Context *context) {
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif // !_LIBUNWIND_SUPPORT_SEH_UNWIND
|
||||
|
||||
/// Called by personality handler during phase 2 if a foreign exception
|
||||
// is caught.
|
||||
|
||||
@ -38,7 +38,11 @@
|
||||
#define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
|
||||
#endif
|
||||
#elif defined(_WIN32)
|
||||
#define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
|
||||
#ifdef __SEH__
|
||||
#define _LIBUNWIND_SUPPORT_SEH_UNWIND 1
|
||||
#else
|
||||
#define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
|
||||
#endif
|
||||
#else
|
||||
#if defined(__ARM_DWARF_EH__) || !defined(__arm__)
|
||||
#define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
|
||||
|
||||
Loading…
Reference in New Issue
Block a user