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