a85da649b9
Summary: This patch contains the implementation of the unwinder for IBM AIX. AIX does not support the eh_frame section. Instead, the traceback table located at the end of each function provides the information for stack unwinding and EH. In this patch macro _LIBUNWIND_SUPPORT_TBTAB_UNWIND is used to guard code for AIX traceback table based unwinding. Function getInfoFromTBTable() and stepWithTBTable() are added to get the EH information from the traceback table and to step up the stack respectively. There are two kinds of LSDA information for EH on AIX, the state table and the range table. The state table is used by the previous version of the IBM XL compiler, i.e., xlC and xlclang++. The DWARF based range table is used by AIX clang++. The traceback table has flags to differentiate these cases. For the range table, relative addresses are calculated using a base of DW_EH_PE_datarel, which is the TOC base of the module where the function of the current frame belongs. Two personality routines are employed to handle these two different LSDAs, __xlcxx_personality_v0() for the state table and __xlcxx_personality_v1() for the range table. Since the traceback table does not have the information of the personality for the state table approach, its personality __xlcxx_personality_v0() is dynamically resolved as the handler for the state table. For the range table, the locations of the LSDA and its associated personality routine are found in the traceback table. Assembly code for 32- and 64-bit PowerPC in UnwindRegistersRestore.S and UnwindRegistersSave.S are modified so that it can be consumed by the GNU flavor assembler and the AIX assembler. The restoration of vector registers does not check VRSAVE on AIX because VRSAVE is not used in the AIX ABI. Reviewed by: MaskRay, compnerd, cebowleratibm, sfertile, libunwind Differential Revision: https://reviews.llvm.org/D100132
568 lines
23 KiB
C
568 lines
23 KiB
C
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//
|
|
// Implements C++ ABI Exception Handling Level 1 as documented at:
|
|
// https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
|
|
// using libunwind
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ARM EHABI does not specify _Unwind_{Get,Set}{GR,IP}(). Thus, we are
|
|
// defining inline functions to delegate the function calls to
|
|
// _Unwind_VRS_{Get,Set}(). However, some applications might declare the
|
|
// function protetype directly (instead of including <unwind.h>), thus we need
|
|
// to export these functions from libunwind.so as well.
|
|
#define _LIBUNWIND_UNWIND_LEVEL1_EXTERNAL_LINKAGE 1
|
|
|
|
#include <inttypes.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "cet_unwind.h"
|
|
#include "config.h"
|
|
#include "libunwind.h"
|
|
#include "libunwind_ext.h"
|
|
#include "unwind.h"
|
|
|
|
#if !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__)
|
|
|
|
#ifndef _LIBUNWIND_SUPPORT_SEH_UNWIND
|
|
|
|
// When CET is enabled, each "call" instruction will push return address to
|
|
// CET shadow stack, each "ret" instruction will pop current CET shadow stack
|
|
// top and compare it with target address which program will return.
|
|
// In exception handing, some stack frames will be skipped before jumping to
|
|
// landing pad and we must adjust CET shadow stack accordingly.
|
|
// _LIBUNWIND_POP_CET_SSP is used to adjust CET shadow stack pointer and we
|
|
// directly jump to __libunwind_Registerts_x86/x86_64_jumpto instead of using
|
|
// a regular function call to avoid pushing to CET shadow stack again.
|
|
#if !defined(_LIBUNWIND_USE_CET)
|
|
#define __unw_phase2_resume(cursor, fn) \
|
|
do { \
|
|
(void)fn; \
|
|
__unw_resume((cursor)); \
|
|
} while (0)
|
|
#elif defined(_LIBUNWIND_TARGET_I386)
|
|
#define __unw_phase2_resume(cursor, fn) \
|
|
do { \
|
|
_LIBUNWIND_POP_CET_SSP((fn)); \
|
|
void *cetRegContext = __libunwind_cet_get_registers((cursor)); \
|
|
void *cetJumpAddress = __libunwind_cet_get_jump_target(); \
|
|
__asm__ volatile("push %%edi\n\t" \
|
|
"sub $4, %%esp\n\t" \
|
|
"jmp *%%edx\n\t" :: "D"(cetRegContext), \
|
|
"d"(cetJumpAddress)); \
|
|
} while (0)
|
|
#elif defined(_LIBUNWIND_TARGET_X86_64)
|
|
#define __unw_phase2_resume(cursor, fn) \
|
|
do { \
|
|
_LIBUNWIND_POP_CET_SSP((fn)); \
|
|
void *cetRegContext = __libunwind_cet_get_registers((cursor)); \
|
|
void *cetJumpAddress = __libunwind_cet_get_jump_target(); \
|
|
__asm__ volatile("jmpq *%%rdx\n\t" :: "D"(cetRegContext), \
|
|
"d"(cetJumpAddress)); \
|
|
} while (0)
|
|
#endif
|
|
|
|
static _Unwind_Reason_Code
|
|
unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
|
|
__unw_init_local(cursor, uc);
|
|
|
|
// Walk each frame looking for a place to stop.
|
|
while (true) {
|
|
// Ask libunwind to get next frame (skip over first which is
|
|
// _Unwind_RaiseException).
|
|
int stepResult = __unw_step(cursor);
|
|
if (stepResult == 0) {
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): __unw_step() reached "
|
|
"bottom => _URC_END_OF_STACK",
|
|
(void *)exception_object);
|
|
return _URC_END_OF_STACK;
|
|
} else if (stepResult < 0) {
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): __unw_step failed => "
|
|
"_URC_FATAL_PHASE1_ERROR",
|
|
(void *)exception_object);
|
|
return _URC_FATAL_PHASE1_ERROR;
|
|
}
|
|
|
|
// See if frame has code to run (has personality routine).
|
|
unw_proc_info_t frameInfo;
|
|
unw_word_t sp;
|
|
if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): __unw_get_proc_info "
|
|
"failed => _URC_FATAL_PHASE1_ERROR",
|
|
(void *)exception_object);
|
|
return _URC_FATAL_PHASE1_ERROR;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
// 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(cursor, functionBuf, sizeof(functionBuf),
|
|
&offset) != UNW_ESUCCESS) ||
|
|
(frameInfo.start_ip + offset > frameInfo.end_ip))
|
|
functionName = ".anonymous.";
|
|
unw_word_t pc;
|
|
__unw_get_reg(cursor, UNW_REG_IP, &pc);
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR
|
|
", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "",
|
|
(void *)exception_object, pc, frameInfo.start_ip, functionName,
|
|
frameInfo.lsda, frameInfo.handler);
|
|
}
|
|
#endif
|
|
|
|
// If there is a personality routine, ask it if it will want to stop at
|
|
// this frame.
|
|
if (frameInfo.handler != 0) {
|
|
_Unwind_Personality_Fn p =
|
|
(_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler);
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): calling personality function %p",
|
|
(void *)exception_object, (void *)(uintptr_t)p);
|
|
_Unwind_Reason_Code personalityResult =
|
|
(*p)(1, _UA_SEARCH_PHASE, exception_object->exception_class,
|
|
exception_object, (struct _Unwind_Context *)(cursor));
|
|
switch (personalityResult) {
|
|
case _URC_HANDLER_FOUND:
|
|
// found a catch clause or locals that need destructing in this frame
|
|
// stop search and remember stack pointer at the frame
|
|
__unw_get_reg(cursor, UNW_REG_SP, &sp);
|
|
exception_object->private_2 = (uintptr_t)sp;
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND",
|
|
(void *)exception_object);
|
|
return _URC_NO_REASON;
|
|
|
|
case _URC_CONTINUE_UNWIND:
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND",
|
|
(void *)exception_object);
|
|
// continue unwinding
|
|
break;
|
|
|
|
default:
|
|
// something went wrong
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
|
|
(void *)exception_object);
|
|
return _URC_FATAL_PHASE1_ERROR;
|
|
}
|
|
}
|
|
}
|
|
return _URC_NO_REASON;
|
|
}
|
|
|
|
|
|
static _Unwind_Reason_Code
|
|
unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
|
|
__unw_init_local(cursor, uc);
|
|
|
|
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
|
|
(void *)exception_object);
|
|
|
|
// uc is initialized by __unw_getcontext in the parent frame. The first stack
|
|
// frame walked is unwind_phase2.
|
|
unsigned framesWalked = 1;
|
|
// Walk each frame until we reach where search phase said to stop.
|
|
while (true) {
|
|
|
|
// Ask libunwind to get next frame (skip over first which is
|
|
// _Unwind_RaiseException).
|
|
int stepResult = __unw_step(cursor);
|
|
if (stepResult == 0) {
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase2(ex_ojb=%p): __unw_step() reached "
|
|
"bottom => _URC_END_OF_STACK",
|
|
(void *)exception_object);
|
|
return _URC_END_OF_STACK;
|
|
} else if (stepResult < 0) {
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase2(ex_ojb=%p): __unw_step failed => "
|
|
"_URC_FATAL_PHASE1_ERROR",
|
|
(void *)exception_object);
|
|
return _URC_FATAL_PHASE2_ERROR;
|
|
}
|
|
|
|
// Get info about this frame.
|
|
unw_word_t sp;
|
|
unw_proc_info_t frameInfo;
|
|
__unw_get_reg(cursor, UNW_REG_SP, &sp);
|
|
if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase2(ex_ojb=%p): __unw_get_proc_info "
|
|
"failed => _URC_FATAL_PHASE1_ERROR",
|
|
(void *)exception_object);
|
|
return _URC_FATAL_PHASE2_ERROR;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
// 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(cursor, functionBuf, sizeof(functionBuf),
|
|
&offset) != UNW_ESUCCESS) ||
|
|
(frameInfo.start_ip + offset > frameInfo.end_ip))
|
|
functionName = ".anonymous.";
|
|
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): start_ip=0x%" PRIxPTR
|
|
", func=%s, sp=0x%" PRIxPTR ", lsda=0x%" PRIxPTR
|
|
", personality=0x%" PRIxPTR,
|
|
(void *)exception_object, frameInfo.start_ip,
|
|
functionName, sp, frameInfo.lsda,
|
|
frameInfo.handler);
|
|
}
|
|
#endif
|
|
|
|
++framesWalked;
|
|
// If there is a personality routine, tell it we are unwinding.
|
|
if (frameInfo.handler != 0) {
|
|
_Unwind_Personality_Fn p =
|
|
(_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler);
|
|
_Unwind_Action action = _UA_CLEANUP_PHASE;
|
|
if (sp == exception_object->private_2) {
|
|
// Tell personality this was the frame it marked in phase 1.
|
|
action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME);
|
|
}
|
|
_Unwind_Reason_Code personalityResult =
|
|
(*p)(1, action, exception_object->exception_class, exception_object,
|
|
(struct _Unwind_Context *)(cursor));
|
|
switch (personalityResult) {
|
|
case _URC_CONTINUE_UNWIND:
|
|
// Continue unwinding
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
|
|
(void *)exception_object);
|
|
if (sp == exception_object->private_2) {
|
|
// Phase 1 said we would stop at this frame, but we did not...
|
|
_LIBUNWIND_ABORT("during phase1 personality function said it would "
|
|
"stop here, but now in phase2 it did not stop here");
|
|
}
|
|
break;
|
|
case _URC_INSTALL_CONTEXT:
|
|
_LIBUNWIND_TRACE_UNWINDING(
|
|
"unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT",
|
|
(void *)exception_object);
|
|
// Personality routine says to transfer control to landing pad.
|
|
// We may get control back if landing pad calls _Unwind_Resume().
|
|
if (_LIBUNWIND_TRACING_UNWINDING) {
|
|
unw_word_t pc;
|
|
__unw_get_reg(cursor, UNW_REG_IP, &pc);
|
|
__unw_get_reg(cursor, UNW_REG_SP, &sp);
|
|
_LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering "
|
|
"user code with ip=0x%" PRIxPTR
|
|
", sp=0x%" PRIxPTR,
|
|
(void *)exception_object, pc, sp);
|
|
}
|
|
|
|
__unw_phase2_resume(cursor, framesWalked);
|
|
// __unw_phase2_resume() only returns if there was an error.
|
|
return _URC_FATAL_PHASE2_ERROR;
|
|
default:
|
|
// Personality routine returned an unknown result code.
|
|
_LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
|
|
personalityResult);
|
|
return _URC_FATAL_PHASE2_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clean up phase did not resume at the frame that the search phase
|
|
// said it would...
|
|
return _URC_FATAL_PHASE2_ERROR;
|
|
}
|
|
|
|
static _Unwind_Reason_Code
|
|
unwind_phase2_forced(unw_context_t *uc, unw_cursor_t *cursor,
|
|
_Unwind_Exception *exception_object,
|
|
_Unwind_Stop_Fn stop, void *stop_parameter) {
|
|
__unw_init_local(cursor, uc);
|
|
|
|
// uc is initialized by __unw_getcontext in the parent frame. The first stack
|
|
// frame walked is unwind_phase2_forced.
|
|
unsigned framesWalked = 1;
|
|
// Walk each frame until we reach where search phase said to stop
|
|
while (__unw_step(cursor) > 0) {
|
|
|
|
// Update info about this frame.
|
|
unw_proc_info_t frameInfo;
|
|
if (__unw_get_proc_info(cursor, &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;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
// 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(cursor, 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%" PRIxPTR
|
|
", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
|
|
(void *)exception_object, frameInfo.start_ip, functionName,
|
|
frameInfo.lsda, frameInfo.handler);
|
|
}
|
|
#endif
|
|
|
|
// 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 *)(cursor), 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;
|
|
}
|
|
|
|
++framesWalked;
|
|
// If there is a personality routine, tell it we are unwinding.
|
|
if (frameInfo.handler != 0) {
|
|
_Unwind_Personality_Fn p =
|
|
(_Unwind_Personality_Fn)(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 *)(cursor));
|
|
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_phase2_resume(cursor, framesWalked);
|
|
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 *)(cursor), 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 __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);
|
|
unw_context_t uc;
|
|
unw_cursor_t cursor;
|
|
__unw_getcontext(&uc);
|
|
|
|
// Mark that this is a non-forced unwind, so _Unwind_Resume()
|
|
// can do the right thing.
|
|
exception_object->private_1 = 0;
|
|
exception_object->private_2 = 0;
|
|
|
|
// phase 1: the search phase
|
|
_Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object);
|
|
if (phase1 != _URC_NO_REASON)
|
|
return phase1;
|
|
|
|
// phase 2: the clean up phase
|
|
return unwind_phase2(&uc, &cursor, exception_object);
|
|
}
|
|
|
|
|
|
|
|
/// When _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 _Unwind_Resume() to continue with the
|
|
/// unwinding. Note: the call to _Unwind_Resume() is from compiler
|
|
/// geneated user code. All other _Unwind_* routines are called
|
|
/// by the C++ runtime __cxa_* routines.
|
|
///
|
|
/// Note: re-throwing an exception (as opposed to continuing the unwind)
|
|
/// is implemented by having the code call __cxa_rethrow() which
|
|
/// in turn calls _Unwind_Resume_or_Rethrow().
|
|
_LIBUNWIND_EXPORT void
|
|
_Unwind_Resume(_Unwind_Exception *exception_object) {
|
|
_LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object);
|
|
unw_context_t uc;
|
|
unw_cursor_t cursor;
|
|
__unw_getcontext(&uc);
|
|
|
|
if (exception_object->private_1 != 0)
|
|
unwind_phase2_forced(&uc, &cursor, exception_object,
|
|
(_Unwind_Stop_Fn) exception_object->private_1,
|
|
(void *)exception_object->private_2);
|
|
else
|
|
unwind_phase2(&uc, &cursor, exception_object);
|
|
|
|
// 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 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_cursor_t cursor;
|
|
__unw_getcontext(&uc);
|
|
|
|
// Mark that this is a forced unwind, so _Unwind_Resume() can do
|
|
// the right thing.
|
|
exception_object->private_1 = (uintptr_t) stop;
|
|
exception_object->private_2 = (uintptr_t) stop_parameter;
|
|
|
|
// do it
|
|
return unwind_phase2_forced(&uc, &cursor, 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) {
|
|
unw_cursor_t *cursor = (unw_cursor_t *)context;
|
|
unw_proc_info_t frameInfo;
|
|
uintptr_t result = 0;
|
|
if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
|
|
result = (uintptr_t)frameInfo.lsda;
|
|
_LIBUNWIND_TRACE_API(
|
|
"_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR,
|
|
(void *)context, result);
|
|
#if !defined(_LIBUNWIND_SUPPORT_TBTAB_UNWIND)
|
|
if (result != 0) {
|
|
if (*((uint8_t *)result) != 0xFF)
|
|
_LIBUNWIND_DEBUG_LOG("lsda at 0x%" PRIxPTR " does not start with 0xFF",
|
|
result);
|
|
}
|
|
#endif
|
|
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) {
|
|
unw_cursor_t *cursor = (unw_cursor_t *)context;
|
|
unw_proc_info_t frameInfo;
|
|
uintptr_t result = 0;
|
|
if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
|
|
result = (uintptr_t)frameInfo.start_ip;
|
|
_LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR,
|
|
(void *)context, result);
|
|
return result;
|
|
}
|
|
|
|
#endif // !_LIBUNWIND_SUPPORT_SEH_UNWIND
|
|
|
|
/// Called by personality handler during phase 2 if a foreign exception
|
|
// is caught.
|
|
_LIBUNWIND_EXPORT void
|
|
_Unwind_DeleteException(_Unwind_Exception *exception_object) {
|
|
_LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
|
|
(void *)exception_object);
|
|
if (exception_object->exception_cleanup != NULL)
|
|
(*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
|
|
exception_object);
|
|
}
|
|
|
|
/// Called by personality handler during phase 2 to get register values.
|
|
_LIBUNWIND_EXPORT uintptr_t
|
|
_Unwind_GetGR(struct _Unwind_Context *context, int index) {
|
|
unw_cursor_t *cursor = (unw_cursor_t *)context;
|
|
unw_word_t result;
|
|
__unw_get_reg(cursor, index, &result);
|
|
_LIBUNWIND_TRACE_API("_Unwind_GetGR(context=%p, reg=%d) => 0x%" PRIxPTR,
|
|
(void *)context, index, result);
|
|
return (uintptr_t)result;
|
|
}
|
|
|
|
/// Called by personality handler during phase 2 to alter register values.
|
|
_LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index,
|
|
uintptr_t value) {
|
|
_LIBUNWIND_TRACE_API("_Unwind_SetGR(context=%p, reg=%d, value=0x%0" PRIxPTR
|
|
")",
|
|
(void *)context, index, value);
|
|
unw_cursor_t *cursor = (unw_cursor_t *)context;
|
|
__unw_set_reg(cursor, index, value);
|
|
}
|
|
|
|
/// Called by personality handler during phase 2 to get instruction pointer.
|
|
_LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) {
|
|
unw_cursor_t *cursor = (unw_cursor_t *)context;
|
|
unw_word_t result;
|
|
__unw_get_reg(cursor, UNW_REG_IP, &result);
|
|
_LIBUNWIND_TRACE_API("_Unwind_GetIP(context=%p) => 0x%" PRIxPTR,
|
|
(void *)context, result);
|
|
return (uintptr_t)result;
|
|
}
|
|
|
|
/// Called by personality handler during phase 2 to alter instruction pointer,
|
|
/// such as setting where the landing pad is, so _Unwind_Resume() will
|
|
/// start executing in the landing pad.
|
|
_LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context,
|
|
uintptr_t value) {
|
|
_LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%0" PRIxPTR ")",
|
|
(void *)context, value);
|
|
unw_cursor_t *cursor = (unw_cursor_t *)context;
|
|
__unw_set_reg(cursor, UNW_REG_IP, value);
|
|
}
|
|
|
|
#endif // !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__)
|