1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //
8 //  Implements 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         break;
101       case Descriptor::LU16:
102         descriptor = getNextNibble(descriptor, &length);
103         descriptor = getNextNibble(descriptor, &offset);
104         break;
105       default:
106         assert(false);
107         return _URC_FAILURE;
108     }
109 
110     // See # 9.2 table for decoding the kind of descriptor. It's a 2-bit value.
111     Descriptor::Kind kind =
112         static_cast<Descriptor::Kind>((length & 0x1) | ((offset & 0x1) << 1));
113 
114     // Clear off flag from last bit.
115     length &= ~1u;
116     offset &= ~1u;
117     uintptr_t scopeStart = ucbp->pr_cache.fnstart + offset;
118     uintptr_t scopeEnd = scopeStart + length;
119     uintptr_t pc = _Unwind_GetIP(context);
120     bool isInScope = (scopeStart <= pc) && (pc < scopeEnd);
121 
122     switch (kind) {
123       case Descriptor::CLEANUP: {
124         // TODO(ajwong): Handle cleanup descriptors.
125         break;
126       }
127       case Descriptor::FUNC: {
128         // TODO(ajwong): Handle function descriptors.
129         break;
130       }
131       case Descriptor::CATCH: {
132         // Catch descriptors require gobbling one more word.
133         uint32_t landing_pad;
134         descriptor = getNextWord(descriptor, &landing_pad);
135 
136         if (isInScope) {
137           // TODO(ajwong): This is only phase1 compatible logic. Implement
138           // phase2.
139           landing_pad = signExtendPrel31(landing_pad & ~0x80000000);
140           if (landing_pad == 0xffffffff) {
141             return _URC_HANDLER_FOUND;
142           } else if (landing_pad == 0xfffffffe) {
143             return _URC_FAILURE;
144           } else {
145             /*
146             bool is_reference_type = landing_pad & 0x80000000;
147             void* matched_object;
148             if (__cxxabiv1::__cxa_type_match(
149                     ucbp, reinterpret_cast<const std::type_info *>(landing_pad),
150                     is_reference_type,
151                     &matched_object) != __cxxabiv1::ctm_failed)
152                 return _URC_HANDLER_FOUND;
153                 */
154             _LIBUNWIND_ABORT("Type matching not implemented");
155           }
156         }
157         break;
158       }
159       default:
160         _LIBUNWIND_ABORT("Invalid descriptor kind found.");
161     }
162 
163     getNextWord(descriptor, &descriptorWord);
164   }
165 
166   return _URC_CONTINUE_UNWIND;
167 }
168 
unwindOneFrame(_Unwind_State state,_Unwind_Control_Block * ucbp,struct _Unwind_Context * context)169 static _Unwind_Reason_Code unwindOneFrame(_Unwind_State state,
170                                           _Unwind_Control_Block* ucbp,
171                                           struct _Unwind_Context* context) {
172   // Read the compact model EHT entry's header # 6.3
173   const uint32_t* unwindingData = ucbp->pr_cache.ehtp;
174   assert((*unwindingData & 0xf0000000) == 0x80000000 && "Must be a compact entry");
175   Descriptor::Format format =
176       static_cast<Descriptor::Format>((*unwindingData & 0x0f000000) >> 24);
177 
178   const char *lsda =
179       reinterpret_cast<const char *>(_Unwind_GetLanguageSpecificData(context));
180 
181   // Handle descriptors before unwinding so they are processed in the context
182   // of the correct stack frame.
183   _Unwind_Reason_Code result =
184       ProcessDescriptors(state, ucbp, context, format, lsda,
185                          ucbp->pr_cache.additional);
186 
187   if (result != _URC_CONTINUE_UNWIND)
188     return result;
189 
190   switch (__unw_step(reinterpret_cast<unw_cursor_t *>(context))) {
191   case UNW_STEP_SUCCESS:
192     return _URC_CONTINUE_UNWIND;
193   case UNW_STEP_END:
194     return _URC_END_OF_STACK;
195   default:
196     return _URC_FAILURE;
197   }
198 }
199 
200 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_CORE /
201 // _UVRSD_UINT32.
RegisterMask(uint8_t start,uint8_t count_minus_one)202 uint32_t RegisterMask(uint8_t start, uint8_t count_minus_one) {
203   return ((1U << (count_minus_one + 1)) - 1) << start;
204 }
205 
206 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_VFP /
207 // _UVRSD_DOUBLE.
RegisterRange(uint8_t start,uint8_t count_minus_one)208 uint32_t RegisterRange(uint8_t start, uint8_t count_minus_one) {
209   return ((uint32_t)start << 16) | ((uint32_t)count_minus_one + 1);
210 }
211 
212 } // end anonymous namespace
213 
214 /**
215  * Decodes an EHT entry.
216  *
217  * @param data Pointer to EHT.
218  * @param[out] off Offset from return value (in bytes) to begin interpretation.
219  * @param[out] len Number of bytes in unwind code.
220  * @return Pointer to beginning of unwind code.
221  */
222 extern "C" const uint32_t*
decode_eht_entry(const uint32_t * data,size_t * off,size_t * len)223 decode_eht_entry(const uint32_t* data, size_t* off, size_t* len) {
224   if ((*data & 0x80000000) == 0) {
225     // 6.2: Generic Model
226     //
227     // EHT entry is a prel31 pointing to the PR, followed by data understood
228     // only by the personality routine. Fortunately, all existing assembler
229     // implementations, including GNU assembler, LLVM integrated assembler,
230     // and ARM assembler, assume that the unwind opcodes come after the
231     // personality rountine address.
232     *off = 1; // First byte is size data.
233     *len = (((data[1] >> 24) & 0xff) + 1) * 4;
234     data++; // Skip the first word, which is the prel31 offset.
235   } else {
236     // 6.3: ARM Compact Model
237     //
238     // EHT entries here correspond to the __aeabi_unwind_cpp_pr[012] PRs indeed
239     // by format:
240     Descriptor::Format format =
241         static_cast<Descriptor::Format>((*data & 0x0f000000) >> 24);
242     switch (format) {
243       case Descriptor::SU16:
244         *len = 4;
245         *off = 1;
246         break;
247       case Descriptor::LU16:
248       case Descriptor::LU32:
249         *len = 4 + 4 * ((*data & 0x00ff0000) >> 16);
250         *off = 2;
251         break;
252       default:
253         return nullptr;
254     }
255   }
256   return data;
257 }
258 
259 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_VRS_Interpret(_Unwind_Context * context,const uint32_t * data,size_t offset,size_t len)260 _Unwind_VRS_Interpret(_Unwind_Context *context, const uint32_t *data,
261                       size_t offset, size_t len) {
262   bool wrotePC = false;
263   bool finish = false;
264   bool hasReturnAddrAuthCode = false;
265   while (offset < len && !finish) {
266     uint8_t byte = getByte(data, offset++);
267     if ((byte & 0x80) == 0) {
268       uint32_t sp;
269       _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
270       if (byte & 0x40)
271         sp -= (((uint32_t)byte & 0x3f) << 2) + 4;
272       else
273         sp += ((uint32_t)byte << 2) + 4;
274       _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
275     } else {
276       switch (byte & 0xf0) {
277         case 0x80: {
278           if (offset >= len)
279             return _URC_FAILURE;
280           uint32_t registers =
281               (((uint32_t)byte & 0x0f) << 12) |
282               (((uint32_t)getByte(data, offset++)) << 4);
283           if (!registers)
284             return _URC_FAILURE;
285           if (registers & (1 << 15))
286             wrotePC = true;
287           _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
288           break;
289         }
290         case 0x90: {
291           uint8_t reg = byte & 0x0f;
292           if (reg == 13 || reg == 15)
293             return _URC_FAILURE;
294           uint32_t sp;
295           _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_R0 + reg,
296                           _UVRSD_UINT32, &sp);
297           _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
298                           &sp);
299           break;
300         }
301         case 0xa0: {
302           uint32_t registers = RegisterMask(4, byte & 0x07);
303           if (byte & 0x08)
304             registers |= 1 << 14;
305           _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
306           break;
307         }
308         case 0xb0: {
309           switch (byte) {
310             case 0xb0:
311               finish = true;
312               break;
313             case 0xb1: {
314               if (offset >= len)
315                 return _URC_FAILURE;
316               uint8_t registers = getByte(data, offset++);
317               if (registers & 0xf0 || !registers)
318                 return _URC_FAILURE;
319               _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
320               break;
321             }
322             case 0xb2: {
323               uint32_t addend = 0;
324               uint32_t shift = 0;
325               // This decodes a uleb128 value.
326               while (true) {
327                 if (offset >= len)
328                   return _URC_FAILURE;
329                 uint32_t v = getByte(data, offset++);
330                 addend |= (v & 0x7f) << shift;
331                 if ((v & 0x80) == 0)
332                   break;
333                 shift += 7;
334               }
335               uint32_t sp;
336               _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
337                               &sp);
338               sp += 0x204 + (addend << 2);
339               _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
340                               &sp);
341               break;
342             }
343             case 0xb3: {
344               uint8_t v = getByte(data, offset++);
345               _Unwind_VRS_Pop(context, _UVRSC_VFP,
346                               RegisterRange(static_cast<uint8_t>(v >> 4),
347                                             v & 0x0f), _UVRSD_VFPX);
348               break;
349             }
350             case 0xb4:
351               hasReturnAddrAuthCode = true;
352               _Unwind_VRS_Pop(context, _UVRSC_PSEUDO,
353                               0 /* Return Address Auth Code */, _UVRSD_UINT32);
354               break;
355             case 0xb5:
356             case 0xb6:
357             case 0xb7:
358               return _URC_FAILURE;
359             default:
360               _Unwind_VRS_Pop(context, _UVRSC_VFP,
361                               RegisterRange(8, byte & 0x07), _UVRSD_VFPX);
362               break;
363           }
364           break;
365         }
366         case 0xc0: {
367           switch (byte) {
368 #if defined(__ARM_WMMX)
369             case 0xc0:
370             case 0xc1:
371             case 0xc2:
372             case 0xc3:
373             case 0xc4:
374             case 0xc5:
375               _Unwind_VRS_Pop(context, _UVRSC_WMMXD,
376                               RegisterRange(10, byte & 0x7), _UVRSD_DOUBLE);
377               break;
378             case 0xc6: {
379               uint8_t v = getByte(data, offset++);
380               uint8_t start = static_cast<uint8_t>(v >> 4);
381               uint8_t count_minus_one = v & 0xf;
382               if (start + count_minus_one >= 16)
383                 return _URC_FAILURE;
384               _Unwind_VRS_Pop(context, _UVRSC_WMMXD,
385                               RegisterRange(start, count_minus_one),
386                               _UVRSD_DOUBLE);
387               break;
388             }
389             case 0xc7: {
390               uint8_t v = getByte(data, offset++);
391               if (!v || v & 0xf0)
392                 return _URC_FAILURE;
393               _Unwind_VRS_Pop(context, _UVRSC_WMMXC, v, _UVRSD_DOUBLE);
394               break;
395             }
396 #endif
397             case 0xc8:
398             case 0xc9: {
399               uint8_t v = getByte(data, offset++);
400               uint8_t start =
401                   static_cast<uint8_t>(((byte == 0xc8) ? 16 : 0) + (v >> 4));
402               uint8_t count_minus_one = v & 0xf;
403               if (start + count_minus_one >= 32)
404                 return _URC_FAILURE;
405               _Unwind_VRS_Pop(context, _UVRSC_VFP,
406                               RegisterRange(start, count_minus_one),
407                               _UVRSD_DOUBLE);
408               break;
409             }
410             default:
411               return _URC_FAILURE;
412           }
413           break;
414         }
415         case 0xd0: {
416           if (byte & 0x08)
417             return _URC_FAILURE;
418           _Unwind_VRS_Pop(context, _UVRSC_VFP, RegisterRange(8, byte & 0x7),
419                           _UVRSD_DOUBLE);
420           break;
421         }
422         default:
423           return _URC_FAILURE;
424       }
425     }
426   }
427   if (!wrotePC) {
428     uint32_t lr;
429     _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_LR, _UVRSD_UINT32, &lr);
430 #ifdef __ARM_FEATURE_PAUTH
431     if (hasReturnAddrAuthCode) {
432       uint32_t sp;
433       uint32_t pac;
434       _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
435       _Unwind_VRS_Get(context, _UVRSC_PSEUDO, 0, _UVRSD_UINT32, &pac);
436       __asm__ __volatile__("autg %0, %1, %2" : : "r"(pac), "r"(lr), "r"(sp) :);
437     }
438 #else
439     (void)hasReturnAddrAuthCode;
440 #endif
441     _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_IP, _UVRSD_UINT32, &lr);
442   }
443   return _URC_CONTINUE_UNWIND;
444 }
445 
446 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__aeabi_unwind_cpp_pr0(_Unwind_State state,_Unwind_Control_Block * ucbp,_Unwind_Context * context)447 __aeabi_unwind_cpp_pr0(_Unwind_State state, _Unwind_Control_Block *ucbp,
448                        _Unwind_Context *context) {
449   return unwindOneFrame(state, ucbp, context);
450 }
451 
452 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__aeabi_unwind_cpp_pr1(_Unwind_State state,_Unwind_Control_Block * ucbp,_Unwind_Context * context)453 __aeabi_unwind_cpp_pr1(_Unwind_State state, _Unwind_Control_Block *ucbp,
454                        _Unwind_Context *context) {
455   return unwindOneFrame(state, ucbp, context);
456 }
457 
458 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__aeabi_unwind_cpp_pr2(_Unwind_State state,_Unwind_Control_Block * ucbp,_Unwind_Context * context)459 __aeabi_unwind_cpp_pr2(_Unwind_State state, _Unwind_Control_Block *ucbp,
460                        _Unwind_Context *context) {
461   return unwindOneFrame(state, ucbp, context);
462 }
463 
464 static _Unwind_Reason_Code
unwind_phase1(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object)465 unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
466   // EHABI #7.3 discusses preserving the VRS in a "temporary VRS" during
467   // phase 1 and then restoring it to the "primary VRS" for phase 2. The
468   // effect is phase 2 doesn't see any of the VRS manipulations from phase 1.
469   // In this implementation, the phases don't share the VRS backing store.
470   // Instead, they are passed the original |uc| and they create a new VRS
471   // from scratch thus achieving the same effect.
472   __unw_init_local(cursor, uc);
473 
474   // Walk each frame looking for a place to stop.
475   for (bool handlerNotFound = true; handlerNotFound;) {
476 
477     // See if frame has code to run (has personality routine).
478     unw_proc_info_t frameInfo;
479     if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
480       _LIBUNWIND_TRACE_UNWINDING(
481           "unwind_phase1(ex_ojb=%p): __unw_get_proc_info "
482           "failed => _URC_FATAL_PHASE1_ERROR",
483           static_cast<void *>(exception_object));
484       return _URC_FATAL_PHASE1_ERROR;
485     }
486 
487 #ifndef NDEBUG
488     // When tracing, print state information.
489     if (_LIBUNWIND_TRACING_UNWINDING) {
490       char functionBuf[512];
491       const char *functionName = functionBuf;
492       unw_word_t offset;
493       if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
494                                &offset) != UNW_ESUCCESS) ||
495           (frameInfo.start_ip + offset > frameInfo.end_ip))
496         functionName = ".anonymous.";
497       unw_word_t pc;
498       __unw_get_reg(cursor, UNW_REG_IP, &pc);
499       _LIBUNWIND_TRACE_UNWINDING(
500           "unwind_phase1(ex_ojb=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR ", func=%s, "
501           "lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
502           static_cast<void *>(exception_object), pc,
503           frameInfo.start_ip, functionName,
504           frameInfo.lsda, frameInfo.handler);
505     }
506 #endif
507 
508     // If there is a personality routine, ask it if it will want to stop at
509     // this frame.
510     if (frameInfo.handler != 0) {
511       _Unwind_Personality_Fn p =
512           (_Unwind_Personality_Fn)(long)(frameInfo.handler);
513       _LIBUNWIND_TRACE_UNWINDING(
514           "unwind_phase1(ex_ojb=%p): calling personality function %p",
515           static_cast<void *>(exception_object),
516           reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(p)));
517       struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
518       exception_object->pr_cache.fnstart = frameInfo.start_ip;
519       exception_object->pr_cache.ehtp =
520           (_Unwind_EHT_Header *)frameInfo.unwind_info;
521       exception_object->pr_cache.additional = frameInfo.flags;
522       _Unwind_Reason_Code personalityResult =
523           (*p)(_US_VIRTUAL_UNWIND_FRAME, exception_object, context);
524       _LIBUNWIND_TRACE_UNWINDING(
525           "unwind_phase1(ex_ojb=%p): personality result %d start_ip %x ehtp %p "
526           "additional %x",
527           static_cast<void *>(exception_object), personalityResult,
528           exception_object->pr_cache.fnstart,
529           static_cast<void *>(exception_object->pr_cache.ehtp),
530           exception_object->pr_cache.additional);
531       switch (personalityResult) {
532       case _URC_HANDLER_FOUND:
533         // found a catch clause or locals that need destructing in this frame
534         // stop search and remember stack pointer at the frame
535         handlerNotFound = false;
536         // p should have initialized barrier_cache. EHABI #7.3.5
537         _LIBUNWIND_TRACE_UNWINDING(
538             "unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND",
539             static_cast<void *>(exception_object));
540         return _URC_NO_REASON;
541 
542       case _URC_CONTINUE_UNWIND:
543         _LIBUNWIND_TRACE_UNWINDING(
544             "unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND",
545             static_cast<void *>(exception_object));
546         // continue unwinding
547         break;
548 
549       // EHABI #7.3.3
550       case _URC_FAILURE:
551         return _URC_FAILURE;
552 
553       default:
554         // something went wrong
555         _LIBUNWIND_TRACE_UNWINDING(
556             "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
557             static_cast<void *>(exception_object));
558         return _URC_FATAL_PHASE1_ERROR;
559       }
560     }
561   }
562   return _URC_NO_REASON;
563 }
564 
unwind_phase2(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object,bool resume)565 static _Unwind_Reason_Code unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor,
566                                          _Unwind_Exception *exception_object,
567                                          bool resume) {
568   // See comment at the start of unwind_phase1 regarding VRS integrity.
569   __unw_init_local(cursor, uc);
570 
571   _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
572                              static_cast<void *>(exception_object));
573   int frame_count = 0;
574 
575   // Walk each frame until we reach where search phase said to stop.
576   while (true) {
577     // Ask libunwind to get next frame (skip over first which is
578     // _Unwind_RaiseException or _Unwind_Resume).
579     //
580     // Resume only ever makes sense for 1 frame.
581     _Unwind_State state =
582         resume ? _US_UNWIND_FRAME_RESUME : _US_UNWIND_FRAME_STARTING;
583     if (resume && frame_count == 1) {
584       // On a resume, first unwind the _Unwind_Resume() frame. The next frame
585       // is now the landing pad for the cleanup from a previous execution of
586       // phase2. To continue unwindingly correctly, replace VRS[15] with the
587       // IP of the frame that the previous run of phase2 installed the context
588       // for. After this, continue unwinding as if normal.
589       //
590       // See #7.4.6 for details.
591       __unw_set_reg(cursor, UNW_REG_IP,
592                     exception_object->unwinder_cache.reserved2);
593       resume = false;
594     }
595 
596     // Get info about this frame.
597     unw_word_t sp;
598     unw_proc_info_t frameInfo;
599     __unw_get_reg(cursor, UNW_REG_SP, &sp);
600     if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
601       _LIBUNWIND_TRACE_UNWINDING(
602           "unwind_phase2(ex_ojb=%p): __unw_get_proc_info "
603           "failed => _URC_FATAL_PHASE2_ERROR",
604           static_cast<void *>(exception_object));
605       return _URC_FATAL_PHASE2_ERROR;
606     }
607 
608 #ifndef NDEBUG
609     // When tracing, print state information.
610     if (_LIBUNWIND_TRACING_UNWINDING) {
611       char functionBuf[512];
612       const char *functionName = functionBuf;
613       unw_word_t offset;
614       if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
615                                &offset) != UNW_ESUCCESS) ||
616           (frameInfo.start_ip + offset > frameInfo.end_ip))
617         functionName = ".anonymous.";
618       _LIBUNWIND_TRACE_UNWINDING(
619           "unwind_phase2(ex_ojb=%p): start_ip=0x%" PRIxPTR ", func=%s, sp=0x%" PRIxPTR ", "
620           "lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "",
621           static_cast<void *>(exception_object), frameInfo.start_ip,
622           functionName, sp, frameInfo.lsda,
623           frameInfo.handler);
624     }
625 #endif
626 
627     // If there is a personality routine, tell it we are unwinding.
628     if (frameInfo.handler != 0) {
629       _Unwind_Personality_Fn p =
630           (_Unwind_Personality_Fn)(intptr_t)(frameInfo.handler);
631       struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
632       // EHABI #7.2
633       exception_object->pr_cache.fnstart = frameInfo.start_ip;
634       exception_object->pr_cache.ehtp =
635           (_Unwind_EHT_Header *)frameInfo.unwind_info;
636       exception_object->pr_cache.additional = frameInfo.flags;
637       _Unwind_Reason_Code personalityResult =
638           (*p)(state, exception_object, context);
639       switch (personalityResult) {
640       case _URC_CONTINUE_UNWIND:
641         // Continue unwinding
642         _LIBUNWIND_TRACE_UNWINDING(
643             "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
644             static_cast<void *>(exception_object));
645         // EHABI #7.2
646         if (sp == exception_object->barrier_cache.sp) {
647           // Phase 1 said we would stop at this frame, but we did not...
648           _LIBUNWIND_ABORT("during phase1 personality function said it would "
649                            "stop here, but now in phase2 it did not stop here");
650         }
651         break;
652       case _URC_INSTALL_CONTEXT:
653         _LIBUNWIND_TRACE_UNWINDING(
654             "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT",
655             static_cast<void *>(exception_object));
656         // Personality routine says to transfer control to landing pad.
657         // We may get control back if landing pad calls _Unwind_Resume().
658         if (_LIBUNWIND_TRACING_UNWINDING) {
659           unw_word_t pc;
660           __unw_get_reg(cursor, UNW_REG_IP, &pc);
661           __unw_get_reg(cursor, UNW_REG_SP, &sp);
662           _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering "
663                                      "user code with ip=0x%" PRIxPTR ", sp=0x%" PRIxPTR,
664                                      static_cast<void *>(exception_object),
665                                      pc, sp);
666         }
667 
668         {
669           // EHABI #7.4.1 says we need to preserve pc for when _Unwind_Resume
670           // is called back, to find this same frame.
671           unw_word_t pc;
672           __unw_get_reg(cursor, UNW_REG_IP, &pc);
673           exception_object->unwinder_cache.reserved2 = (uint32_t)pc;
674         }
675         __unw_resume(cursor);
676         // __unw_resume() only returns if there was an error.
677         return _URC_FATAL_PHASE2_ERROR;
678 
679       // # EHABI #7.4.3
680       case _URC_FAILURE:
681         abort();
682 
683       default:
684         // Personality routine returned an unknown result code.
685         _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
686                       personalityResult);
687         return _URC_FATAL_PHASE2_ERROR;
688       }
689     }
690     frame_count++;
691   }
692 
693   // Clean up phase did not resume at the frame that the search phase
694   // said it would...
695   return _URC_FATAL_PHASE2_ERROR;
696 }
697 
698 static _Unwind_Reason_Code
unwind_phase2_forced(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object,_Unwind_Stop_Fn stop,void * stop_parameter)699 unwind_phase2_forced(unw_context_t *uc, unw_cursor_t *cursor,
700                      _Unwind_Exception *exception_object, _Unwind_Stop_Fn stop,
701                      void *stop_parameter) {
702   bool endOfStack = false;
703   // See comment at the start of unwind_phase1 regarding VRS integrity.
704   __unw_init_local(cursor, uc);
705   _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_force(ex_ojb=%p)",
706                              static_cast<void *>(exception_object));
707   // Walk each frame until we reach where search phase said to stop
708   while (!endOfStack) {
709     // Update info about this frame.
710     unw_proc_info_t frameInfo;
711     if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
712       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): __unw_step "
713                                  "failed => _URC_END_OF_STACK",
714                                  (void *)exception_object);
715       return _URC_FATAL_PHASE2_ERROR;
716     }
717 
718 #ifndef NDEBUG
719     // When tracing, print state information.
720     if (_LIBUNWIND_TRACING_UNWINDING) {
721       char functionBuf[512];
722       const char *functionName = functionBuf;
723       unw_word_t offset;
724       if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
725                                &offset) != UNW_ESUCCESS) ||
726           (frameInfo.start_ip + offset > frameInfo.end_ip))
727         functionName = ".anonymous.";
728       _LIBUNWIND_TRACE_UNWINDING(
729           "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR
730           ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
731           (void *)exception_object, frameInfo.start_ip, functionName,
732           frameInfo.lsda, frameInfo.handler);
733     }
734 #endif
735 
736     // Call stop function at each frame.
737     _Unwind_Action action =
738         (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
739     _Unwind_Reason_Code stopResult =
740         (*stop)(1, action, exception_object->exception_class, exception_object,
741                 (_Unwind_Context *)(cursor), stop_parameter);
742     _LIBUNWIND_TRACE_UNWINDING(
743         "unwind_phase2_forced(ex_ojb=%p): stop function returned %d",
744         (void *)exception_object, stopResult);
745     if (stopResult != _URC_NO_REASON) {
746       _LIBUNWIND_TRACE_UNWINDING(
747           "unwind_phase2_forced(ex_ojb=%p): stopped by stop function",
748           (void *)exception_object);
749       return _URC_FATAL_PHASE2_ERROR;
750     }
751 
752     // If there is a personality routine, tell it we are unwinding.
753     if (frameInfo.handler != 0) {
754       _Unwind_Personality_Fn p =
755           (_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler);
756       struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
757       // EHABI #7.2
758       exception_object->pr_cache.fnstart = frameInfo.start_ip;
759       exception_object->pr_cache.ehtp =
760           (_Unwind_EHT_Header *)frameInfo.unwind_info;
761       exception_object->pr_cache.additional = frameInfo.flags;
762       _Unwind_Reason_Code personalityResult =
763           (*p)(_US_FORCE_UNWIND | _US_UNWIND_FRAME_STARTING, exception_object,
764                context);
765       switch (personalityResult) {
766       case _URC_CONTINUE_UNWIND:
767         _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
768                                    "personality returned "
769                                    "_URC_CONTINUE_UNWIND",
770                                    (void *)exception_object);
771         // Destructors called, continue unwinding
772         break;
773       case _URC_INSTALL_CONTEXT:
774         _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
775                                    "personality returned "
776                                    "_URC_INSTALL_CONTEXT",
777                                    (void *)exception_object);
778         // We may get control back if landing pad calls _Unwind_Resume().
779         __unw_resume(cursor);
780         break;
781       case _URC_END_OF_STACK:
782         _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
783                                    "personality returned "
784                                    "_URC_END_OF_STACK",
785                                    (void *)exception_object);
786         // Personalty routine did the step and it can't step forward.
787         endOfStack = true;
788         break;
789       default:
790         // Personality routine returned an unknown result code.
791         _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
792                                    "personality returned %d, "
793                                    "_URC_FATAL_PHASE2_ERROR",
794                                    (void *)exception_object, personalityResult);
795         return _URC_FATAL_PHASE2_ERROR;
796       }
797     }
798   }
799 
800   // Call stop function one last time and tell it we've reached the end
801   // of the stack.
802   _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
803                              "function with _UA_END_OF_STACK",
804                              (void *)exception_object);
805   _Unwind_Action lastAction =
806       (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
807   (*stop)(1, lastAction, exception_object->exception_class, exception_object,
808           (struct _Unwind_Context *)(cursor), stop_parameter);
809 
810   // Clean up phase did not resume at the frame that the search phase said it
811   // would.
812   return _URC_FATAL_PHASE2_ERROR;
813 }
814 
815 /// Called by __cxa_throw.  Only returns if there is a fatal error.
816 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_RaiseException(_Unwind_Exception * exception_object)817 _Unwind_RaiseException(_Unwind_Exception *exception_object) {
818   _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
819                        static_cast<void *>(exception_object));
820   unw_context_t uc;
821   unw_cursor_t cursor;
822   __unw_getcontext(&uc);
823 
824   // This field for is for compatibility with GCC to say this isn't a forced
825   // unwind. EHABI #7.2
826   exception_object->unwinder_cache.reserved1 = 0;
827 
828   // phase 1: the search phase
829   _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object);
830   if (phase1 != _URC_NO_REASON)
831     return phase1;
832 
833   // phase 2: the clean up phase
834   return unwind_phase2(&uc, &cursor, exception_object, false);
835 }
836 
_Unwind_Complete(_Unwind_Exception * exception_object)837 _LIBUNWIND_EXPORT void _Unwind_Complete(_Unwind_Exception* exception_object) {
838   // This is to be called when exception handling completes to give us a chance
839   // to perform any housekeeping. EHABI #7.2. But we have nothing to do here.
840   (void)exception_object;
841 }
842 
843 /// When _Unwind_RaiseException() is in phase2, it hands control
844 /// to the personality function at each frame.  The personality
845 /// may force a jump to a landing pad in that function, the landing
846 /// pad code may then call _Unwind_Resume() to continue with the
847 /// unwinding.  Note: the call to _Unwind_Resume() is from compiler
848 /// generated user code.  All other _Unwind_* routines are called
849 /// by the C++ runtime __cxa_* routines.
850 ///
851 /// Note: re-throwing an exception (as opposed to continuing the unwind)
852 /// is implemented by having the code call __cxa_rethrow() which
853 /// in turn calls _Unwind_Resume_or_Rethrow().
854 _LIBUNWIND_EXPORT void
_Unwind_Resume(_Unwind_Exception * exception_object)855 _Unwind_Resume(_Unwind_Exception *exception_object) {
856   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)",
857                        static_cast<void *>(exception_object));
858   unw_context_t uc;
859   unw_cursor_t cursor;
860   __unw_getcontext(&uc);
861 
862   if (exception_object->unwinder_cache.reserved1)
863     unwind_phase2_forced(
864         &uc, &cursor, exception_object,
865         (_Unwind_Stop_Fn)exception_object->unwinder_cache.reserved1,
866         (void *)exception_object->unwinder_cache.reserved3);
867   else
868     unwind_phase2(&uc, &cursor, exception_object, true);
869 
870   // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
871   _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
872 }
873 
874 /// Called by personality handler during phase 2 to get LSDA for current frame.
875 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetLanguageSpecificData(struct _Unwind_Context * context)876 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
877   unw_cursor_t *cursor = (unw_cursor_t *)context;
878   unw_proc_info_t frameInfo;
879   uintptr_t result = 0;
880   if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
881     result = (uintptr_t)frameInfo.lsda;
882   _LIBUNWIND_TRACE_API(
883       "_Unwind_GetLanguageSpecificData(context=%p) => 0x%llx",
884       static_cast<void *>(context), (long long)result);
885   return result;
886 }
887 
ValueAsBitPattern(_Unwind_VRS_DataRepresentation representation,void * valuep)888 static uint64_t ValueAsBitPattern(_Unwind_VRS_DataRepresentation representation,
889                                   void* valuep) {
890   uint64_t value = 0;
891   switch (representation) {
892     case _UVRSD_UINT32:
893     case _UVRSD_FLOAT:
894       memcpy(&value, valuep, sizeof(uint32_t));
895       break;
896 
897     case _UVRSD_VFPX:
898     case _UVRSD_UINT64:
899     case _UVRSD_DOUBLE:
900       memcpy(&value, valuep, sizeof(uint64_t));
901       break;
902   }
903   return value;
904 }
905 
906 _LIBUNWIND_EXPORT _Unwind_VRS_Result
_Unwind_VRS_Set(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t regno,_Unwind_VRS_DataRepresentation representation,void * valuep)907 _Unwind_VRS_Set(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
908                 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
909                 void *valuep) {
910   _LIBUNWIND_TRACE_API("_Unwind_VRS_Set(context=%p, regclass=%d, reg=%d, "
911                        "rep=%d, value=0x%llX)",
912                        static_cast<void *>(context), regclass, regno,
913                        representation,
914                        ValueAsBitPattern(representation, valuep));
915   unw_cursor_t *cursor = (unw_cursor_t *)context;
916   switch (regclass) {
917     case _UVRSC_CORE:
918       if (representation != _UVRSD_UINT32 || regno > 15)
919         return _UVRSR_FAILED;
920       return __unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
921                            *(unw_word_t *)valuep) == UNW_ESUCCESS
922                  ? _UVRSR_OK
923                  : _UVRSR_FAILED;
924     case _UVRSC_VFP:
925       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
926         return _UVRSR_FAILED;
927       if (representation == _UVRSD_VFPX) {
928         // Can only touch d0-15 with FSTMFDX.
929         if (regno > 15)
930           return _UVRSR_FAILED;
931         __unw_save_vfp_as_X(cursor);
932       } else {
933         if (regno > 31)
934           return _UVRSR_FAILED;
935       }
936       return __unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
937                              *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
938                  ? _UVRSR_OK
939                  : _UVRSR_FAILED;
940 #if defined(__ARM_WMMX)
941     case _UVRSC_WMMXC:
942       if (representation != _UVRSD_UINT32 || regno > 3)
943         return _UVRSR_FAILED;
944       return __unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
945                            *(unw_word_t *)valuep) == UNW_ESUCCESS
946                  ? _UVRSR_OK
947                  : _UVRSR_FAILED;
948     case _UVRSC_WMMXD:
949       if (representation != _UVRSD_DOUBLE || regno > 31)
950         return _UVRSR_FAILED;
951       return __unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
952                              *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
953                  ? _UVRSR_OK
954                  : _UVRSR_FAILED;
955 #else
956     case _UVRSC_WMMXC:
957     case _UVRSC_WMMXD:
958       break;
959 #endif
960     case _UVRSC_PSEUDO:
961       // There's only one pseudo-register, PAC, with regno == 0.
962       if (representation != _UVRSD_UINT32 || regno != 0)
963         return _UVRSR_FAILED;
964       return __unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_RA_AUTH_CODE),
965                            *(unw_word_t *)valuep) == UNW_ESUCCESS
966                  ? _UVRSR_OK
967                  : _UVRSR_FAILED;
968       break;
969   }
970   _LIBUNWIND_ABORT("unsupported register class");
971 }
972 
973 static _Unwind_VRS_Result
_Unwind_VRS_Get_Internal(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t regno,_Unwind_VRS_DataRepresentation representation,void * valuep)974 _Unwind_VRS_Get_Internal(_Unwind_Context *context,
975                          _Unwind_VRS_RegClass regclass, uint32_t regno,
976                          _Unwind_VRS_DataRepresentation representation,
977                          void *valuep) {
978   unw_cursor_t *cursor = (unw_cursor_t *)context;
979   switch (regclass) {
980     case _UVRSC_CORE:
981       if (representation != _UVRSD_UINT32 || regno > 15)
982         return _UVRSR_FAILED;
983       return __unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
984                            (unw_word_t *)valuep) == UNW_ESUCCESS
985                  ? _UVRSR_OK
986                  : _UVRSR_FAILED;
987     case _UVRSC_VFP:
988       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
989         return _UVRSR_FAILED;
990       if (representation == _UVRSD_VFPX) {
991         // Can only touch d0-15 with FSTMFDX.
992         if (regno > 15)
993           return _UVRSR_FAILED;
994         __unw_save_vfp_as_X(cursor);
995       } else {
996         if (regno > 31)
997           return _UVRSR_FAILED;
998       }
999       return __unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
1000                              (unw_fpreg_t *)valuep) == UNW_ESUCCESS
1001                  ? _UVRSR_OK
1002                  : _UVRSR_FAILED;
1003 #if defined(__ARM_WMMX)
1004     case _UVRSC_WMMXC:
1005       if (representation != _UVRSD_UINT32 || regno > 3)
1006         return _UVRSR_FAILED;
1007       return __unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
1008                            (unw_word_t *)valuep) == UNW_ESUCCESS
1009                  ? _UVRSR_OK
1010                  : _UVRSR_FAILED;
1011     case _UVRSC_WMMXD:
1012       if (representation != _UVRSD_DOUBLE || regno > 31)
1013         return _UVRSR_FAILED;
1014       return __unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
1015                              (unw_fpreg_t *)valuep) == UNW_ESUCCESS
1016                  ? _UVRSR_OK
1017                  : _UVRSR_FAILED;
1018 #else
1019     case _UVRSC_WMMXC:
1020     case _UVRSC_WMMXD:
1021       break;
1022 #endif
1023     case _UVRSC_PSEUDO:
1024       // There's only one pseudo-register, PAC, with regno == 0.
1025       if (representation != _UVRSD_UINT32 || regno != 0)
1026         return _UVRSR_FAILED;
1027       return __unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_RA_AUTH_CODE),
1028                            (unw_word_t *)valuep) == UNW_ESUCCESS
1029                  ? _UVRSR_OK
1030                  : _UVRSR_FAILED;
1031       break;
1032   }
1033   _LIBUNWIND_ABORT("unsupported register class");
1034 }
1035 
1036 _LIBUNWIND_EXPORT _Unwind_VRS_Result
_Unwind_VRS_Get(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t regno,_Unwind_VRS_DataRepresentation representation,void * valuep)1037 _Unwind_VRS_Get(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
1038                 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
1039                 void *valuep) {
1040   _Unwind_VRS_Result result =
1041       _Unwind_VRS_Get_Internal(context, regclass, regno, representation,
1042                                valuep);
1043   _LIBUNWIND_TRACE_API("_Unwind_VRS_Get(context=%p, regclass=%d, reg=%d, "
1044                        "rep=%d, value=0x%llX, result = %d)",
1045                        static_cast<void *>(context), regclass, regno,
1046                        representation,
1047                        ValueAsBitPattern(representation, valuep), result);
1048   return result;
1049 }
1050 
1051 _Unwind_VRS_Result
_Unwind_VRS_Pop(_Unwind_Context * context,_Unwind_VRS_RegClass regclass,uint32_t discriminator,_Unwind_VRS_DataRepresentation representation)1052 _Unwind_VRS_Pop(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
1053                 uint32_t discriminator,
1054                 _Unwind_VRS_DataRepresentation representation) {
1055   _LIBUNWIND_TRACE_API("_Unwind_VRS_Pop(context=%p, regclass=%d, "
1056                        "discriminator=%d, representation=%d)",
1057                        static_cast<void *>(context), regclass, discriminator,
1058                        representation);
1059   switch (regclass) {
1060     case _UVRSC_WMMXC:
1061 #if !defined(__ARM_WMMX)
1062       break;
1063 #endif
1064     case _UVRSC_CORE: {
1065       if (representation != _UVRSD_UINT32)
1066         return _UVRSR_FAILED;
1067       // When popping SP from the stack, we don't want to override it from the
1068       // computed new stack location. See EHABI #7.5.4 table 3.
1069       bool poppedSP = false;
1070       uint32_t* sp;
1071       if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
1072                           _UVRSD_UINT32, &sp) != _UVRSR_OK) {
1073         return _UVRSR_FAILED;
1074       }
1075       for (uint32_t i = 0; i < 16; ++i) {
1076         if (!(discriminator & static_cast<uint32_t>(1 << i)))
1077           continue;
1078         uint32_t value = *sp++;
1079         if (regclass == _UVRSC_CORE && i == 13)
1080           poppedSP = true;
1081         if (_Unwind_VRS_Set(context, regclass, i,
1082                             _UVRSD_UINT32, &value) != _UVRSR_OK) {
1083           return _UVRSR_FAILED;
1084         }
1085       }
1086       if (!poppedSP) {
1087         return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP,
1088                                _UVRSD_UINT32, &sp);
1089       }
1090       return _UVRSR_OK;
1091     }
1092     case _UVRSC_WMMXD:
1093 #if !defined(__ARM_WMMX)
1094       break;
1095 #endif
1096     case _UVRSC_VFP: {
1097       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
1098         return _UVRSR_FAILED;
1099       uint32_t first = discriminator >> 16;
1100       uint32_t count = discriminator & 0xffff;
1101       uint32_t end = first+count;
1102       uint32_t* sp;
1103       if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
1104                           _UVRSD_UINT32, &sp) != _UVRSR_OK) {
1105         return _UVRSR_FAILED;
1106       }
1107       // For _UVRSD_VFPX, we're assuming the data is stored in FSTMX "standard
1108       // format 1", which is equivalent to FSTMD + a padding word.
1109       for (uint32_t i = first; i < end; ++i) {
1110         // SP is only 32-bit aligned so don't copy 64-bit at a time.
1111         uint64_t w0 = *sp++;
1112         uint64_t w1 = *sp++;
1113 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1114         uint64_t value = (w1 << 32) | w0;
1115 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1116         uint64_t value = (w0 << 32) | w1;
1117 #else
1118 #error "Unable to determine endianess"
1119 #endif
1120         if (_Unwind_VRS_Set(context, regclass, i, representation, &value) !=
1121             _UVRSR_OK)
1122           return _UVRSR_FAILED;
1123       }
1124       if (representation == _UVRSD_VFPX)
1125         ++sp;
1126       return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
1127                              &sp);
1128     }
1129     case _UVRSC_PSEUDO: {
1130       if (representation != _UVRSD_UINT32 || discriminator != 0)
1131         return _UVRSR_FAILED;
1132       // Return Address Authentication code (PAC) - discriminator 0
1133       uint32_t *sp;
1134       if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
1135                           &sp) != _UVRSR_OK) {
1136         return _UVRSR_FAILED;
1137       }
1138       uint32_t pac = *sp++;
1139       _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
1140       return _Unwind_VRS_Set(context, _UVRSC_PSEUDO, 0, _UVRSD_UINT32, &pac);
1141     }
1142   }
1143   _LIBUNWIND_ABORT("unsupported register class");
1144 }
1145 
1146 /// Not used by C++.
1147 /// Unwinds stack, calling "stop" function at each frame.
1148 /// Could be used to implement longjmp().
1149 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_ForcedUnwind(_Unwind_Exception * exception_object,_Unwind_Stop_Fn stop,void * stop_parameter)1150 _Unwind_ForcedUnwind(_Unwind_Exception *exception_object, _Unwind_Stop_Fn stop,
1151                      void *stop_parameter) {
1152   _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)",
1153                        (void *)exception_object, (void *)(uintptr_t)stop);
1154   unw_context_t uc;
1155   unw_cursor_t cursor;
1156   __unw_getcontext(&uc);
1157 
1158   // Mark that this is a forced unwind, so _Unwind_Resume() can do
1159   // the right thing.
1160   exception_object->unwinder_cache.reserved1 = (uintptr_t)stop;
1161   exception_object->unwinder_cache.reserved3 = (uintptr_t)stop_parameter;
1162 
1163   return unwind_phase2_forced(&uc, &cursor, exception_object, stop,
1164                               stop_parameter);
1165 }
1166 
1167 /// Called by personality handler during phase 2 to find the start of the
1168 /// function.
1169 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetRegionStart(struct _Unwind_Context * context)1170 _Unwind_GetRegionStart(struct _Unwind_Context *context) {
1171   unw_cursor_t *cursor = (unw_cursor_t *)context;
1172   unw_proc_info_t frameInfo;
1173   uintptr_t result = 0;
1174   if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
1175     result = (uintptr_t)frameInfo.start_ip;
1176   _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%llX",
1177                        static_cast<void *>(context), (long long)result);
1178   return result;
1179 }
1180 
1181 
1182 /// Called by personality handler during phase 2 if a foreign exception
1183 // is caught.
1184 _LIBUNWIND_EXPORT void
_Unwind_DeleteException(_Unwind_Exception * exception_object)1185 _Unwind_DeleteException(_Unwind_Exception *exception_object) {
1186   _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
1187                        static_cast<void *>(exception_object));
1188   if (exception_object->exception_cleanup != NULL)
1189     (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
1190                                            exception_object);
1191 }
1192 
1193 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
__gnu_unwind_frame(_Unwind_Exception * exception_object,struct _Unwind_Context * context)1194 __gnu_unwind_frame(_Unwind_Exception *exception_object,
1195                    struct _Unwind_Context *context) {
1196   (void)exception_object;
1197   unw_cursor_t *cursor = (unw_cursor_t *)context;
1198   switch (__unw_step(cursor)) {
1199   case UNW_STEP_SUCCESS:
1200     return _URC_OK;
1201   case UNW_STEP_END:
1202     return _URC_END_OF_STACK;
1203   default:
1204     return _URC_FAILURE;
1205   }
1206 }
1207 
1208 #endif  // defined(_LIBUNWIND_ARM_EHABI)
1209