1 //===--------------------------- Unwind-EHABI.cpp -------------------------===//
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 ARM zero-cost C++ exceptions
9 //
10 //===----------------------------------------------------------------------===//
11
12 #include "Unwind-EHABI.h"
13
14 #if defined(_LIBUNWIND_ARM_EHABI)
15
16 #include <inttypes.h>
17 #include <stdbool.h>
18 #include <stdint.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include "config.h"
24 #include "libunwind.h"
25 #include "libunwind_ext.h"
26 #include "unwind.h"
27
28 namespace {
29
30 // Strange order: take words in order, but inside word, take from most to least
31 // signinficant byte.
getByte(const uint32_t * data,size_t offset)32 uint8_t getByte(const uint32_t* data, size_t offset) {
33 const uint8_t* byteData = reinterpret_cast<const uint8_t*>(data);
34 return byteData[(offset & ~(size_t)0x03) + (3 - (offset & (size_t)0x03))];
35 }
36
getNextWord(const char * data,uint32_t * out)37 const char* getNextWord(const char* data, uint32_t* out) {
38 *out = *reinterpret_cast<const uint32_t*>(data);
39 return data + 4;
40 }
41
getNextNibble(const char * data,uint32_t * out)42 const char* getNextNibble(const char* data, uint32_t* out) {
43 *out = *reinterpret_cast<const uint16_t*>(data);
44 return data + 2;
45 }
46
47 struct Descriptor {
48 // See # 9.2
49 typedef enum {
50 SU16 = 0, // Short descriptor, 16-bit entries
51 LU16 = 1, // Long descriptor, 16-bit entries
52 LU32 = 3, // Long descriptor, 32-bit entries
53 RESERVED0 = 4, RESERVED1 = 5, RESERVED2 = 6, RESERVED3 = 7,
54 RESERVED4 = 8, RESERVED5 = 9, RESERVED6 = 10, RESERVED7 = 11,
55 RESERVED8 = 12, RESERVED9 = 13, RESERVED10 = 14, RESERVED11 = 15
56 } Format;
57
58 // See # 9.2
59 typedef enum {
60 CLEANUP = 0x0,
61 FUNC = 0x1,
62 CATCH = 0x2,
63 INVALID = 0x4
64 } Kind;
65 };
66
ProcessDescriptors(_Unwind_State state,_Unwind_Control_Block * ucbp,struct _Unwind_Context * context,Descriptor::Format format,const char * descriptorStart,uint32_t flags)67 _Unwind_Reason_Code ProcessDescriptors(
68 _Unwind_State state,
69 _Unwind_Control_Block* ucbp,
70 struct _Unwind_Context* context,
71 Descriptor::Format format,
72 const char* descriptorStart,
73 uint32_t flags) {
74
75 // EHT is inlined in the index using compact form. No descriptors. #5
76 if (flags & 0x1)
77 return _URC_CONTINUE_UNWIND;
78
79 // TODO: We should check the state here, and determine whether we need to
80 // perform phase1 or phase2 unwinding.
81 (void)state;
82
83 const char* descriptor = descriptorStart;
84 uint32_t descriptorWord;
85 getNextWord(descriptor, &descriptorWord);
86 while (descriptorWord) {
87 // Read descriptor based on # 9.2.
88 uint32_t length;
89 uint32_t offset;
90 switch (format) {
91 case Descriptor::LU32:
92 descriptor = getNextWord(descriptor, &length);
93 descriptor = getNextWord(descriptor, &offset);
94 case Descriptor::LU16:
95 descriptor = getNextNibble(descriptor, &length);
96 descriptor = getNextNibble(descriptor, &offset);
97 default:
98 assert(false);
99 return _URC_FAILURE;
100 }
101
102 // See # 9.2 table for decoding the kind of descriptor. It's a 2-bit value.
103 Descriptor::Kind kind =
104 static_cast<Descriptor::Kind>((length & 0x1) | ((offset & 0x1) << 1));
105
106 // Clear off flag from last bit.
107 length &= ~1u;
108 offset &= ~1u;
109 uintptr_t scopeStart = ucbp->pr_cache.fnstart + offset;
110 uintptr_t scopeEnd = scopeStart + length;
111 uintptr_t pc = _Unwind_GetIP(context);
112 bool isInScope = (scopeStart <= pc) && (pc < scopeEnd);
113
114 switch (kind) {
115 case Descriptor::CLEANUP: {
116 // TODO(ajwong): Handle cleanup descriptors.
117 break;
118 }
119 case Descriptor::FUNC: {
120 // TODO(ajwong): Handle function descriptors.
121 break;
122 }
123 case Descriptor::CATCH: {
124 // Catch descriptors require gobbling one more word.
125 uint32_t landing_pad;
126 descriptor = getNextWord(descriptor, &landing_pad);
127
128 if (isInScope) {
129 // TODO(ajwong): This is only phase1 compatible logic. Implement
130 // phase2.
131 landing_pad = signExtendPrel31(landing_pad & ~0x80000000);
132 if (landing_pad == 0xffffffff) {
133 return _URC_HANDLER_FOUND;
134 } else if (landing_pad == 0xfffffffe) {
135 return _URC_FAILURE;
136 } else {
137 /*
138 bool is_reference_type = landing_pad & 0x80000000;
139 void* matched_object;
140 if (__cxxabiv1::__cxa_type_match(
141 ucbp, reinterpret_cast<const std::type_info *>(landing_pad),
142 is_reference_type,
143 &matched_object) != __cxxabiv1::ctm_failed)
144 return _URC_HANDLER_FOUND;
145 */
146 _LIBUNWIND_ABORT("Type matching not implemented");
147 }
148 }
149 break;
150 }
151 default:
152 _LIBUNWIND_ABORT("Invalid descriptor kind found.");
153 }
154
155 getNextWord(descriptor, &descriptorWord);
156 }
157
158 return _URC_CONTINUE_UNWIND;
159 }
160
unwindOneFrame(_Unwind_State state,_Unwind_Control_Block * ucbp,struct _Unwind_Context * context)161 static _Unwind_Reason_Code unwindOneFrame(_Unwind_State state,
162 _Unwind_Control_Block* ucbp,
163 struct _Unwind_Context* context) {
164 // Read the compact model EHT entry's header # 6.3
165 const uint32_t* unwindingData = ucbp->pr_cache.ehtp;
166 assert((*unwindingData & 0xf0000000) == 0x80000000 && "Must be a compact entry");
167 Descriptor::Format format =
168 static_cast<Descriptor::Format>((*unwindingData & 0x0f000000) >> 24);
169
170 const char *lsda =
171 reinterpret_cast<const char *>(_Unwind_GetLanguageSpecificData(context));
172
173 // Handle descriptors before unwinding so they are processed in the context
174 // of the correct stack frame.
175 _Unwind_Reason_Code result =
176 ProcessDescriptors(state, ucbp, context, format, lsda,
177 ucbp->pr_cache.additional);
178
179 if (result != _URC_CONTINUE_UNWIND)
180 return result;
181
182 if (unw_step(reinterpret_cast<unw_cursor_t*>(context)) != UNW_STEP_SUCCESS)
183 return _URC_FAILURE;
184 return _URC_CONTINUE_UNWIND;
185 }
186
187 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_CORE /
188 // _UVRSD_UINT32.
RegisterMask(uint8_t start,uint8_t count_minus_one)189 uint32_t RegisterMask(uint8_t start, uint8_t count_minus_one) {
190 return ((1U << (count_minus_one + 1)) - 1) << start;
191 }
192
193 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_VFP /
194 // _UVRSD_DOUBLE.
RegisterRange(uint8_t start,uint8_t count_minus_one)195 uint32_t RegisterRange(uint8_t start, uint8_t count_minus_one) {
196 return ((uint32_t)start << 16) | ((uint32_t)count_minus_one + 1);
197 }
198
199 } // end anonymous namespace
200
201 /**
202 * Decodes an EHT entry.
203 *
204 * @param data Pointer to EHT.
205 * @param[out] off Offset from return value (in bytes) to begin interpretation.
206 * @param[out] len Number of bytes in unwind code.
207 * @return Pointer to beginning of unwind code.
208 */
209 extern "C" const uint32_t*
decode_eht_entry(const uint32_t * data,size_t * off,size_t * len)210 decode_eht_entry(const uint32_t* data, size_t* off, size_t* len) {
211 if ((*data & 0x80000000) == 0) {
212 // 6.2: Generic Model
213 //
214 // EHT entry is a prel31 pointing to the PR, followed by data understood
215 // only by the personality routine. Fortunately, all existing assembler
216 // implementations, including GNU assembler, LLVM integrated assembler,
217 // and ARM assembler, assume that the unwind opcodes come after the
218 // personality rountine address.
219 *off = 1; // First byte is size data.
220 *len = (((data[1] >> 24) & 0xff) + 1) * 4;
221 data++; // Skip the first word, which is the prel31 offset.
222 } else {
223 // 6.3: ARM Compact Model
224 //
225 // EHT entries here correspond to the __aeabi_unwind_cpp_pr[012] PRs indeded
226 // by format:
227 Descriptor::Format format =
228 static_cast<Descriptor::Format>((*data & 0x0f000000) >> 24);
229 switch (format) {
230 case Descriptor::SU16:
231 *len = 4;
232 *off = 1;
233 break;
234 case Descriptor::LU16:
235 case Descriptor::LU32:
236 *len = 4 + 4 * ((*data & 0x00ff0000) >> 16);
237 *off = 2;
238 break;
239 default:
240 return nullptr;
241 }
242 }
243 return data;
244 }
245
246 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_VRS_Interpret(_Unwind_Context * context,const uint32_t * data,size_t offset,size_t len)247 _Unwind_VRS_Interpret(_Unwind_Context *context, const uint32_t *data,
248 size_t offset, size_t len) {
249 bool wrotePC = false;
250 bool finish = false;
251 while (offset < len && !finish) {
252 uint8_t byte = getByte(data, offset++);
253 if ((byte & 0x80) == 0) {
254 uint32_t sp;
255 _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
256 if (byte & 0x40)
257 sp -= (((uint32_t)byte & 0x3f) << 2) + 4;
258 else
259 sp += ((uint32_t)byte << 2) + 4;
260 _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
261 } else {
262 switch (byte & 0xf0) {
263 case 0x80: {
264 if (offset >= len)
265 return _URC_FAILURE;
266 uint32_t registers =
267 (((uint32_t)byte & 0x0f) << 12) |
268 (((uint32_t)getByte(data, offset++)) << 4);
269 if (!registers)
270 return _URC_FAILURE;
271 if (registers & (1 << 15))
272 wrotePC = true;
273 _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
274 break;
275 }
276 case 0x90: {
277 uint8_t reg = byte & 0x0f;
278 if (reg == 13 || reg == 15)
279 return _URC_FAILURE;
280 uint32_t sp;
281 _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_R0 + reg,
282 _UVRSD_UINT32, &sp);
283 _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
284 &sp);
285 break;
286 }
287 case 0xa0: {
288 uint32_t registers = RegisterMask(4, byte & 0x07);
289 if (byte & 0x08)
290 registers |= 1 << 14;
291 _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
292 break;
293 }
294 case 0xb0: {
295 switch (byte) {
296 case 0xb0:
297 finish = true;
298 break;
299 case 0xb1: {
300 if (offset >= len)
301 return _URC_FAILURE;
302 uint8_t registers = getByte(data, offset++);
303 if (registers & 0xf0 || !registers)
304 return _URC_FAILURE;
305 _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
306 break;
307 }
308 case 0xb2: {
309 uint32_t addend = 0;
310 uint32_t shift = 0;
311 // This decodes a uleb128 value.
312 while (true) {
313 if (offset >= len)
314 return _URC_FAILURE;
315 uint32_t v = getByte(data, offset++);
316 addend |= (v & 0x7f) << shift;
317 if ((v & 0x80) == 0)
318 break;
319 shift += 7;
320 }
321 uint32_t sp;
322 _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
323 &sp);
324 sp += 0x204 + (addend << 2);
325 _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
326 &sp);
327 break;
328 }
329 case 0xb3: {
330 uint8_t v = getByte(data, offset++);
331 _Unwind_VRS_Pop(context, _UVRSC_VFP,
332 RegisterRange(static_cast<uint8_t>(v >> 4),
333 v & 0x0f), _UVRSD_VFPX);
334 break;
335 }
336 case 0xb4:
337 case 0xb5:
338 case 0xb6:
339 case 0xb7:
340 return _URC_FAILURE;
341 default:
342 _Unwind_VRS_Pop(context, _UVRSC_VFP,
343 RegisterRange(8, byte & 0x07), _UVRSD_VFPX);
344 break;
345 }
346 break;
347 }
348 case 0xc0: {
349 switch (byte) {
350 #if defined(__ARM_WMMX)
351 case 0xc0:
352 case 0xc1:
353 case 0xc2:
354 case 0xc3:
355 case 0xc4:
356 case 0xc5:
357 _Unwind_VRS_Pop(context, _UVRSC_WMMXD,
358 RegisterRange(10, byte & 0x7), _UVRSD_DOUBLE);
359 break;
360 case 0xc6: {
361 uint8_t v = getByte(data, offset++);
362 uint8_t start = static_cast<uint8_t>(v >> 4);
363 uint8_t count_minus_one = v & 0xf;
364 if (start + count_minus_one >= 16)
365 return _URC_FAILURE;
366 _Unwind_VRS_Pop(context, _UVRSC_WMMXD,
367 RegisterRange(start, count_minus_one),
368 _UVRSD_DOUBLE);
369 break;
370 }
371 case 0xc7: {
372 uint8_t v = getByte(data, offset++);
373 if (!v || v & 0xf0)
374 return _URC_FAILURE;
375 _Unwind_VRS_Pop(context, _UVRSC_WMMXC, v, _UVRSD_DOUBLE);
376 break;
377 }
378 #endif
379 case 0xc8:
380 case 0xc9: {
381 uint8_t v = getByte(data, offset++);
382 uint8_t start =
383 static_cast<uint8_t>(((byte == 0xc8) ? 16 : 0) + (v >> 4));
384 uint8_t count_minus_one = v & 0xf;
385 if (start + count_minus_one >= 32)
386 return _URC_FAILURE;
387 _Unwind_VRS_Pop(context, _UVRSC_VFP,
388 RegisterRange(start, count_minus_one),
389 _UVRSD_DOUBLE);
390 break;
391 }
392 default:
393 return _URC_FAILURE;
394 }
395 break;
396 }
397 case 0xd0: {
398 if (byte & 0x08)
399 return _URC_FAILURE;
400 _Unwind_VRS_Pop(context, _UVRSC_VFP, RegisterRange(8, byte & 0x7),
401 _UVRSD_DOUBLE);
402 break;
403 }
404 default:
405 return _URC_FAILURE;
406 }
407 }
408 }
409 if (!wrotePC) {
410 uint32_t lr;
411 _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_LR, _UVRSD_UINT32, &lr);
412 _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_IP, _UVRSD_UINT32, &lr);
413 }
414 return _URC_CONTINUE_UNWIND;
415 }
416
417 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__aeabi_unwind_cpp_pr0(_Unwind_State state,_Unwind_Control_Block * ucbp,_Unwind_Context * context)418 __aeabi_unwind_cpp_pr0(_Unwind_State state, _Unwind_Control_Block *ucbp,
419 _Unwind_Context *context) {
420 return unwindOneFrame(state, ucbp, context);
421 }
422
423 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__aeabi_unwind_cpp_pr1(_Unwind_State state,_Unwind_Control_Block * ucbp,_Unwind_Context * context)424 __aeabi_unwind_cpp_pr1(_Unwind_State state, _Unwind_Control_Block *ucbp,
425 _Unwind_Context *context) {
426 return unwindOneFrame(state, ucbp, context);
427 }
428
429 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__aeabi_unwind_cpp_pr2(_Unwind_State state,_Unwind_Control_Block * ucbp,_Unwind_Context * context)430 __aeabi_unwind_cpp_pr2(_Unwind_State state, _Unwind_Control_Block *ucbp,
431 _Unwind_Context *context) {
432 return unwindOneFrame(state, ucbp, context);
433 }
434
435 static _Unwind_Reason_Code
unwind_phase1(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object)436 unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
437 // EHABI #7.3 discusses preserving the VRS in a "temporary VRS" during
438 // phase 1 and then restoring it to the "primary VRS" for phase 2. The
439 // effect is phase 2 doesn't see any of the VRS manipulations from phase 1.
440 // In this implementation, the phases don't share the VRS backing store.
441 // Instead, they are passed the original |uc| and they create a new VRS
442 // from scratch thus achieving the same effect.
443 unw_init_local(cursor, uc);
444
445 // Walk each frame looking for a place to stop.
446 for (bool handlerNotFound = true; handlerNotFound;) {
447
448 // See if frame has code to run (has personality routine).
449 unw_proc_info_t frameInfo;
450 if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
451 _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_get_proc_info "
452 "failed => _URC_FATAL_PHASE1_ERROR",
453 static_cast<void *>(exception_object));
454 return _URC_FATAL_PHASE1_ERROR;
455 }
456
457 // When tracing, print state information.
458 if (_LIBUNWIND_TRACING_UNWINDING) {
459 char functionBuf[512];
460 const char *functionName = functionBuf;
461 unw_word_t offset;
462 if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
463 &offset) != UNW_ESUCCESS) ||
464 (frameInfo.start_ip + offset > frameInfo.end_ip))
465 functionName = ".anonymous.";
466 unw_word_t pc;
467 unw_get_reg(cursor, UNW_REG_IP, &pc);
468 _LIBUNWIND_TRACE_UNWINDING(
469 "unwind_phase1(ex_ojb=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR ", func=%s, "
470 "lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
471 static_cast<void *>(exception_object), pc,
472 frameInfo.start_ip, functionName,
473 frameInfo.lsda, frameInfo.handler);
474 }
475
476 // If there is a personality routine, ask it if it will want to stop at
477 // this frame.
478 if (frameInfo.handler != 0) {
479 __personality_routine p =
480 (__personality_routine)(long)(frameInfo.handler);
481 _LIBUNWIND_TRACE_UNWINDING(
482 "unwind_phase1(ex_ojb=%p): calling personality function %p",
483 static_cast<void *>(exception_object),
484 reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(p)));
485 struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
486 exception_object->pr_cache.fnstart = frameInfo.start_ip;
487 exception_object->pr_cache.ehtp =
488 (_Unwind_EHT_Header *)frameInfo.unwind_info;
489 exception_object->pr_cache.additional = frameInfo.flags;
490 _Unwind_Reason_Code personalityResult =
491 (*p)(_US_VIRTUAL_UNWIND_FRAME, exception_object, context);
492 _LIBUNWIND_TRACE_UNWINDING(
493 "unwind_phase1(ex_ojb=%p): personality result %d start_ip %x ehtp %p "
494 "additional %x",
495 static_cast<void *>(exception_object), personalityResult,
496 exception_object->pr_cache.fnstart,
497 static_cast<void *>(exception_object->pr_cache.ehtp),
498 exception_object->pr_cache.additional);
499 switch (personalityResult) {
500 case _URC_HANDLER_FOUND:
501 // found a catch clause or locals that need destructing in this frame
502 // stop search and remember stack pointer at the frame
503 handlerNotFound = false;
504 // p should have initialized barrier_cache. EHABI #7.3.5
505 _LIBUNWIND_TRACE_UNWINDING(
506 "unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND",
507 static_cast<void *>(exception_object));
508 return _URC_NO_REASON;
509
510 case _URC_CONTINUE_UNWIND:
511 _LIBUNWIND_TRACE_UNWINDING(
512 "unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND",
513 static_cast<void *>(exception_object));
514 // continue unwinding
515 break;
516
517 // EHABI #7.3.3
518 case _URC_FAILURE:
519 return _URC_FAILURE;
520
521 default:
522 // something went wrong
523 _LIBUNWIND_TRACE_UNWINDING(
524 "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
525 static_cast<void *>(exception_object));
526 return _URC_FATAL_PHASE1_ERROR;
527 }
528 }
529 }
530 return _URC_NO_REASON;
531 }
532
unwind_phase2(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object,bool resume)533 static _Unwind_Reason_Code unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor,
534 _Unwind_Exception *exception_object,
535 bool resume) {
536 // See comment at the start of unwind_phase1 regarding VRS integrity.
537 unw_init_local(cursor, uc);
538
539 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
540 static_cast<void *>(exception_object));
541 int frame_count = 0;
542
543 // Walk each frame until we reach where search phase said to stop.
544 while (true) {
545 // Ask libunwind to get next frame (skip over first which is
546 // _Unwind_RaiseException or _Unwind_Resume).
547 //
548 // Resume only ever makes sense for 1 frame.
549 _Unwind_State state =
550 resume ? _US_UNWIND_FRAME_RESUME : _US_UNWIND_FRAME_STARTING;
551 if (resume && frame_count == 1) {
552 // On a resume, first unwind the _Unwind_Resume() frame. The next frame
553 // is now the landing pad for the cleanup from a previous execution of
554 // phase2. To continue unwindingly correctly, replace VRS[15] with the
555 // IP of the frame that the previous run of phase2 installed the context
556 // for. After this, continue unwinding as if normal.
557 //
558 // See #7.4.6 for details.
559 unw_set_reg(cursor, UNW_REG_IP,
560 exception_object->unwinder_cache.reserved2);
561 resume = false;
562 }
563
564 // Get info about this frame.
565 unw_word_t sp;
566 unw_proc_info_t frameInfo;
567 unw_get_reg(cursor, UNW_REG_SP, &sp);
568 if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
569 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_get_proc_info "
570 "failed => _URC_FATAL_PHASE2_ERROR",
571 static_cast<void *>(exception_object));
572 return _URC_FATAL_PHASE2_ERROR;
573 }
574
575 // When tracing, print state information.
576 if (_LIBUNWIND_TRACING_UNWINDING) {
577 char functionBuf[512];
578 const char *functionName = functionBuf;
579 unw_word_t offset;
580 if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
581 &offset) != UNW_ESUCCESS) ||
582 (frameInfo.start_ip + offset > frameInfo.end_ip))
583 functionName = ".anonymous.";
584 _LIBUNWIND_TRACE_UNWINDING(
585 "unwind_phase2(ex_ojb=%p): start_ip=0x%" PRIxPTR ", func=%s, sp=0x%" PRIxPTR ", "
586 "lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "",
587 static_cast<void *>(exception_object), frameInfo.start_ip,
588 functionName, sp, frameInfo.lsda,
589 frameInfo.handler);
590 }
591
592 // If there is a personality routine, tell it we are unwinding.
593 if (frameInfo.handler != 0) {
594 __personality_routine p =
595 (__personality_routine)(long)(frameInfo.handler);
596 struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
597 // EHABI #7.2
598 exception_object->pr_cache.fnstart = frameInfo.start_ip;
599 exception_object->pr_cache.ehtp =
600 (_Unwind_EHT_Header *)frameInfo.unwind_info;
601 exception_object->pr_cache.additional = frameInfo.flags;
602 _Unwind_Reason_Code personalityResult =
603 (*p)(state, exception_object, context);
604 switch (personalityResult) {
605 case _URC_CONTINUE_UNWIND:
606 // Continue unwinding
607 _LIBUNWIND_TRACE_UNWINDING(
608 "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
609 static_cast<void *>(exception_object));
610 // EHABI #7.2
611 if (sp == exception_object->barrier_cache.sp) {
612 // Phase 1 said we would stop at this frame, but we did not...
613 _LIBUNWIND_ABORT("during phase1 personality function said it would "
614 "stop here, but now in phase2 it did not stop here");
615 }
616 break;
617 case _URC_INSTALL_CONTEXT:
618 _LIBUNWIND_TRACE_UNWINDING(
619 "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT",
620 static_cast<void *>(exception_object));
621 // Personality routine says to transfer control to landing pad.
622 // We may get control back if landing pad calls _Unwind_Resume().
623 if (_LIBUNWIND_TRACING_UNWINDING) {
624 unw_word_t pc;
625 unw_get_reg(cursor, UNW_REG_IP, &pc);
626 unw_get_reg(cursor, UNW_REG_SP, &sp);
627 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering "
628 "user code with ip=0x%" PRIxPTR ", sp=0x%" PRIxPTR,
629 static_cast<void *>(exception_object),
630 pc, sp);
631 }
632
633 {
634 // EHABI #7.4.1 says we need to preserve pc for when _Unwind_Resume
635 // is called back, to find this same frame.
636 unw_word_t pc;
637 unw_get_reg(cursor, UNW_REG_IP, &pc);
638 exception_object->unwinder_cache.reserved2 = (uint32_t)pc;
639 }
640 unw_resume(cursor);
641 // unw_resume() only returns if there was an error.
642 return _URC_FATAL_PHASE2_ERROR;
643
644 // # EHABI #7.4.3
645 case _URC_FAILURE:
646 abort();
647
648 default:
649 // Personality routine returned an unknown result code.
650 _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
651 personalityResult);
652 return _URC_FATAL_PHASE2_ERROR;
653 }
654 }
655 frame_count++;
656 }
657
658 // Clean up phase did not resume at the frame that the search phase
659 // said it would...
660 return _URC_FATAL_PHASE2_ERROR;
661 }
662
663 /// Called by __cxa_throw. Only returns if there is a fatal error.
664 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_RaiseException(_Unwind_Exception * exception_object)665 _Unwind_RaiseException(_Unwind_Exception *exception_object) {
666 _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
667 static_cast<void *>(exception_object));
668 unw_context_t uc;
669 unw_cursor_t cursor;
670 unw_getcontext(&uc);
671
672 // This field for is for compatibility with GCC to say this isn't a forced
673 // unwind. EHABI #7.2
674 exception_object->unwinder_cache.reserved1 = 0;
675
676 // phase 1: the search phase
677 _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object);
678 if (phase1 != _URC_NO_REASON)
679 return phase1;
680
681 // phase 2: the clean up phase
682 return unwind_phase2(&uc, &cursor, exception_object, false);
683 }
684
_Unwind_Complete(_Unwind_Exception * exception_object)685 _LIBUNWIND_EXPORT void _Unwind_Complete(_Unwind_Exception* exception_object) {
686 // This is to be called when exception handling completes to give us a chance
687 // to perform any housekeeping. EHABI #7.2. But we have nothing to do here.
688 (void)exception_object;
689 }
690
691 /// When _Unwind_RaiseException() is in phase2, it hands control
692 /// to the personality function at each frame. The personality
693 /// may force a jump to a landing pad in that function, the landing
694 /// pad code may then call _Unwind_Resume() to continue with the
695 /// unwinding. Note: the call to _Unwind_Resume() is from compiler
696 /// geneated user code. All other _Unwind_* routines are called
697 /// by the C++ runtime __cxa_* routines.
698 ///
699 /// Note: re-throwing an exception (as opposed to continuing the unwind)
700 /// is implemented by having the code call __cxa_rethrow() which
701 /// in turn calls _Unwind_Resume_or_Rethrow().
702 _LIBUNWIND_EXPORT void
_Unwind_Resume(_Unwind_Exception * exception_object)703 _Unwind_Resume(_Unwind_Exception *exception_object) {
704 _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)",
705 static_cast<void *>(exception_object));
706 unw_context_t uc;
707 unw_cursor_t cursor;
708 unw_getcontext(&uc);
709
710 // _Unwind_RaiseException on EHABI will always set the reserved1 field to 0,
711 // which is in the same position as private_1 below.
712 // TODO(ajwong): Who wronte the above? Why is it true?
713 unwind_phase2(&uc, &cursor, exception_object, true);
714
715 // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
716 _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
717 }
718
719 /// Called by personality handler during phase 2 to get LSDA for current frame.
720 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetLanguageSpecificData(struct _Unwind_Context * context)721 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
722 unw_cursor_t *cursor = (unw_cursor_t *)context;
723 unw_proc_info_t frameInfo;
724 uintptr_t result = 0;
725 if (unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
726 result = (uintptr_t)frameInfo.lsda;
727 _LIBUNWIND_TRACE_API(
728 "_Unwind_GetLanguageSpecificData(context=%p) => 0x%llx",
729 static_cast<void *>(context), (long long)result);
730 return result;
731 }
732
ValueAsBitPattern(_Unwind_VRS_DataRepresentation representation,void * valuep)733 static uint64_t ValueAsBitPattern(_Unwind_VRS_DataRepresentation representation,
734 void* valuep) {
735 uint64_t value = 0;
736 switch (representation) {
737 case _UVRSD_UINT32:
738 case _UVRSD_FLOAT:
739 memcpy(&value, valuep, sizeof(uint32_t));
740 break;
741
742 case _UVRSD_VFPX:
743 case _UVRSD_UINT64:
744 case _UVRSD_DOUBLE:
745 memcpy(&value, valuep, sizeof(uint64_t));
746 break;
747 }
748 return value;
749 }
750
751 _LIBUNWIND_EXPORT _Unwind_VRS_Result
_Unwind_VRS_Set(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t regno,_Unwind_VRS_DataRepresentation representation,void * valuep)752 _Unwind_VRS_Set(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
753 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
754 void *valuep) {
755 _LIBUNWIND_TRACE_API("_Unwind_VRS_Set(context=%p, regclass=%d, reg=%d, "
756 "rep=%d, value=0x%llX)",
757 static_cast<void *>(context), regclass, regno,
758 representation,
759 ValueAsBitPattern(representation, valuep));
760 unw_cursor_t *cursor = (unw_cursor_t *)context;
761 switch (regclass) {
762 case _UVRSC_CORE:
763 if (representation != _UVRSD_UINT32 || regno > 15)
764 return _UVRSR_FAILED;
765 return unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
766 *(unw_word_t *)valuep) == UNW_ESUCCESS
767 ? _UVRSR_OK
768 : _UVRSR_FAILED;
769 case _UVRSC_VFP:
770 if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
771 return _UVRSR_FAILED;
772 if (representation == _UVRSD_VFPX) {
773 // Can only touch d0-15 with FSTMFDX.
774 if (regno > 15)
775 return _UVRSR_FAILED;
776 unw_save_vfp_as_X(cursor);
777 } else {
778 if (regno > 31)
779 return _UVRSR_FAILED;
780 }
781 return unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
782 *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
783 ? _UVRSR_OK
784 : _UVRSR_FAILED;
785 #if defined(__ARM_WMMX)
786 case _UVRSC_WMMXC:
787 if (representation != _UVRSD_UINT32 || regno > 3)
788 return _UVRSR_FAILED;
789 return unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
790 *(unw_word_t *)valuep) == UNW_ESUCCESS
791 ? _UVRSR_OK
792 : _UVRSR_FAILED;
793 case _UVRSC_WMMXD:
794 if (representation != _UVRSD_DOUBLE || regno > 31)
795 return _UVRSR_FAILED;
796 return unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
797 *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
798 ? _UVRSR_OK
799 : _UVRSR_FAILED;
800 #else
801 case _UVRSC_WMMXC:
802 case _UVRSC_WMMXD:
803 break;
804 #endif
805 }
806 _LIBUNWIND_ABORT("unsupported register class");
807 }
808
809 static _Unwind_VRS_Result
_Unwind_VRS_Get_Internal(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t regno,_Unwind_VRS_DataRepresentation representation,void * valuep)810 _Unwind_VRS_Get_Internal(_Unwind_Context *context,
811 _Unwind_VRS_RegClass regclass, uint32_t regno,
812 _Unwind_VRS_DataRepresentation representation,
813 void *valuep) {
814 unw_cursor_t *cursor = (unw_cursor_t *)context;
815 switch (regclass) {
816 case _UVRSC_CORE:
817 if (representation != _UVRSD_UINT32 || regno > 15)
818 return _UVRSR_FAILED;
819 return unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
820 (unw_word_t *)valuep) == UNW_ESUCCESS
821 ? _UVRSR_OK
822 : _UVRSR_FAILED;
823 case _UVRSC_VFP:
824 if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
825 return _UVRSR_FAILED;
826 if (representation == _UVRSD_VFPX) {
827 // Can only touch d0-15 with FSTMFDX.
828 if (regno > 15)
829 return _UVRSR_FAILED;
830 unw_save_vfp_as_X(cursor);
831 } else {
832 if (regno > 31)
833 return _UVRSR_FAILED;
834 }
835 return unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
836 (unw_fpreg_t *)valuep) == UNW_ESUCCESS
837 ? _UVRSR_OK
838 : _UVRSR_FAILED;
839 #if defined(__ARM_WMMX)
840 case _UVRSC_WMMXC:
841 if (representation != _UVRSD_UINT32 || regno > 3)
842 return _UVRSR_FAILED;
843 return unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
844 (unw_word_t *)valuep) == UNW_ESUCCESS
845 ? _UVRSR_OK
846 : _UVRSR_FAILED;
847 case _UVRSC_WMMXD:
848 if (representation != _UVRSD_DOUBLE || regno > 31)
849 return _UVRSR_FAILED;
850 return unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
851 (unw_fpreg_t *)valuep) == UNW_ESUCCESS
852 ? _UVRSR_OK
853 : _UVRSR_FAILED;
854 #else
855 case _UVRSC_WMMXC:
856 case _UVRSC_WMMXD:
857 break;
858 #endif
859 }
860 _LIBUNWIND_ABORT("unsupported register class");
861 }
862
863 _LIBUNWIND_EXPORT _Unwind_VRS_Result
_Unwind_VRS_Get(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t regno,_Unwind_VRS_DataRepresentation representation,void * valuep)864 _Unwind_VRS_Get(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
865 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
866 void *valuep) {
867 _Unwind_VRS_Result result =
868 _Unwind_VRS_Get_Internal(context, regclass, regno, representation,
869 valuep);
870 _LIBUNWIND_TRACE_API("_Unwind_VRS_Get(context=%p, regclass=%d, reg=%d, "
871 "rep=%d, value=0x%llX, result = %d)",
872 static_cast<void *>(context), regclass, regno,
873 representation,
874 ValueAsBitPattern(representation, valuep), result);
875 return result;
876 }
877
878 _Unwind_VRS_Result
_Unwind_VRS_Pop(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t discriminator,_Unwind_VRS_DataRepresentation representation)879 _Unwind_VRS_Pop(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
880 uint32_t discriminator,
881 _Unwind_VRS_DataRepresentation representation) {
882 _LIBUNWIND_TRACE_API("_Unwind_VRS_Pop(context=%p, regclass=%d, "
883 "discriminator=%d, representation=%d)",
884 static_cast<void *>(context), regclass, discriminator,
885 representation);
886 switch (regclass) {
887 case _UVRSC_WMMXC:
888 #if !defined(__ARM_WMMX)
889 break;
890 #endif
891 case _UVRSC_CORE: {
892 if (representation != _UVRSD_UINT32)
893 return _UVRSR_FAILED;
894 // When popping SP from the stack, we don't want to override it from the
895 // computed new stack location. See EHABI #7.5.4 table 3.
896 bool poppedSP = false;
897 uint32_t* sp;
898 if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
899 _UVRSD_UINT32, &sp) != _UVRSR_OK) {
900 return _UVRSR_FAILED;
901 }
902 for (uint32_t i = 0; i < 16; ++i) {
903 if (!(discriminator & static_cast<uint32_t>(1 << i)))
904 continue;
905 uint32_t value = *sp++;
906 if (regclass == _UVRSC_CORE && i == 13)
907 poppedSP = true;
908 if (_Unwind_VRS_Set(context, regclass, i,
909 _UVRSD_UINT32, &value) != _UVRSR_OK) {
910 return _UVRSR_FAILED;
911 }
912 }
913 if (!poppedSP) {
914 return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP,
915 _UVRSD_UINT32, &sp);
916 }
917 return _UVRSR_OK;
918 }
919 case _UVRSC_WMMXD:
920 #if !defined(__ARM_WMMX)
921 break;
922 #endif
923 case _UVRSC_VFP: {
924 if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
925 return _UVRSR_FAILED;
926 uint32_t first = discriminator >> 16;
927 uint32_t count = discriminator & 0xffff;
928 uint32_t end = first+count;
929 uint32_t* sp;
930 if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
931 _UVRSD_UINT32, &sp) != _UVRSR_OK) {
932 return _UVRSR_FAILED;
933 }
934 // For _UVRSD_VFPX, we're assuming the data is stored in FSTMX "standard
935 // format 1", which is equivalent to FSTMD + a padding word.
936 for (uint32_t i = first; i < end; ++i) {
937 // SP is only 32-bit aligned so don't copy 64-bit at a time.
938 uint64_t value = *sp++;
939 value |= ((uint64_t)(*sp++)) << 32;
940 if (_Unwind_VRS_Set(context, regclass, i, representation, &value) !=
941 _UVRSR_OK)
942 return _UVRSR_FAILED;
943 }
944 if (representation == _UVRSD_VFPX)
945 ++sp;
946 return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
947 &sp);
948 }
949 }
950 _LIBUNWIND_ABORT("unsupported register class");
951 }
952
953 /// Called by personality handler during phase 2 to find the start of the
954 /// function.
955 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetRegionStart(struct _Unwind_Context * context)956 _Unwind_GetRegionStart(struct _Unwind_Context *context) {
957 unw_cursor_t *cursor = (unw_cursor_t *)context;
958 unw_proc_info_t frameInfo;
959 uintptr_t result = 0;
960 if (unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
961 result = (uintptr_t)frameInfo.start_ip;
962 _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%llX",
963 static_cast<void *>(context), (long long)result);
964 return result;
965 }
966
967
968 /// Called by personality handler during phase 2 if a foreign exception
969 // is caught.
970 _LIBUNWIND_EXPORT void
_Unwind_DeleteException(_Unwind_Exception * exception_object)971 _Unwind_DeleteException(_Unwind_Exception *exception_object) {
972 _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
973 static_cast<void *>(exception_object));
974 if (exception_object->exception_cleanup != NULL)
975 (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
976 exception_object);
977 }
978
979 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__gnu_unwind_frame(_Unwind_Exception * exception_object,struct _Unwind_Context * context)980 __gnu_unwind_frame(_Unwind_Exception *exception_object,
981 struct _Unwind_Context *context) {
982 unw_cursor_t *cursor = (unw_cursor_t *)context;
983 if (unw_step(cursor) != UNW_STEP_SUCCESS)
984 return _URC_FAILURE;
985 return _URC_OK;
986 }
987
988 #endif // defined(_LIBUNWIND_ARM_EHABI)
989