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