forked from OSchip/llvm-project
258 lines
8.6 KiB
C
258 lines
8.6 KiB
C
//===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "int_lib.h"
|
|
#include <stddef.h>
|
|
|
|
#include <unwind.h>
|
|
#if defined(__arm__) && !defined(__ARM_DWARF_EH__) && \
|
|
!defined(__USING_SJLJ_EXCEPTIONS__)
|
|
// When building with older compilers (e.g. clang <3.9), it is possible that we
|
|
// have a version of unwind.h which does not provide the EHABI declarations
|
|
// which are quired for the C personality to conform to the specification. In
|
|
// order to provide forward compatibility for such compilers, we re-declare the
|
|
// necessary interfaces in the helper to permit a standalone compilation of the
|
|
// builtins (which contains the C unwinding personality for historical reasons).
|
|
#include "unwind-ehabi-helpers.h"
|
|
#endif
|
|
|
|
#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
|
|
#include <windows.h>
|
|
#include <winnt.h>
|
|
|
|
EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD, void *, PCONTEXT,
|
|
PDISPATCHER_CONTEXT,
|
|
_Unwind_Personality_Fn);
|
|
#endif
|
|
|
|
// Pointer encodings documented at:
|
|
// http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
|
|
|
|
#define DW_EH_PE_omit 0xff // no data follows
|
|
|
|
#define DW_EH_PE_absptr 0x00
|
|
#define DW_EH_PE_uleb128 0x01
|
|
#define DW_EH_PE_udata2 0x02
|
|
#define DW_EH_PE_udata4 0x03
|
|
#define DW_EH_PE_udata8 0x04
|
|
#define DW_EH_PE_sleb128 0x09
|
|
#define DW_EH_PE_sdata2 0x0A
|
|
#define DW_EH_PE_sdata4 0x0B
|
|
#define DW_EH_PE_sdata8 0x0C
|
|
|
|
#define DW_EH_PE_pcrel 0x10
|
|
#define DW_EH_PE_textrel 0x20
|
|
#define DW_EH_PE_datarel 0x30
|
|
#define DW_EH_PE_funcrel 0x40
|
|
#define DW_EH_PE_aligned 0x50
|
|
#define DW_EH_PE_indirect 0x80 // gcc extension
|
|
|
|
// read a uleb128 encoded value and advance pointer
|
|
static size_t readULEB128(const uint8_t **data) {
|
|
size_t result = 0;
|
|
size_t shift = 0;
|
|
unsigned char byte;
|
|
const uint8_t *p = *data;
|
|
do {
|
|
byte = *p++;
|
|
result |= (byte & 0x7f) << shift;
|
|
shift += 7;
|
|
} while (byte & 0x80);
|
|
*data = p;
|
|
return result;
|
|
}
|
|
|
|
// read a pointer encoded value and advance pointer
|
|
static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
|
|
const uint8_t *p = *data;
|
|
uintptr_t result = 0;
|
|
|
|
if (encoding == DW_EH_PE_omit)
|
|
return 0;
|
|
|
|
// first get value
|
|
switch (encoding & 0x0F) {
|
|
case DW_EH_PE_absptr:
|
|
result = *((const uintptr_t *)p);
|
|
p += sizeof(uintptr_t);
|
|
break;
|
|
case DW_EH_PE_uleb128:
|
|
result = readULEB128(&p);
|
|
break;
|
|
case DW_EH_PE_udata2:
|
|
result = *((const uint16_t *)p);
|
|
p += sizeof(uint16_t);
|
|
break;
|
|
case DW_EH_PE_udata4:
|
|
result = *((const uint32_t *)p);
|
|
p += sizeof(uint32_t);
|
|
break;
|
|
case DW_EH_PE_udata8:
|
|
result = *((const uint64_t *)p);
|
|
p += sizeof(uint64_t);
|
|
break;
|
|
case DW_EH_PE_sdata2:
|
|
result = *((const int16_t *)p);
|
|
p += sizeof(int16_t);
|
|
break;
|
|
case DW_EH_PE_sdata4:
|
|
result = *((const int32_t *)p);
|
|
p += sizeof(int32_t);
|
|
break;
|
|
case DW_EH_PE_sdata8:
|
|
result = *((const int64_t *)p);
|
|
p += sizeof(int64_t);
|
|
break;
|
|
case DW_EH_PE_sleb128:
|
|
default:
|
|
// not supported
|
|
compilerrt_abort();
|
|
break;
|
|
}
|
|
|
|
// then add relative offset
|
|
switch (encoding & 0x70) {
|
|
case DW_EH_PE_absptr:
|
|
// do nothing
|
|
break;
|
|
case DW_EH_PE_pcrel:
|
|
result += (uintptr_t)(*data);
|
|
break;
|
|
case DW_EH_PE_textrel:
|
|
case DW_EH_PE_datarel:
|
|
case DW_EH_PE_funcrel:
|
|
case DW_EH_PE_aligned:
|
|
default:
|
|
// not supported
|
|
compilerrt_abort();
|
|
break;
|
|
}
|
|
|
|
// then apply indirection
|
|
if (encoding & DW_EH_PE_indirect) {
|
|
result = *((const uintptr_t *)result);
|
|
}
|
|
|
|
*data = p;
|
|
return result;
|
|
}
|
|
|
|
#if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) && \
|
|
!defined(__ARM_DWARF_EH__)
|
|
#define USING_ARM_EHABI 1
|
|
_Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *,
|
|
struct _Unwind_Context *);
|
|
#endif
|
|
|
|
static inline _Unwind_Reason_Code
|
|
continueUnwind(struct _Unwind_Exception *exceptionObject,
|
|
struct _Unwind_Context *context) {
|
|
#if USING_ARM_EHABI
|
|
// On ARM EHABI the personality routine is responsible for actually
|
|
// unwinding a single stack frame before returning (ARM EHABI Sec. 6.1).
|
|
if (__gnu_unwind_frame(exceptionObject, context) != _URC_OK)
|
|
return _URC_FAILURE;
|
|
#endif
|
|
return _URC_CONTINUE_UNWIND;
|
|
}
|
|
|
|
// The C compiler makes references to __gcc_personality_v0 in
|
|
// the dwarf unwind information for translation units that use
|
|
// __attribute__((cleanup(xx))) on local variables.
|
|
// This personality routine is called by the system unwinder
|
|
// on each frame as the stack is unwound during a C++ exception
|
|
// throw through a C function compiled with -fexceptions.
|
|
#if __USING_SJLJ_EXCEPTIONS__
|
|
// the setjump-longjump based exceptions personality routine has a
|
|
// different name
|
|
COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_sj0(
|
|
int version, _Unwind_Action actions, uint64_t exceptionClass,
|
|
struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
|
|
#elif USING_ARM_EHABI
|
|
// The ARM EHABI personality routine has a different signature.
|
|
COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
|
|
_Unwind_State state, struct _Unwind_Exception *exceptionObject,
|
|
struct _Unwind_Context *context)
|
|
#elif defined(__SEH__)
|
|
static _Unwind_Reason_Code __gcc_personality_imp(
|
|
int version, _Unwind_Action actions, uint64_t exceptionClass,
|
|
struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
|
|
#else
|
|
COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
|
|
int version, _Unwind_Action actions, uint64_t exceptionClass,
|
|
struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
|
|
#endif
|
|
{
|
|
// Since C does not have catch clauses, there is nothing to do during
|
|
// phase 1 (the search phase).
|
|
#if USING_ARM_EHABI
|
|
// After resuming from a cleanup we should also continue on to the next
|
|
// frame straight away.
|
|
if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
|
|
#else
|
|
if (actions & _UA_SEARCH_PHASE)
|
|
#endif
|
|
return continueUnwind(exceptionObject, context);
|
|
|
|
// There is nothing to do if there is no LSDA for this frame.
|
|
const uint8_t *lsda = (uint8_t *)_Unwind_GetLanguageSpecificData(context);
|
|
if (lsda == (uint8_t *)0)
|
|
return continueUnwind(exceptionObject, context);
|
|
|
|
uintptr_t pc = (uintptr_t)_Unwind_GetIP(context) - 1;
|
|
uintptr_t funcStart = (uintptr_t)_Unwind_GetRegionStart(context);
|
|
uintptr_t pcOffset = pc - funcStart;
|
|
|
|
// Parse LSDA header.
|
|
uint8_t lpStartEncoding = *lsda++;
|
|
if (lpStartEncoding != DW_EH_PE_omit) {
|
|
readEncodedPointer(&lsda, lpStartEncoding);
|
|
}
|
|
uint8_t ttypeEncoding = *lsda++;
|
|
if (ttypeEncoding != DW_EH_PE_omit) {
|
|
readULEB128(&lsda);
|
|
}
|
|
// Walk call-site table looking for range that includes current PC.
|
|
uint8_t callSiteEncoding = *lsda++;
|
|
uint32_t callSiteTableLength = readULEB128(&lsda);
|
|
const uint8_t *callSiteTableStart = lsda;
|
|
const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength;
|
|
const uint8_t *p = callSiteTableStart;
|
|
while (p < callSiteTableEnd) {
|
|
uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
|
|
size_t length = readEncodedPointer(&p, callSiteEncoding);
|
|
size_t landingPad = readEncodedPointer(&p, callSiteEncoding);
|
|
readULEB128(&p); // action value not used for C code
|
|
if (landingPad == 0)
|
|
continue; // no landing pad for this entry
|
|
if ((start <= pcOffset) && (pcOffset < (start + length))) {
|
|
// Found landing pad for the PC.
|
|
// Set Instruction Pointer to so we re-enter function
|
|
// at landing pad. The landing pad is created by the compiler
|
|
// to take two parameters in registers.
|
|
_Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
|
|
(uintptr_t)exceptionObject);
|
|
_Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
|
|
_Unwind_SetIP(context, (funcStart + landingPad));
|
|
return _URC_INSTALL_CONTEXT;
|
|
}
|
|
}
|
|
|
|
// No landing pad found, continue unwinding.
|
|
return continueUnwind(exceptionObject, context);
|
|
}
|
|
|
|
#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
|
|
COMPILER_RT_ABI EXCEPTION_DISPOSITION
|
|
__gcc_personality_seh0(PEXCEPTION_RECORD ms_exc, void *this_frame,
|
|
PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp) {
|
|
return _GCC_specific_handler(ms_exc, this_frame, ms_orig_context, ms_disp,
|
|
__gcc_personality_imp);
|
|
}
|
|
#endif
|