1//===----------------------------------------------------------------------===//
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// Implements setjump-longjump based C++ exceptions
9//
10//===----------------------------------------------------------------------===//
11
12#include <unwind.h>
13
14#include <inttypes.h>
15#include <stdint.h>
16#include <stdbool.h>
17#include <stdlib.h>
18
19#include "config.h"
20
21/// With SJLJ based exceptions, any function that has a catch clause or needs to
22/// do any clean up when an exception propagates through it, needs to call
23/// \c _Unwind_SjLj_Register at the start of the function and
24/// \c _Unwind_SjLj_Unregister at the end. The register function is called with
25/// the address of a block of memory in the function's stack frame. The runtime
26/// keeps a linked list (stack) of these blocks - one per thread. The calling
27/// function also sets the personality and lsda fields of the block.
28
29#if defined(_LIBUNWIND_BUILD_SJLJ_APIS)
30
31struct _Unwind_FunctionContext {
32 // next function in stack of handlers
33 struct _Unwind_FunctionContext *prev;
34
35#if defined(__ve__)
36 // VE requires to store 64 bit pointers in the buffer for SjLj exception.
37 // We expand the size of values defined here. This size must be matched
38 // to the size returned by TargetMachine::getSjLjDataSize().
39
40 // set by calling function before registering to be the landing pad
41 uint64_t resumeLocation;
42
43 // set by personality handler to be parameters passed to landing pad function
44 uint64_t resumeParameters[4];
45#else
46 // set by calling function before registering to be the landing pad
47 uint32_t resumeLocation;
48
49 // set by personality handler to be parameters passed to landing pad function
50 uint32_t resumeParameters[4];
51#endif
52
53 // set by calling function before registering
54 _Unwind_Personality_Fn personality; // arm offset=24
55 uintptr_t lsda; // arm offset=28
56
57 // variable length array, contains registers to restore
58 // 0 = r7, 1 = pc, 2 = sp
59 void *jbuf[];
60};
61
62#if defined(_LIBUNWIND_HAS_NO_THREADS)
63# define _LIBUNWIND_THREAD_LOCAL
64#else
65# if __STDC_VERSION__ >= 201112L
66# define _LIBUNWIND_THREAD_LOCAL _Thread_local
67# elif defined(_MSC_VER)
68# define _LIBUNWIND_THREAD_LOCAL __declspec(thread)
69# elif defined(__GNUC__) || defined(__clang__)
70# define _LIBUNWIND_THREAD_LOCAL __thread
71# else
72# error Unable to create thread local storage
73# endif
74#endif
75
76
77#if !defined(FOR_DYLD)
78
79#if defined(__APPLE__)
80#include <System/pthread_machdep.h>
81#else
82static _LIBUNWIND_THREAD_LOCAL struct _Unwind_FunctionContext *stack = NULL;
83#endif
84
85static struct _Unwind_FunctionContext *
86__Unwind_SjLj_GetTopOfFunctionStack(void) {
87#if defined(__APPLE__)
88 return _pthread_getspecific_direct(__PTK_LIBC_DYLD_Unwind_SjLj_Key);
89#else
90 return stack;
91#endif
92}
93
94static void
95__Unwind_SjLj_SetTopOfFunctionStack(struct _Unwind_FunctionContext *fc) {
96#if defined(__APPLE__)
97 _pthread_setspecific_direct(__PTK_LIBC_DYLD_Unwind_SjLj_Key, fc);
98#else
99 stack = fc;
100#endif
101}
102
103#endif
104
105
106/// Called at start of each function that catches exceptions
107_LIBUNWIND_EXPORT void
108_Unwind_SjLj_Register(struct _Unwind_FunctionContext *fc) {
109 fc->prev = __Unwind_SjLj_GetTopOfFunctionStack();
110 __Unwind_SjLj_SetTopOfFunctionStack(fc);
111}
112
113
114/// Called at end of each function that catches exceptions
115_LIBUNWIND_EXPORT void
116_Unwind_SjLj_Unregister(struct _Unwind_FunctionContext *fc) {
117 __Unwind_SjLj_SetTopOfFunctionStack(fc->prev);
118}
119
120
121static _Unwind_Reason_Code
122unwind_phase1(struct _Unwind_Exception *exception_object) {
123 _Unwind_FunctionContext_t c = __Unwind_SjLj_GetTopOfFunctionStack();
124 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1: initial function-context=%p",
125 (void *)c);
126
127 // walk each frame looking for a place to stop
128 for (bool handlerNotFound = true; handlerNotFound; c = c->prev) {
129
130 // check for no more frames
131 if (c == NULL) {
132 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): reached "
133 "bottom => _URC_END_OF_STACK",
134 (void *)exception_object);
135 return _URC_END_OF_STACK;
136 }
137
138 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1: function-context=%p", (void *)c);
139 // if there is a personality routine, ask it if it will want to stop at this
140 // frame
141 if (c->personality != NULL) {
142 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): calling "
143 "personality function %p",
144 (void *)exception_object,
145 (void *)c->personality);
146 _Unwind_Reason_Code personalityResult = (*c->personality)(
147 1, _UA_SEARCH_PHASE, exception_object->exception_class,
148 exception_object, (struct _Unwind_Context *)c);
149 switch (personalityResult) {
150 case _URC_HANDLER_FOUND:
151 // found a catch clause or locals that need destructing in this frame
152 // stop search and remember function context
153 handlerNotFound = false;
154 exception_object->private_2 = (uintptr_t) c;
155 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): "
156 "_URC_HANDLER_FOUND",
157 (void *)exception_object);
158 return _URC_NO_REASON;
159
160 case _URC_CONTINUE_UNWIND:
161 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): "
162 "_URC_CONTINUE_UNWIND",
163 (void *)exception_object);
164 // continue unwinding
165 break;
166
167 default:
168 // something went wrong
169 _LIBUNWIND_TRACE_UNWINDING(
170 "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
171 (void *)exception_object);
172 return _URC_FATAL_PHASE1_ERROR;
173 }
174 }
175 }
176 return _URC_NO_REASON;
177}
178
179
180static _Unwind_Reason_Code
181unwind_phase2(struct _Unwind_Exception *exception_object) {
182 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
183 (void *)exception_object);
184
185 // walk each frame until we reach where search phase said to stop
186 _Unwind_FunctionContext_t c = __Unwind_SjLj_GetTopOfFunctionStack();
187 while (true) {
188 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2s(ex_ojb=%p): context=%p",
189 (void *)exception_object, (void *)c);
190
191 // check for no more frames
192 if (c == NULL) {
193 _LIBUNWIND_TRACE_UNWINDING(
194 "unwind_phase2(ex_ojb=%p): __unw_step() reached "
195 "bottom => _URC_END_OF_STACK",
196 (void *)exception_object);
197 return _URC_END_OF_STACK;
198 }
199
200 // if there is a personality routine, tell it we are unwinding
201 if (c->personality != NULL) {
202 _Unwind_Action action = _UA_CLEANUP_PHASE;
203 if ((uintptr_t) c == exception_object->private_2)
204 action = (_Unwind_Action)(
205 _UA_CLEANUP_PHASE |
206 _UA_HANDLER_FRAME); // tell personality this was the frame it marked
207 // in phase 1
208 _Unwind_Reason_Code personalityResult =
209 (*c->personality)(1, action, exception_object->exception_class,
210 exception_object, (struct _Unwind_Context *)c);
211 switch (personalityResult) {
212 case _URC_CONTINUE_UNWIND:
213 // continue unwinding
214 _LIBUNWIND_TRACE_UNWINDING(
215 "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
216 (void *)exception_object);
217 if ((uintptr_t) c == exception_object->private_2) {
218 // phase 1 said we would stop at this frame, but we did not...
219 _LIBUNWIND_ABORT("during phase1 personality function said it would "
220 "stop here, but now if phase2 it did not stop here");
221 }
222 break;
223 case _URC_INSTALL_CONTEXT:
224 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): "
225 "_URC_INSTALL_CONTEXT, will resume at "
226 "landing pad %p",
227 (void *)exception_object, c->jbuf[1]);
228 // personality routine says to transfer control to landing pad
229 // we may get control back if landing pad calls _Unwind_Resume()
230 __Unwind_SjLj_SetTopOfFunctionStack(c);
231 __builtin_longjmp(c->jbuf, 1);
232 // __unw_resume() only returns if there was an error
233 return _URC_FATAL_PHASE2_ERROR;
234 default:
235 // something went wrong
236 _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
237 personalityResult);
238 return _URC_FATAL_PHASE2_ERROR;
239 }
240 }
241 c = c->prev;
242 }
243
244 // clean up phase did not resume at the frame that the search phase said it
245 // would
246 return _URC_FATAL_PHASE2_ERROR;
247}
248
249
250static _Unwind_Reason_Code
251unwind_phase2_forced(struct _Unwind_Exception *exception_object,
252 _Unwind_Stop_Fn stop, void *stop_parameter) {
253 // walk each frame until we reach where search phase said to stop
254 _Unwind_FunctionContext_t c = __Unwind_SjLj_GetTopOfFunctionStack();
255 while (true) {
256
257 // get next frame (skip over first which is _Unwind_RaiseException)
258 if (c == NULL) {
259 _LIBUNWIND_TRACE_UNWINDING(
260 "unwind_phase2(ex_ojb=%p): __unw_step() reached "
261 "bottom => _URC_END_OF_STACK",
262 (void *)exception_object);
263 return _URC_END_OF_STACK;
264 }
265
266 // call stop function at each frame
267 _Unwind_Action action =
268 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
269 _Unwind_Reason_Code stopResult =
270 (*stop)(1, action, exception_object->exception_class, exception_object,
271 (struct _Unwind_Context *)c, stop_parameter);
272 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
273 "stop function returned %d",
274 (void *)exception_object, stopResult);
275 if (stopResult != _URC_NO_REASON) {
276 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
277 "stopped by stop function",
278 (void *)exception_object);
279 return _URC_FATAL_PHASE2_ERROR;
280 }
281
282 // if there is a personality routine, tell it we are unwinding
283 if (c->personality != NULL) {
284 _Unwind_Personality_Fn p = (_Unwind_Personality_Fn)c->personality;
285 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
286 "calling personality function %p",
287 (void *)exception_object, (void *)p);
288 _Unwind_Reason_Code personalityResult =
289 (*p)(1, action, exception_object->exception_class, exception_object,
290 (struct _Unwind_Context *)c);
291 switch (personalityResult) {
292 case _URC_CONTINUE_UNWIND:
293 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
294 "personality returned _URC_CONTINUE_UNWIND",
295 (void *)exception_object);
296 // destructors called, continue unwinding
297 break;
298 case _URC_INSTALL_CONTEXT:
299 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
300 "personality returned _URC_INSTALL_CONTEXT",
301 (void *)exception_object);
302 // we may get control back if landing pad calls _Unwind_Resume()
303 __Unwind_SjLj_SetTopOfFunctionStack(c);
304 __builtin_longjmp(c->jbuf, 1);
305 break;
306 default:
307 // something went wrong
308 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
309 "personality returned %d, "
310 "_URC_FATAL_PHASE2_ERROR",
311 (void *)exception_object, personalityResult);
312 return _URC_FATAL_PHASE2_ERROR;
313 }
314 }
315 c = c->prev;
316 }
317
318 // call stop function one last time and tell it we've reached the end of the
319 // stack
320 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
321 "function with _UA_END_OF_STACK",
322 (void *)exception_object);
323 _Unwind_Action lastAction =
324 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
325 (*stop)(1, lastAction, exception_object->exception_class, exception_object,
326 (struct _Unwind_Context *)c, stop_parameter);
327
328 // clean up phase did not resume at the frame that the search phase said it
329 // would
330 return _URC_FATAL_PHASE2_ERROR;
331}
332
333
334/// Called by __cxa_throw. Only returns if there is a fatal error
335_LIBUNWIND_EXPORT _Unwind_Reason_Code
336_Unwind_SjLj_RaiseException(struct _Unwind_Exception *exception_object) {
337 _LIBUNWIND_TRACE_API("_Unwind_SjLj_RaiseException(ex_obj=%p)",
338 (void *)exception_object);
339
340 // mark that this is a non-forced unwind, so _Unwind_Resume() can do the right
341 // thing
342 exception_object->private_1 = 0;
343 exception_object->private_2 = 0;
344
345 // phase 1: the search phase
346 _Unwind_Reason_Code phase1 = unwind_phase1(exception_object);
347 if (phase1 != _URC_NO_REASON)
348 return phase1;
349
350 // phase 2: the clean up phase
351 return unwind_phase2(exception_object);
352}
353
354
355
356/// When _Unwind_RaiseException() is in phase2, it hands control
357/// to the personality function at each frame. The personality
358/// may force a jump to a landing pad in that function, the landing
359/// pad code may then call _Unwind_Resume() to continue with the
360/// unwinding. Note: the call to _Unwind_Resume() is from compiler
361/// generated user code. All other _Unwind_* routines are called
362/// by the C++ runtime __cxa_* routines.
363///
364/// Re-throwing an exception is implemented by having the code call
365/// __cxa_rethrow() which in turn calls _Unwind_Resume_or_Rethrow()
366_LIBUNWIND_EXPORT void
367_Unwind_SjLj_Resume(struct _Unwind_Exception *exception_object) {
368 _LIBUNWIND_TRACE_API("_Unwind_SjLj_Resume(ex_obj=%p)",
369 (void *)exception_object);
370
371 if (exception_object->private_1 != 0)
372 unwind_phase2_forced(exception_object,
373 (_Unwind_Stop_Fn) exception_object->private_1,
374 (void *)exception_object->private_2);
375 else
376 unwind_phase2(exception_object);
377
378 // clients assume _Unwind_Resume() does not return, so all we can do is abort.
379 _LIBUNWIND_ABORT("_Unwind_SjLj_Resume() can't return");
380}
381
382
383/// Called by __cxa_rethrow().
384_LIBUNWIND_EXPORT _Unwind_Reason_Code
385_Unwind_SjLj_Resume_or_Rethrow(struct _Unwind_Exception *exception_object) {
386 _LIBUNWIND_TRACE_API("__Unwind_SjLj_Resume_or_Rethrow(ex_obj=%p), "
387 "private_1=%" PRIuPTR,
388 (void *)exception_object, exception_object->private_1);
389 // If this is non-forced and a stopping place was found, then this is a
390 // re-throw.
391 // Call _Unwind_RaiseException() as if this was a new exception.
392 if (exception_object->private_1 == 0) {
393 return _Unwind_SjLj_RaiseException(exception_object);
394 // should return if there is no catch clause, so that __cxa_rethrow can call
395 // std::terminate()
396 }
397
398 // Call through to _Unwind_Resume() which distinguishes between forced and
399 // regular exceptions.
400 _Unwind_SjLj_Resume(exception_object);
401 _LIBUNWIND_ABORT("__Unwind_SjLj_Resume_or_Rethrow() called "
402 "_Unwind_SjLj_Resume() which unexpectedly returned");
403}
404
405
406/// Called by personality handler during phase 2 to get LSDA for current frame.
407_LIBUNWIND_EXPORT uintptr_t
408_Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
409 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
410 _LIBUNWIND_TRACE_API("_Unwind_GetLanguageSpecificData(context=%p) "
411 "=> 0x%" PRIxPTR,
412 (void *)context, ufc->lsda);
413 return ufc->lsda;
414}
415
416
417/// Called by personality handler during phase 2 to get register values.
418_LIBUNWIND_EXPORT uintptr_t _Unwind_GetGR(struct _Unwind_Context *context,
419 int index) {
420 _LIBUNWIND_TRACE_API("_Unwind_GetGR(context=%p, reg=%d)", (void *)context,
421 index);
422 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
423 return ufc->resumeParameters[index];
424}
425
426
427/// Called by personality handler during phase 2 to alter register values.
428_LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index,
429 uintptr_t new_value) {
430 _LIBUNWIND_TRACE_API("_Unwind_SetGR(context=%p, reg=%d, value=0x%" PRIxPTR
431 ")",
432 (void *)context, index, new_value);
433 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
434 ufc->resumeParameters[index] = new_value;
435}
436
437
438/// Called by personality handler during phase 2 to get instruction pointer.
439_LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) {
440 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
441 _LIBUNWIND_TRACE_API("_Unwind_GetIP(context=%p) => 0x%" PRIxPTR,
442 (void *)context, ufc->resumeLocation + 1);
443 return ufc->resumeLocation + 1;
444}
445
446
447/// Called by personality handler during phase 2 to get instruction pointer.
448/// ipBefore is a boolean that says if IP is already adjusted to be the call
449/// site address. Normally IP is the return address.
450_LIBUNWIND_EXPORT uintptr_t _Unwind_GetIPInfo(struct _Unwind_Context *context,
451 int *ipBefore) {
452 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
453 *ipBefore = 0;
454 _LIBUNWIND_TRACE_API("_Unwind_GetIPInfo(context=%p, %p) => 0x%" PRIxPTR,
455 (void *)context, (void *)ipBefore,
456 ufc->resumeLocation + 1);
457 return ufc->resumeLocation + 1;
458}
459
460
461/// Called by personality handler during phase 2 to alter instruction pointer.
462_LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context,
463 uintptr_t new_value) {
464 _LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%" PRIxPTR ")",
465 (void *)context, new_value);
466 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
467 ufc->resumeLocation = new_value - 1;
468}
469
470
471/// Called by personality handler during phase 2 to find the start of the
472/// function.
473_LIBUNWIND_EXPORT uintptr_t
474_Unwind_GetRegionStart(struct _Unwind_Context *context) {
475 // Not supported or needed for sjlj based unwinding
476 (void)context;
477 _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p)", (void *)context);
478 return 0;
479}
480
481
482/// Called by personality handler during phase 2 if a foreign exception
483/// is caught.
484_LIBUNWIND_EXPORT void
485_Unwind_DeleteException(struct _Unwind_Exception *exception_object) {
486 _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
487 (void *)exception_object);
488 if (exception_object->exception_cleanup != NULL)
489 (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
490 exception_object);
491}
492
493
494
495/// Called by personality handler during phase 2 to get base address for data
496/// relative encodings.
497_LIBUNWIND_EXPORT uintptr_t
498_Unwind_GetDataRelBase(struct _Unwind_Context *context) {
499 // Not supported or needed for sjlj based unwinding
500 (void)context;
501 _LIBUNWIND_TRACE_API("_Unwind_GetDataRelBase(context=%p)", (void *)context);
502 _LIBUNWIND_ABORT("_Unwind_GetDataRelBase() not implemented");
503}
504
505
506/// Called by personality handler during phase 2 to get base address for text
507/// relative encodings.
508_LIBUNWIND_EXPORT uintptr_t
509_Unwind_GetTextRelBase(struct _Unwind_Context *context) {
510 // Not supported or needed for sjlj based unwinding
511 (void)context;
512 _LIBUNWIND_TRACE_API("_Unwind_GetTextRelBase(context=%p)", (void *)context);
513 _LIBUNWIND_ABORT("_Unwind_GetTextRelBase() not implemented");
514}
515
516
517/// Called by personality handler to get "Call Frame Area" for current frame.
518_LIBUNWIND_EXPORT uintptr_t _Unwind_GetCFA(struct _Unwind_Context *context) {
519 _LIBUNWIND_TRACE_API("_Unwind_GetCFA(context=%p)", (void *)context);
520 if (context != NULL) {
521 _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
522 // Setjmp/longjmp based exceptions don't have a true CFA.
523 // Instead, the SP in the jmpbuf is the closest approximation.
524 return (uintptr_t) ufc->jbuf[2];
525 }
526 return 0;
527}
528
529#endif // defined(_LIBUNWIND_BUILD_SJLJ_APIS)
530