1//===-- gcc_personality_v0.c - Implement __gcc_personality_v0 -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "int_lib.h"
10#include <stddef.h>
11
12#include <unwind.h>
13#if defined(__arm__) && !defined(__ARM_DWARF_EH__) && \
14 !defined(__USING_SJLJ_EXCEPTIONS__)
15// When building with older compilers (e.g. clang <3.9), it is possible that we
16// have a version of unwind.h which does not provide the EHABI declarations
17// which are quired for the C personality to conform to the specification. In
18// order to provide forward compatibility for such compilers, we re-declare the
19// necessary interfaces in the helper to permit a standalone compilation of the
20// builtins (which contains the C unwinding personality for historical reasons).
21#include "unwind-ehabi-helpers.h"
22#endif
23
24#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
25#include <windows.h>
26#include <winnt.h>
27
28EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD, void *, PCONTEXT,
29 PDISPATCHER_CONTEXT,
30 _Unwind_Personality_Fn);
31#endif
32
33// Pointer encodings documented at:
34// http://refspecs.freestandards.org/LSB_1.3.0/gLSB/gLSB/ehframehdr.html
35
36#define DW_EH_PE_omit 0xff // no data follows
37
38#define DW_EH_PE_absptr 0x00
39#define DW_EH_PE_uleb128 0x01
40#define DW_EH_PE_udata2 0x02
41#define DW_EH_PE_udata4 0x03
42#define DW_EH_PE_udata8 0x04
43#define DW_EH_PE_sleb128 0x09
44#define DW_EH_PE_sdata2 0x0A
45#define DW_EH_PE_sdata4 0x0B
46#define DW_EH_PE_sdata8 0x0C
47
48#define DW_EH_PE_pcrel 0x10
49#define DW_EH_PE_textrel 0x20
50#define DW_EH_PE_datarel 0x30
51#define DW_EH_PE_funcrel 0x40
52#define DW_EH_PE_aligned 0x50
53#define DW_EH_PE_indirect 0x80 // gcc extension
54
55// read a uleb128 encoded value and advance pointer
56static size_t readULEB128(const uint8_t **data) {
57 size_t result = 0;
58 size_t shift = 0;
59 unsigned char byte;
60 const uint8_t *p = *data;
61 do {
62 byte = *p++;
63 result |= (byte & 0x7f) << shift;
64 shift += 7;
65 } while (byte & 0x80);
66 *data = p;
67 return result;
68}
69
70// read a pointer encoded value and advance pointer
71static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
72 const uint8_t *p = *data;
73 uintptr_t result = 0;
74
75 if (encoding == DW_EH_PE_omit)
76 return 0;
77
78 // first get value
79 switch (encoding & 0x0F) {
80 case DW_EH_PE_absptr:
81 result = *((const uintptr_t *)p);
82 p += sizeof(uintptr_t);
83 break;
84 case DW_EH_PE_uleb128:
85 result = readULEB128(data: &p);
86 break;
87 case DW_EH_PE_udata2:
88 result = *((const uint16_t *)p);
89 p += sizeof(uint16_t);
90 break;
91 case DW_EH_PE_udata4:
92 result = *((const uint32_t *)p);
93 p += sizeof(uint32_t);
94 break;
95 case DW_EH_PE_udata8:
96 result = *((const uint64_t *)p);
97 p += sizeof(uint64_t);
98 break;
99 case DW_EH_PE_sdata2:
100 result = *((const int16_t *)p);
101 p += sizeof(int16_t);
102 break;
103 case DW_EH_PE_sdata4:
104 result = *((const int32_t *)p);
105 p += sizeof(int32_t);
106 break;
107 case DW_EH_PE_sdata8:
108 result = *((const int64_t *)p);
109 p += sizeof(int64_t);
110 break;
111 case DW_EH_PE_sleb128:
112 default:
113 // not supported
114 compilerrt_abort();
115 break;
116 }
117
118 // then add relative offset
119 switch (encoding & 0x70) {
120 case DW_EH_PE_absptr:
121 // do nothing
122 break;
123 case DW_EH_PE_pcrel:
124 result += (uintptr_t)(*data);
125 break;
126 case DW_EH_PE_textrel:
127 case DW_EH_PE_datarel:
128 case DW_EH_PE_funcrel:
129 case DW_EH_PE_aligned:
130 default:
131 // not supported
132 compilerrt_abort();
133 break;
134 }
135
136 // then apply indirection
137 if (encoding & DW_EH_PE_indirect) {
138 result = *((const uintptr_t *)result);
139 }
140
141 *data = p;
142 return result;
143}
144
145#if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) && \
146 !defined(__ARM_DWARF_EH__) && !defined(__SEH__)
147#define USING_ARM_EHABI 1
148_Unwind_Reason_Code __gnu_unwind_frame(struct _Unwind_Exception *,
149 struct _Unwind_Context *);
150#endif
151
152static inline _Unwind_Reason_Code
153continueUnwind(struct _Unwind_Exception *exceptionObject,
154 struct _Unwind_Context *context) {
155#if USING_ARM_EHABI
156 // On ARM EHABI the personality routine is responsible for actually
157 // unwinding a single stack frame before returning (ARM EHABI Sec. 6.1).
158 if (__gnu_unwind_frame(exceptionObject, context) != _URC_OK)
159 return _URC_FAILURE;
160#endif
161 return _URC_CONTINUE_UNWIND;
162}
163
164// The C compiler makes references to __gcc_personality_v0 in
165// the dwarf unwind information for translation units that use
166// __attribute__((cleanup(xx))) on local variables.
167// This personality routine is called by the system unwinder
168// on each frame as the stack is unwound during a C++ exception
169// throw through a C function compiled with -fexceptions.
170#if __USING_SJLJ_EXCEPTIONS__
171// the setjump-longjump based exceptions personality routine has a
172// different name
173COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_sj0(
174 int version, _Unwind_Action actions, uint64_t exceptionClass,
175 struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
176#elif USING_ARM_EHABI
177// The ARM EHABI personality routine has a different signature.
178COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
179 _Unwind_State state, struct _Unwind_Exception *exceptionObject,
180 struct _Unwind_Context *context)
181#elif defined(__SEH__)
182static _Unwind_Reason_Code __gcc_personality_imp(
183 int version, _Unwind_Action actions, uint64_t exceptionClass,
184 struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
185#else
186COMPILER_RT_ABI _Unwind_Reason_Code __gcc_personality_v0(
187 int version, _Unwind_Action actions, uint64_t exceptionClass,
188 struct _Unwind_Exception *exceptionObject, struct _Unwind_Context *context)
189#endif
190{
191 // Since C does not have catch clauses, there is nothing to do during
192 // phase 1 (the search phase).
193#if USING_ARM_EHABI
194 // After resuming from a cleanup we should also continue on to the next
195 // frame straight away.
196 if ((state & _US_ACTION_MASK) != _US_UNWIND_FRAME_STARTING)
197#else
198 if (actions & _UA_SEARCH_PHASE)
199#endif
200 return continueUnwind(exceptionObject, context);
201
202 // There is nothing to do if there is no LSDA for this frame.
203 const uint8_t *lsda = (uint8_t *)_Unwind_GetLanguageSpecificData(context);
204 if (lsda == (uint8_t *)0)
205 return continueUnwind(exceptionObject, context);
206
207 uintptr_t pc = (uintptr_t)_Unwind_GetIP(context) - 1;
208 uintptr_t funcStart = (uintptr_t)_Unwind_GetRegionStart(context);
209 uintptr_t pcOffset = pc - funcStart;
210
211 // Parse LSDA header.
212 uint8_t lpStartEncoding = *lsda++;
213 if (lpStartEncoding != DW_EH_PE_omit) {
214 readEncodedPointer(data: &lsda, encoding: lpStartEncoding);
215 }
216 uint8_t ttypeEncoding = *lsda++;
217 if (ttypeEncoding != DW_EH_PE_omit) {
218 readULEB128(data: &lsda);
219 }
220 // Walk call-site table looking for range that includes current PC.
221 uint8_t callSiteEncoding = *lsda++;
222 size_t callSiteTableLength = readULEB128(data: &lsda);
223 const uint8_t *callSiteTableStart = lsda;
224 const uint8_t *callSiteTableEnd = callSiteTableStart + callSiteTableLength;
225 const uint8_t *p = callSiteTableStart;
226 while (p < callSiteTableEnd) {
227 uintptr_t start = readEncodedPointer(data: &p, encoding: callSiteEncoding);
228 size_t length = readEncodedPointer(data: &p, encoding: callSiteEncoding);
229 size_t landingPad = readEncodedPointer(data: &p, encoding: callSiteEncoding);
230 readULEB128(data: &p); // action value not used for C code
231 if (landingPad == 0)
232 continue; // no landing pad for this entry
233 if ((start <= pcOffset) && (pcOffset < (start + length))) {
234 // Found landing pad for the PC.
235 // Set Instruction Pointer to so we re-enter function
236 // at landing pad. The landing pad is created by the compiler
237 // to take two parameters in registers.
238 _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
239 (uintptr_t)exceptionObject);
240 _Unwind_SetGR(context, __builtin_eh_return_data_regno(1), 0);
241 _Unwind_SetIP(context, (funcStart + landingPad));
242 return _URC_INSTALL_CONTEXT;
243 }
244 }
245
246 // No landing pad found, continue unwinding.
247 return continueUnwind(exceptionObject, context);
248}
249
250#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
251COMPILER_RT_ABI EXCEPTION_DISPOSITION
252__gcc_personality_seh0(PEXCEPTION_RECORD ms_exc, void *this_frame,
253 PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp) {
254 return _GCC_specific_handler(ms_exc, this_frame, ms_orig_context, ms_disp,
255 __gcc_personality_imp);
256}
257#endif
258

source code of compiler-rt/lib/builtins/gcc_personality_v0.c