• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===------------------------- cxa_exception.cpp --------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //
9 //  This file implements the "Exception Handling APIs"
10 //  http://mentorembedded.github.io/cxx-abi/abi-eh.html
11 //  http://www.intel.com/design/itanium/downloads/245358.htm
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include <assert.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <typeinfo>
19 
20 #include "__cxxabi_config.h"
21 #include "config.h"
22 #include "cxa_exception.hpp"
23 #include "cxa_handlers.hpp"
24 #include "private_typeinfo.h"
25 #include "unwind.h"
26 
27 /*
28     Exception Header Layout:
29 
30 +---------------------------+-----------------------------+---------------+
31 | __cxa_exception           | _Unwind_Exception CLNGC++\0 | thrown object |
32 +---------------------------+-----------------------------+---------------+
33                                                           ^
34                                                           |
35   +-------------------------------------------------------+
36   |
37 +---------------------------+-----------------------------+
38 | __cxa_dependent_exception | _Unwind_Exception CLNGC++\1 |
39 +---------------------------+-----------------------------+
40 
41     Exception Handling Table Layout:
42 
43 +-----------------+--------+
44 | lpStartEncoding | (char) |
45 +---------+-------+--------+---------------+-----------------------+
46 | lpStart | (encoded with lpStartEncoding) | defaults to funcStart |
47 +---------+-----+--------+-----------------+---------------+-------+
48 | ttypeEncoding | (char) | Encoding of the type_info table |
49 +---------------+-+------+----+----------------------------+----------------+
50 | classInfoOffset | (ULEB128) | Offset to type_info table, defaults to null |
51 +-----------------++--------+-+----------------------------+----------------+
52 | callSiteEncoding | (char) | Encoding for Call Site Table |
53 +------------------+--+-----+-----+------------------------+--------------------------+
54 | callSiteTableLength | (ULEB128) | Call Site Table length, used to find Action table |
55 +---------------------+-----------+---------------------------------------------------+
56 #ifndef __USING_SJLJ_EXCEPTIONS__
57 +---------------------+-----------+------------------------------------------------+
58 | Beginning of Call Site Table            The current ip lies within the           |
59 | ...                                     (start, length) range of one of these    |
60 |                                         call sites. There may be action needed.  |
61 | +-------------+---------------------------------+------------------------------+ |
62 | | start       | (encoded with callSiteEncoding) | offset relative to funcStart | |
63 | | length      | (encoded with callSiteEncoding) | length of code fragment      | |
64 | | landingPad  | (encoded with callSiteEncoding) | offset relative to lpStart   | |
65 | | actionEntry | (ULEB128)                       | Action Table Index 1-based   | |
66 | |             |                                 | actionEntry == 0 -> cleanup  | |
67 | +-------------+---------------------------------+------------------------------+ |
68 | ...                                                                              |
69 +----------------------------------------------------------------------------------+
70 #else  // __USING_SJLJ_EXCEPTIONS__
71 +---------------------+-----------+------------------------------------------------+
72 | Beginning of Call Site Table            The current ip is a 1-based index into   |
73 | ...                                     this table.  Or it is -1 meaning no      |
74 |                                         action is needed.  Or it is 0 meaning    |
75 |                                         terminate.                               |
76 | +-------------+---------------------------------+------------------------------+ |
77 | | landingPad  | (ULEB128)                       | offset relative to lpStart   | |
78 | | actionEntry | (ULEB128)                       | Action Table Index 1-based   | |
79 | |             |                                 | actionEntry == 0 -> cleanup  | |
80 | +-------------+---------------------------------+------------------------------+ |
81 | ...                                                                              |
82 +----------------------------------------------------------------------------------+
83 #endif  // __USING_SJLJ_EXCEPTIONS__
84 +---------------------------------------------------------------------+
85 | Beginning of Action Table       ttypeIndex == 0 : cleanup           |
86 | ...                             ttypeIndex  > 0 : catch             |
87 |                                 ttypeIndex  < 0 : exception spec    |
88 | +--------------+-----------+--------------------------------------+ |
89 | | ttypeIndex   | (SLEB128) | Index into type_info Table (1-based) | |
90 | | actionOffset | (SLEB128) | Offset into next Action Table entry  | |
91 | +--------------+-----------+--------------------------------------+ |
92 | ...                                                                 |
93 +---------------------------------------------------------------------+-----------------+
94 | type_info Table, but classInfoOffset does *not* point here!                           |
95 | +----------------+------------------------------------------------+-----------------+ |
96 | | Nth type_info* | Encoded with ttypeEncoding, 0 means catch(...) | ttypeIndex == N | |
97 | +----------------+------------------------------------------------+-----------------+ |
98 | ...                                                                                   |
99 | +----------------+------------------------------------------------+-----------------+ |
100 | | 1st type_info* | Encoded with ttypeEncoding, 0 means catch(...) | ttypeIndex == 1 | |
101 | +----------------+------------------------------------------------+-----------------+ |
102 | +---------------------------------------+-----------+------------------------------+  |
103 | | 1st ttypeIndex for 1st exception spec | (ULEB128) | classInfoOffset points here! |  |
104 | | ...                                   | (ULEB128) |                              |  |
105 | | Mth ttypeIndex for 1st exception spec | (ULEB128) |                              |  |
106 | | 0                                     | (ULEB128) |                              |  |
107 | +---------------------------------------+------------------------------------------+  |
108 | ...                                                                                   |
109 | +---------------------------------------+------------------------------------------+  |
110 | | 0                                     | (ULEB128) | throw()                      |  |
111 | +---------------------------------------+------------------------------------------+  |
112 | ...                                                                                   |
113 | +---------------------------------------+------------------------------------------+  |
114 | | 1st ttypeIndex for Nth exception spec | (ULEB128) |                              |  |
115 | | ...                                   | (ULEB128) |                              |  |
116 | | Mth ttypeIndex for Nth exception spec | (ULEB128) |                              |  |
117 | | 0                                     | (ULEB128) |                              |  |
118 | +---------------------------------------+------------------------------------------+  |
119 +---------------------------------------------------------------------------------------+
120 
121 Notes:
122 
123 *  ttypeIndex in the Action Table, and in the exception spec table, is an index,
124      not a byte count, if positive.  It is a negative index offset of
125      classInfoOffset and the sizeof entry depends on ttypeEncoding.
126    But if ttypeIndex is negative, it is a positive 1-based byte offset into the
127      type_info Table.
128    And if ttypeIndex is zero, it refers to a catch (...).
129 
130 *  landingPad can be 0, this implies there is nothing to be done.
131 
132 *  landingPad != 0 and actionEntry == 0 implies a cleanup needs to be done
133      @landingPad.
134 
135 *  A cleanup can also be found under landingPad != 0 and actionEntry != 0 in
136      the Action Table with ttypeIndex == 0.
137 */
138 
139 namespace __cxxabiv1
140 {
141 
142 namespace
143 {
144 
145 template <class AsType>
readPointerHelper(const uint8_t * & p)146 uintptr_t readPointerHelper(const uint8_t*& p) {
147     AsType value;
148     memcpy(&value, p, sizeof(AsType));
149     p += sizeof(AsType);
150     return static_cast<uintptr_t>(value);
151 }
152 
153 } // end namespace
154 
155 extern "C"
156 {
157 
158 // private API
159 
160 // Heavily borrowed from llvm/examples/ExceptionDemo/ExceptionDemo.cpp
161 
162 // DWARF Constants
163 enum
164 {
165     DW_EH_PE_absptr   = 0x00,
166     DW_EH_PE_uleb128  = 0x01,
167     DW_EH_PE_udata2   = 0x02,
168     DW_EH_PE_udata4   = 0x03,
169     DW_EH_PE_udata8   = 0x04,
170     DW_EH_PE_sleb128  = 0x09,
171     DW_EH_PE_sdata2   = 0x0A,
172     DW_EH_PE_sdata4   = 0x0B,
173     DW_EH_PE_sdata8   = 0x0C,
174     DW_EH_PE_pcrel    = 0x10,
175     DW_EH_PE_textrel  = 0x20,
176     DW_EH_PE_datarel  = 0x30,
177     DW_EH_PE_funcrel  = 0x40,
178     DW_EH_PE_aligned  = 0x50,
179     DW_EH_PE_indirect = 0x80,
180     DW_EH_PE_omit     = 0xFF
181 };
182 
183 /// Read a uleb128 encoded value and advance pointer
184 /// See Variable Length Data Appendix C in:
185 /// @link http://dwarfstd.org/Dwarf4.pdf @unlink
186 /// @param data reference variable holding memory pointer to decode from
187 /// @returns decoded value
188 static
189 uintptr_t
readULEB128(const uint8_t ** data)190 readULEB128(const uint8_t** data)
191 {
192     uintptr_t result = 0;
193     uintptr_t shift = 0;
194     unsigned char byte;
195     const uint8_t *p = *data;
196     do
197     {
198         byte = *p++;
199         result |= static_cast<uintptr_t>(byte & 0x7F) << shift;
200         shift += 7;
201     } while (byte & 0x80);
202     *data = p;
203     return result;
204 }
205 
206 /// Read a sleb128 encoded value and advance pointer
207 /// See Variable Length Data Appendix C in:
208 /// @link http://dwarfstd.org/Dwarf4.pdf @unlink
209 /// @param data reference variable holding memory pointer to decode from
210 /// @returns decoded value
211 static
212 intptr_t
readSLEB128(const uint8_t ** data)213 readSLEB128(const uint8_t** data)
214 {
215     uintptr_t result = 0;
216     uintptr_t shift = 0;
217     unsigned char byte;
218     const uint8_t *p = *data;
219     do
220     {
221         byte = *p++;
222         result |= static_cast<uintptr_t>(byte & 0x7F) << shift;
223         shift += 7;
224     } while (byte & 0x80);
225     *data = p;
226     if ((byte & 0x40) && (shift < (sizeof(result) << 3)))
227         result |= static_cast<uintptr_t>(~0) << shift;
228     return static_cast<intptr_t>(result);
229 }
230 
231 /// Read a pointer encoded value and advance pointer
232 /// See Variable Length Data in:
233 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
234 /// @param data reference variable holding memory pointer to decode from
235 /// @param encoding dwarf encoding type
236 /// @returns decoded value
237 static
238 uintptr_t
readEncodedPointer(const uint8_t ** data,uint8_t encoding)239 readEncodedPointer(const uint8_t** data, uint8_t encoding)
240 {
241     uintptr_t result = 0;
242     if (encoding == DW_EH_PE_omit)
243         return result;
244     const uint8_t* p = *data;
245     // first get value
246     switch (encoding & 0x0F)
247     {
248     case DW_EH_PE_absptr:
249         result = readPointerHelper<uintptr_t>(p);
250         break;
251     case DW_EH_PE_uleb128:
252         result = readULEB128(&p);
253         break;
254     case DW_EH_PE_sleb128:
255         result = static_cast<uintptr_t>(readSLEB128(&p));
256         break;
257     case DW_EH_PE_udata2:
258         result = readPointerHelper<uint16_t>(p);
259         break;
260     case DW_EH_PE_udata4:
261         result = readPointerHelper<uint32_t>(p);
262         break;
263     case DW_EH_PE_udata8:
264         result = readPointerHelper<uint64_t>(p);
265         break;
266     case DW_EH_PE_sdata2:
267         result = readPointerHelper<int16_t>(p);
268         break;
269     case DW_EH_PE_sdata4:
270         result = readPointerHelper<int32_t>(p);
271         break;
272     case DW_EH_PE_sdata8:
273         result = readPointerHelper<int64_t>(p);
274         break;
275     default:
276         // not supported
277         abort();
278         break;
279     }
280     // then add relative offset
281     switch (encoding & 0x70)
282     {
283     case DW_EH_PE_absptr:
284         // do nothing
285         break;
286     case DW_EH_PE_pcrel:
287         if (result)
288             result += (uintptr_t)(*data);
289         break;
290     case DW_EH_PE_textrel:
291     case DW_EH_PE_datarel:
292     case DW_EH_PE_funcrel:
293     case DW_EH_PE_aligned:
294     default:
295         // not supported
296         abort();
297         break;
298     }
299     // then apply indirection
300     if (result && (encoding & DW_EH_PE_indirect))
301         result = *((uintptr_t*)result);
302     *data = p;
303     return result;
304 }
305 
306 static
307 void
call_terminate(bool native_exception,_Unwind_Exception * unwind_exception)308 call_terminate(bool native_exception, _Unwind_Exception* unwind_exception)
309 {
310     __cxa_begin_catch(unwind_exception);
311     if (native_exception)
312     {
313         // Use the stored terminate_handler if possible
314         __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
315         std::__terminate(exception_header->terminateHandler);
316     }
317     std::terminate();
318 }
319 
320 #if LIBCXXABI_ARM_EHABI
read_target2_value(const void * ptr)321 static const void* read_target2_value(const void* ptr)
322 {
323     uintptr_t offset = *reinterpret_cast<const uintptr_t*>(ptr);
324     if (!offset)
325         return 0;
326     // "ARM EABI provides a TARGET2 relocation to describe these typeinfo
327     // pointers. The reason being it allows their precise semantics to be
328     // deferred to the linker. For bare-metal they turn into absolute
329     // relocations. For linux they turn into GOT-REL relocations."
330     // https://gcc.gnu.org/ml/gcc-patches/2009-08/msg00264.html
331 #if LIBCXXABI_BAREMETAL
332     return reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(ptr) +
333                                          offset);
334 #else
335     return *reinterpret_cast<const void **>(reinterpret_cast<uintptr_t>(ptr) +
336                                             offset);
337 #endif
338 }
339 
340 static const __shim_type_info*
get_shim_type_info(uint64_t ttypeIndex,const uint8_t * classInfo,uint8_t ttypeEncoding,bool native_exception,_Unwind_Exception * unwind_exception)341 get_shim_type_info(uint64_t ttypeIndex, const uint8_t* classInfo,
342                    uint8_t ttypeEncoding, bool native_exception,
343                    _Unwind_Exception* unwind_exception)
344 {
345     if (classInfo == 0)
346     {
347         // this should not happen.  Indicates corrupted eh_table.
348         call_terminate(native_exception, unwind_exception);
349     }
350 
351     assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
352             (ttypeEncoding == DW_EH_PE_pcrel) ||  // GCC 4.7 baremetal
353             (ttypeEncoding == (DW_EH_PE_pcrel | DW_EH_PE_indirect))) &&  // GCC 4.7 linux
354            "Unexpected TTypeEncoding");
355     (void)ttypeEncoding;
356 
357     const uint8_t* ttypePtr = classInfo - ttypeIndex * sizeof(uintptr_t);
358     return reinterpret_cast<const __shim_type_info *>(
359         read_target2_value(ttypePtr));
360 }
361 #else // !LIBCXXABI_ARM_EHABI
362 static
363 const __shim_type_info*
get_shim_type_info(uint64_t ttypeIndex,const uint8_t * classInfo,uint8_t ttypeEncoding,bool native_exception,_Unwind_Exception * unwind_exception)364 get_shim_type_info(uint64_t ttypeIndex, const uint8_t* classInfo,
365                    uint8_t ttypeEncoding, bool native_exception,
366                    _Unwind_Exception* unwind_exception)
367 {
368     if (classInfo == 0)
369     {
370         // this should not happen.  Indicates corrupted eh_table.
371         call_terminate(native_exception, unwind_exception);
372     }
373     switch (ttypeEncoding & 0x0F)
374     {
375     case DW_EH_PE_absptr:
376         ttypeIndex *= sizeof(void*);
377         break;
378     case DW_EH_PE_udata2:
379     case DW_EH_PE_sdata2:
380         ttypeIndex *= 2;
381         break;
382     case DW_EH_PE_udata4:
383     case DW_EH_PE_sdata4:
384         ttypeIndex *= 4;
385         break;
386     case DW_EH_PE_udata8:
387     case DW_EH_PE_sdata8:
388         ttypeIndex *= 8;
389         break;
390     default:
391         // this should not happen.   Indicates corrupted eh_table.
392         call_terminate(native_exception, unwind_exception);
393     }
394     classInfo -= ttypeIndex;
395     return (const __shim_type_info*)readEncodedPointer(&classInfo, ttypeEncoding);
396 }
397 #endif // !LIBCXXABI_ARM_EHABI
398 
399 /*
400     This is checking a thrown exception type, excpType, against a possibly empty
401     list of catchType's which make up an exception spec.
402 
403     An exception spec acts like a catch handler, but in reverse.  This "catch
404     handler" will catch an excpType if and only if none of the catchType's in
405     the list will catch a excpType.  If any catchType in the list can catch an
406     excpType, then this exception spec does not catch the excpType.
407 */
408 #if LIBCXXABI_ARM_EHABI
409 static
410 bool
exception_spec_can_catch(int64_t specIndex,const uint8_t * classInfo,uint8_t ttypeEncoding,const __shim_type_info * excpType,void * adjustedPtr,_Unwind_Exception * unwind_exception)411 exception_spec_can_catch(int64_t specIndex, const uint8_t* classInfo,
412                          uint8_t ttypeEncoding, const __shim_type_info* excpType,
413                          void* adjustedPtr, _Unwind_Exception* unwind_exception)
414 {
415     if (classInfo == 0)
416     {
417         // this should not happen.   Indicates corrupted eh_table.
418         call_terminate(false, unwind_exception);
419     }
420 
421     assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
422             (ttypeEncoding == DW_EH_PE_pcrel) ||  // GCC 4.7 baremetal
423             (ttypeEncoding == (DW_EH_PE_pcrel | DW_EH_PE_indirect))) &&  // GCC 4.7 linux
424            "Unexpected TTypeEncoding");
425     (void)ttypeEncoding;
426 
427     // specIndex is negative of 1-based byte offset into classInfo;
428     specIndex = -specIndex;
429     --specIndex;
430     const void** temp = reinterpret_cast<const void**>(
431         reinterpret_cast<uintptr_t>(classInfo) +
432         static_cast<uintptr_t>(specIndex) * sizeof(uintptr_t));
433     // If any type in the spec list can catch excpType, return false, else return true
434     //    adjustments to adjustedPtr are ignored.
435     while (true)
436     {
437         // ARM EHABI exception specification table (filter table) consists of
438         // several pointers which will directly point to the type info object
439         // (instead of ttypeIndex).  The table will be terminated with 0.
440         const void** ttypePtr = temp++;
441         if (*ttypePtr == 0)
442             break;
443         // We can get the __shim_type_info simply by performing a
444         // R_ARM_TARGET2 relocation, and cast the result to __shim_type_info.
445         const __shim_type_info* catchType =
446             static_cast<const __shim_type_info*>(read_target2_value(ttypePtr));
447         void* tempPtr = adjustedPtr;
448         if (catchType->can_catch(excpType, tempPtr))
449             return false;
450     }
451     return true;
452 }
453 #else
454 static
455 bool
exception_spec_can_catch(int64_t specIndex,const uint8_t * classInfo,uint8_t ttypeEncoding,const __shim_type_info * excpType,void * adjustedPtr,_Unwind_Exception * unwind_exception)456 exception_spec_can_catch(int64_t specIndex, const uint8_t* classInfo,
457                          uint8_t ttypeEncoding, const __shim_type_info* excpType,
458                          void* adjustedPtr, _Unwind_Exception* unwind_exception)
459 {
460     if (classInfo == 0)
461     {
462         // this should not happen.   Indicates corrupted eh_table.
463         call_terminate(false, unwind_exception);
464     }
465     // specIndex is negative of 1-based byte offset into classInfo;
466     specIndex = -specIndex;
467     --specIndex;
468     const uint8_t* temp = classInfo + specIndex;
469     // If any type in the spec list can catch excpType, return false, else return true
470     //    adjustments to adjustedPtr are ignored.
471     while (true)
472     {
473         uint64_t ttypeIndex = readULEB128(&temp);
474         if (ttypeIndex == 0)
475             break;
476         const __shim_type_info* catchType = get_shim_type_info(ttypeIndex,
477                                                                classInfo,
478                                                                ttypeEncoding,
479                                                                true,
480                                                                unwind_exception);
481         void* tempPtr = adjustedPtr;
482         if (catchType->can_catch(excpType, tempPtr))
483             return false;
484     }
485     return true;
486 }
487 #endif
488 
489 static
490 void*
get_thrown_object_ptr(_Unwind_Exception * unwind_exception)491 get_thrown_object_ptr(_Unwind_Exception* unwind_exception)
492 {
493     // Even for foreign exceptions, the exception object is *probably* at unwind_exception + 1
494     //    Regardless, this library is prohibited from touching a foreign exception
495     void* adjustedPtr = unwind_exception + 1;
496     if (unwind_exception->exception_class == kOurDependentExceptionClass)
497         adjustedPtr = ((__cxa_dependent_exception*)adjustedPtr - 1)->primaryException;
498     return adjustedPtr;
499 }
500 
501 namespace
502 {
503 
504 struct scan_results
505 {
506     int64_t        ttypeIndex;   // > 0 catch handler, < 0 exception spec handler, == 0 a cleanup
507     const uint8_t* actionRecord;         // Currently unused.  Retained to ease future maintenance.
508     const uint8_t* languageSpecificData;  // Needed only for __cxa_call_unexpected
509     uintptr_t      landingPad;   // null -> nothing found, else something found
510     void*          adjustedPtr;  // Used in cxa_exception.cpp
511     _Unwind_Reason_Code reason;  // One of _URC_FATAL_PHASE1_ERROR,
512                                  //        _URC_FATAL_PHASE2_ERROR,
513                                  //        _URC_CONTINUE_UNWIND,
514                                  //        _URC_HANDLER_FOUND
515 };
516 
517 }  // unnamed namespace
518 
519 static
520 void
set_registers(_Unwind_Exception * unwind_exception,_Unwind_Context * context,const scan_results & results)521 set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context,
522               const scan_results& results)
523 {
524 #if defined(__USING_SJLJ_EXCEPTIONS__)
525 #define __builtin_eh_return_data_regno(regno) regno
526 #endif
527   _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
528                 reinterpret_cast<uintptr_t>(unwind_exception));
529   _Unwind_SetGR(context, __builtin_eh_return_data_regno(1),
530                 static_cast<uintptr_t>(results.ttypeIndex));
531   _Unwind_SetIP(context, results.landingPad);
532 }
533 
534 /*
535     There are 3 types of scans needed:
536 
537     1.  Scan for handler with native or foreign exception.  If handler found,
538         save state and return _URC_HANDLER_FOUND, else return _URC_CONTINUE_UNWIND.
539         May also report an error on invalid input.
540         May terminate for invalid exception table.
541         _UA_SEARCH_PHASE
542 
543     2.  Scan for handler with foreign exception.  Must return _URC_HANDLER_FOUND,
544         or call terminate.
545         _UA_CLEANUP_PHASE && _UA_HANDLER_FRAME && !native_exception
546 
547     3.  Scan for cleanups.  If a handler is found and this isn't forced unwind,
548         then terminate, otherwise ignore the handler and keep looking for cleanup.
549         If a cleanup is found, return _URC_HANDLER_FOUND, else return _URC_CONTINUE_UNWIND.
550         May also report an error on invalid input.
551         May terminate for invalid exception table.
552         _UA_CLEANUP_PHASE && !_UA_HANDLER_FRAME
553 */
554 
scan_eh_tab(scan_results & results,_Unwind_Action actions,bool native_exception,_Unwind_Exception * unwind_exception,_Unwind_Context * context)555 static void scan_eh_tab(scan_results &results, _Unwind_Action actions,
556                         bool native_exception,
557                         _Unwind_Exception *unwind_exception,
558                         _Unwind_Context *context) {
559     // Initialize results to found nothing but an error
560     results.ttypeIndex = 0;
561     results.actionRecord = 0;
562     results.languageSpecificData = 0;
563     results.landingPad = 0;
564     results.adjustedPtr = 0;
565     results.reason = _URC_FATAL_PHASE1_ERROR;
566     // Check for consistent actions
567     if (actions & _UA_SEARCH_PHASE)
568     {
569         // Do Phase 1
570         if (actions & (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME | _UA_FORCE_UNWIND))
571         {
572             // None of these flags should be set during Phase 1
573             //   Client error
574             results.reason = _URC_FATAL_PHASE1_ERROR;
575             return;
576         }
577     }
578     else if (actions & _UA_CLEANUP_PHASE)
579     {
580         if ((actions & _UA_HANDLER_FRAME) && (actions & _UA_FORCE_UNWIND))
581         {
582             // _UA_HANDLER_FRAME should only be set if phase 1 found a handler.
583             // If _UA_FORCE_UNWIND is set, phase 1 shouldn't have happened.
584             //    Client error
585             results.reason = _URC_FATAL_PHASE2_ERROR;
586             return;
587         }
588     }
589     else // Neither _UA_SEARCH_PHASE nor _UA_CLEANUP_PHASE is set
590     {
591         // One of these should be set.
592         //   Client error
593         results.reason = _URC_FATAL_PHASE1_ERROR;
594         return;
595     }
596     // Start scan by getting exception table address
597     const uint8_t *lsda = (const uint8_t *)_Unwind_GetLanguageSpecificData(context);
598     if (lsda == 0)
599     {
600         // There is no exception table
601         results.reason = _URC_CONTINUE_UNWIND;
602         return;
603     }
604     results.languageSpecificData = lsda;
605     // Get the current instruction pointer and offset it before next
606     // instruction in the current frame which threw the exception.
607     uintptr_t ip = _Unwind_GetIP(context) - 1;
608     // Get beginning current frame's code (as defined by the
609     // emitted dwarf code)
610     uintptr_t funcStart = _Unwind_GetRegionStart(context);
611 #ifdef __USING_SJLJ_EXCEPTIONS__
612     if (ip == uintptr_t(-1))
613     {
614         // no action
615         results.reason = _URC_CONTINUE_UNWIND;
616         return;
617     }
618     else if (ip == 0)
619         call_terminate(native_exception, unwind_exception);
620     // ip is 1-based index into call site table
621 #else  // !__USING_SJLJ_EXCEPTIONS__
622     uintptr_t ipOffset = ip - funcStart;
623 #endif  // !defined(_USING_SLJL_EXCEPTIONS__)
624     const uint8_t* classInfo = NULL;
625     // Note: See JITDwarfEmitter::EmitExceptionTable(...) for corresponding
626     //       dwarf emission
627     // Parse LSDA header.
628     uint8_t lpStartEncoding = *lsda++;
629     const uint8_t* lpStart = (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
630     if (lpStart == 0)
631         lpStart = (const uint8_t*)funcStart;
632     uint8_t ttypeEncoding = *lsda++;
633     if (ttypeEncoding != DW_EH_PE_omit)
634     {
635         // Calculate type info locations in emitted dwarf code which
636         // were flagged by type info arguments to llvm.eh.selector
637         // intrinsic
638         uintptr_t classInfoOffset = readULEB128(&lsda);
639         classInfo = lsda + classInfoOffset;
640     }
641     // Walk call-site table looking for range that
642     // includes current PC.
643     uint8_t callSiteEncoding = *lsda++;
644 #ifdef __USING_SJLJ_EXCEPTIONS__
645     (void)callSiteEncoding;  // When using SjLj exceptions, callSiteEncoding is never used
646 #endif
647     uint32_t callSiteTableLength = static_cast<uint32_t>(readULEB128(&lsda));
648     const uint8_t* callSiteTableStart = lsda;
649     const uint8_t* callSiteTableEnd = callSiteTableStart + callSiteTableLength;
650     const uint8_t* actionTableStart = callSiteTableEnd;
651     const uint8_t* callSitePtr = callSiteTableStart;
652     while (callSitePtr < callSiteTableEnd)
653     {
654         // There is one entry per call site.
655 #ifndef __USING_SJLJ_EXCEPTIONS__
656         // The call sites are non-overlapping in [start, start+length)
657         // The call sites are ordered in increasing value of start
658         uintptr_t start = readEncodedPointer(&callSitePtr, callSiteEncoding);
659         uintptr_t length = readEncodedPointer(&callSitePtr, callSiteEncoding);
660         uintptr_t landingPad = readEncodedPointer(&callSitePtr, callSiteEncoding);
661         uintptr_t actionEntry = readULEB128(&callSitePtr);
662         if ((start <= ipOffset) && (ipOffset < (start + length)))
663 #else  // __USING_SJLJ_EXCEPTIONS__
664         // ip is 1-based index into this table
665         uintptr_t landingPad = readULEB128(&callSitePtr);
666         uintptr_t actionEntry = readULEB128(&callSitePtr);
667         if (--ip == 0)
668 #endif  // __USING_SJLJ_EXCEPTIONS__
669         {
670             // Found the call site containing ip.
671 #ifndef __USING_SJLJ_EXCEPTIONS__
672             if (landingPad == 0)
673             {
674                 // No handler here
675                 results.reason = _URC_CONTINUE_UNWIND;
676                 return;
677             }
678             landingPad = (uintptr_t)lpStart + landingPad;
679 #else  // __USING_SJLJ_EXCEPTIONS__
680             ++landingPad;
681 #endif  // __USING_SJLJ_EXCEPTIONS__
682             if (actionEntry == 0)
683             {
684                 // Found a cleanup
685                 // If this is a type 1 or type 2 search, there are no handlers
686                 // If this is a type 3 search, you want to install the cleanup.
687                 if ((actions & _UA_CLEANUP_PHASE) && !(actions & _UA_HANDLER_FRAME))
688                 {
689                     results.ttypeIndex = 0;  // Redundant but clarifying
690                     results.landingPad = landingPad;
691                     results.reason = _URC_HANDLER_FOUND;
692                     return;
693                 }
694                 // No handler here
695                 results.reason = _URC_CONTINUE_UNWIND;
696                 return;
697             }
698             // Convert 1-based byte offset into
699             const uint8_t* action = actionTableStart + (actionEntry - 1);
700             // Scan action entries until you find a matching handler, cleanup, or the end of action list
701             while (true)
702             {
703                 const uint8_t* actionRecord = action;
704                 int64_t ttypeIndex = readSLEB128(&action);
705                 if (ttypeIndex > 0)
706                 {
707                     // Found a catch, does it actually catch?
708                     // First check for catch (...)
709                     const __shim_type_info* catchType =
710                         get_shim_type_info(static_cast<uint64_t>(ttypeIndex),
711                                            classInfo, ttypeEncoding,
712                                            native_exception, unwind_exception);
713                     if (catchType == 0)
714                     {
715                         // Found catch (...) catches everything, including foreign exceptions
716                         // If this is a type 1 search save state and return _URC_HANDLER_FOUND
717                         // If this is a type 2 search save state and return _URC_HANDLER_FOUND
718                         // If this is a type 3 search !_UA_FORCE_UNWIND, we should have found this in phase 1!
719                         // If this is a type 3 search _UA_FORCE_UNWIND, ignore handler and continue scan
720                         if ((actions & _UA_SEARCH_PHASE) || (actions & _UA_HANDLER_FRAME))
721                         {
722                             // Save state and return _URC_HANDLER_FOUND
723                             results.ttypeIndex = ttypeIndex;
724                             results.actionRecord = actionRecord;
725                             results.landingPad = landingPad;
726                             results.adjustedPtr = get_thrown_object_ptr(unwind_exception);
727                             results.reason = _URC_HANDLER_FOUND;
728                             return;
729                         }
730                         else if (!(actions & _UA_FORCE_UNWIND))
731                         {
732                             // It looks like the exception table has changed
733                             //    on us.  Likely stack corruption!
734                             call_terminate(native_exception, unwind_exception);
735                         }
736                     }
737                     // Else this is a catch (T) clause and will never
738                     //    catch a foreign exception
739                     else if (native_exception)
740                     {
741                         __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
742                         void* adjustedPtr = get_thrown_object_ptr(unwind_exception);
743                         const __shim_type_info* excpType =
744                             static_cast<const __shim_type_info*>(exception_header->exceptionType);
745                         if (adjustedPtr == 0 || excpType == 0)
746                         {
747                             // Something very bad happened
748                             call_terminate(native_exception, unwind_exception);
749                         }
750                         if (catchType->can_catch(excpType, adjustedPtr))
751                         {
752                             // Found a matching handler
753                             // If this is a type 1 search save state and return _URC_HANDLER_FOUND
754                             // If this is a type 3 search and !_UA_FORCE_UNWIND, we should have found this in phase 1!
755                             // If this is a type 3 search and _UA_FORCE_UNWIND, ignore handler and continue scan
756                             if (actions & _UA_SEARCH_PHASE)
757                             {
758                                 // Save state and return _URC_HANDLER_FOUND
759                                 results.ttypeIndex = ttypeIndex;
760                                 results.actionRecord = actionRecord;
761                                 results.landingPad = landingPad;
762                                 results.adjustedPtr = adjustedPtr;
763                                 results.reason = _URC_HANDLER_FOUND;
764                                 return;
765                             }
766                             else if (!(actions & _UA_FORCE_UNWIND))
767                             {
768                                 // It looks like the exception table has changed
769                                 //    on us.  Likely stack corruption!
770                                 call_terminate(native_exception, unwind_exception);
771                             }
772                         }
773                     }
774                     // Scan next action ...
775                 }
776                 else if (ttypeIndex < 0)
777                 {
778                     // Found an exception spec.  If this is a foreign exception,
779                     //   it is always caught.
780                     if (native_exception)
781                     {
782                         // Does the exception spec catch this native exception?
783                         __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
784                         void* adjustedPtr = get_thrown_object_ptr(unwind_exception);
785                         const __shim_type_info* excpType =
786                             static_cast<const __shim_type_info*>(exception_header->exceptionType);
787                         if (adjustedPtr == 0 || excpType == 0)
788                         {
789                             // Something very bad happened
790                             call_terminate(native_exception, unwind_exception);
791                         }
792                         if (exception_spec_can_catch(ttypeIndex, classInfo,
793                                                      ttypeEncoding, excpType,
794                                                      adjustedPtr, unwind_exception))
795                         {
796                             // native exception caught by exception spec
797                             // If this is a type 1 search, save state and return _URC_HANDLER_FOUND
798                             // If this is a type 3 search !_UA_FORCE_UNWIND, we should have found this in phase 1!
799                             // If this is a type 3 search _UA_FORCE_UNWIND, ignore handler and continue scan
800                             if (actions & _UA_SEARCH_PHASE)
801                             {
802                                 // Save state and return _URC_HANDLER_FOUND
803                                 results.ttypeIndex = ttypeIndex;
804                                 results.actionRecord = actionRecord;
805                                 results.landingPad = landingPad;
806                                 results.adjustedPtr = adjustedPtr;
807                                 results.reason = _URC_HANDLER_FOUND;
808                                 return;
809                             }
810                             else if (!(actions & _UA_FORCE_UNWIND))
811                             {
812                                 // It looks like the exception table has changed
813                                 //    on us.  Likely stack corruption!
814                                 call_terminate(native_exception, unwind_exception);
815                             }
816                         }
817                     }
818                     else
819                     {
820                         // foreign exception caught by exception spec
821                         // If this is a type 1 search, save state and return _URC_HANDLER_FOUND
822                         // If this is a type 2 search, save state and return _URC_HANDLER_FOUND
823                         // If this is a type 3 search !_UA_FORCE_UNWIND, we should have found this in phase 1!
824                         // If this is a type 3 search _UA_FORCE_UNWIND, ignore handler and continue scan
825                         if ((actions & _UA_SEARCH_PHASE) || (actions & _UA_HANDLER_FRAME))
826                         {
827                             // Save state and return _URC_HANDLER_FOUND
828                             results.ttypeIndex = ttypeIndex;
829                             results.actionRecord = actionRecord;
830                             results.landingPad = landingPad;
831                             results.adjustedPtr = get_thrown_object_ptr(unwind_exception);
832                             results.reason = _URC_HANDLER_FOUND;
833                             return;
834                         }
835                         else if (!(actions & _UA_FORCE_UNWIND))
836                         {
837                             // It looks like the exception table has changed
838                             //    on us.  Likely stack corruption!
839                             call_terminate(native_exception, unwind_exception);
840                         }
841                     }
842                     // Scan next action ...
843                 }
844                 else  // ttypeIndex == 0
845                 {
846                     // Found a cleanup
847                     // If this is a type 1 search, ignore it and continue scan
848                     // If this is a type 2 search, ignore it and continue scan
849                     // If this is a type 3 search, save state and return _URC_HANDLER_FOUND
850                     if ((actions & _UA_CLEANUP_PHASE) && !(actions & _UA_HANDLER_FRAME))
851                     {
852                         // Save state and return _URC_HANDLER_FOUND
853                         results.ttypeIndex = ttypeIndex;
854                         results.actionRecord = actionRecord;
855                         results.landingPad = landingPad;
856                         results.adjustedPtr = get_thrown_object_ptr(unwind_exception);
857                         results.reason = _URC_HANDLER_FOUND;
858                         return;
859                     }
860                 }
861                 const uint8_t* temp = action;
862                 int64_t actionOffset = readSLEB128(&temp);
863                 if (actionOffset == 0)
864                 {
865                     // End of action list, no matching handler or cleanup found
866                     results.reason = _URC_CONTINUE_UNWIND;
867                     return;
868                 }
869                 // Go to next action
870                 action += actionOffset;
871             }  // there is no break out of this loop, only return
872         }
873 #ifndef __USING_SJLJ_EXCEPTIONS__
874         else if (ipOffset < start)
875         {
876             // There is no call site for this ip
877             // Something bad has happened.  We should never get here.
878             // Possible stack corruption.
879             call_terminate(native_exception, unwind_exception);
880         }
881 #endif  // !__USING_SJLJ_EXCEPTIONS__
882     }  // there might be some tricky cases which break out of this loop
883 
884     // It is possible that no eh table entry specify how to handle
885     // this exception. By spec, terminate it immediately.
886     call_terminate(native_exception, unwind_exception);
887 }
888 
889 // public API
890 
891 /*
892 The personality function branches on actions like so:
893 
894 _UA_SEARCH_PHASE
895 
896     If _UA_CLEANUP_PHASE or _UA_HANDLER_FRAME or _UA_FORCE_UNWIND there's
897       an error from above, return _URC_FATAL_PHASE1_ERROR.
898 
899     Scan for anything that could stop unwinding:
900 
901        1.  A catch clause that will catch this exception
902            (will never catch foreign).
903        2.  A catch (...) (will always catch foreign).
904        3.  An exception spec that will catch this exception
905            (will always catch foreign).
906     If a handler is found
907         If not foreign
908             Save state in header
909         return _URC_HANDLER_FOUND
910     Else a handler not found
911         return _URC_CONTINUE_UNWIND
912 
913 _UA_CLEANUP_PHASE
914 
915     If _UA_HANDLER_FRAME
916         If _UA_FORCE_UNWIND
917             How did this happen?  return _URC_FATAL_PHASE2_ERROR
918         If foreign
919             Do _UA_SEARCH_PHASE to recover state
920         else
921             Recover state from header
922         Transfer control to landing pad.  return _URC_INSTALL_CONTEXT
923 
924     Else
925 
926         This branch handles both normal C++ non-catching handlers (cleanups)
927           and forced unwinding.
928         Scan for anything that can not stop unwinding:
929 
930             1.  A cleanup.
931 
932         If a cleanup is found
933             transfer control to it. return _URC_INSTALL_CONTEXT
934         Else a cleanup is not found: return _URC_CONTINUE_UNWIND
935 */
936 
937 #if !LIBCXXABI_ARM_EHABI
938 _LIBCXXABI_FUNC_VIS _Unwind_Reason_Code
939 #ifdef __USING_SJLJ_EXCEPTIONS__
__gxx_personality_sj0(int version,_Unwind_Action actions,uint64_t exceptionClass,_Unwind_Exception * unwind_exception,_Unwind_Context * context)940 __gxx_personality_sj0
941 #else
942 __gxx_personality_v0
943 #endif
944                     (int version, _Unwind_Action actions, uint64_t exceptionClass,
945                      _Unwind_Exception* unwind_exception, _Unwind_Context* context)
946 {
947     if (version != 1 || unwind_exception == 0 || context == 0)
948         return _URC_FATAL_PHASE1_ERROR;
949 
950     bool native_exception = (exceptionClass     & get_vendor_and_language) ==
951                             (kOurExceptionClass & get_vendor_and_language);
952     scan_results results;
953     if (actions & _UA_SEARCH_PHASE)
954     {
955         // Phase 1 search:  All we're looking for in phase 1 is a handler that
956         //   halts unwinding
957         scan_eh_tab(results, actions, native_exception, unwind_exception, context);
958         if (results.reason == _URC_HANDLER_FOUND)
959         {
960             // Found one.  Can we cache the results somewhere to optimize phase 2?
961             if (native_exception)
962             {
963                 __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
964                 exception_header->handlerSwitchValue = static_cast<int>(results.ttypeIndex);
965                 exception_header->actionRecord = results.actionRecord;
966                 exception_header->languageSpecificData = results.languageSpecificData;
967                 exception_header->catchTemp = reinterpret_cast<void*>(results.landingPad);
968                 exception_header->adjustedPtr = results.adjustedPtr;
969             }
970             return _URC_HANDLER_FOUND;
971         }
972         // Did not find a catching-handler.  Return the results of the scan
973         //    (normally _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE1_ERROR
974         //     if we were called improperly).
975         return results.reason;
976     }
977     if (actions & _UA_CLEANUP_PHASE)
978     {
979         // Phase 2 search:
980         //  Did we find a catching handler in phase 1?
981         if (actions & _UA_HANDLER_FRAME)
982         {
983             // Yes, phase 1 said we have a catching handler here.
984             // Did we cache the results of the scan?
985             if (native_exception)
986             {
987                 // Yes, reload the results from the cache.
988                 __cxa_exception* exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
989                 results.ttypeIndex = exception_header->handlerSwitchValue;
990                 results.actionRecord = exception_header->actionRecord;
991                 results.languageSpecificData = exception_header->languageSpecificData;
992                 results.landingPad = reinterpret_cast<uintptr_t>(exception_header->catchTemp);
993                 results.adjustedPtr = exception_header->adjustedPtr;
994             }
995             else
996             {
997                 // No, do the scan again to reload the results.
998                 scan_eh_tab(results, actions, native_exception, unwind_exception, context);
999                 // Phase 1 told us we would find a handler.  Now in Phase 2 we
1000                 //   didn't find a handler.  The eh table should not be changing!
1001                 if (results.reason != _URC_HANDLER_FOUND)
1002                     call_terminate(native_exception, unwind_exception);
1003             }
1004             // Jump to the handler
1005             set_registers(unwind_exception, context, results);
1006             return _URC_INSTALL_CONTEXT;
1007         }
1008         // Either we didn't do a phase 1 search (due to forced unwinding), or
1009         //   phase 1 reported no catching-handlers.
1010         // Search for a (non-catching) cleanup
1011         scan_eh_tab(results, actions, native_exception, unwind_exception, context);
1012         if (results.reason == _URC_HANDLER_FOUND)
1013         {
1014             // Found a non-catching handler.  Jump to it:
1015             set_registers(unwind_exception, context, results);
1016             return _URC_INSTALL_CONTEXT;
1017         }
1018         // Did not find a cleanup.  Return the results of the scan
1019         //    (normally _URC_CONTINUE_UNWIND, but could have been _URC_FATAL_PHASE2_ERROR
1020         //     if we were called improperly).
1021         return results.reason;
1022     }
1023     // We were called improperly: neither a phase 1 or phase 2 search
1024     return _URC_FATAL_PHASE1_ERROR;
1025 }
1026 #else
1027 
1028 extern "C" _Unwind_Reason_Code __gnu_unwind_frame(_Unwind_Exception*,
1029                                                   _Unwind_Context*);
1030 
1031 // Helper function to unwind one frame.
1032 // ARM EHABI 7.3 and 7.4: If the personality function returns _URC_CONTINUE_UNWIND, the
1033 // personality routine should update the virtual register set (VRS) according to the
1034 // corresponding frame unwinding instructions (ARM EHABI 9.3.)
continue_unwind(_Unwind_Exception * unwind_exception,_Unwind_Context * context)1035 static _Unwind_Reason_Code continue_unwind(_Unwind_Exception* unwind_exception,
1036                                            _Unwind_Context* context)
1037 {
1038     if (__gnu_unwind_frame(unwind_exception, context) != _URC_OK)
1039         return _URC_FAILURE;
1040     return _URC_CONTINUE_UNWIND;
1041 }
1042 
1043 // ARM register names
1044 #if !defined(LIBCXXABI_USE_LLVM_UNWINDER)
1045 static const uint32_t REG_UCB = 12;  // Register to save _Unwind_Control_Block
1046 #endif
1047 static const uint32_t REG_SP = 13;
1048 
save_results_to_barrier_cache(_Unwind_Exception * unwind_exception,const scan_results & results)1049 static void save_results_to_barrier_cache(_Unwind_Exception* unwind_exception,
1050                                           const scan_results& results)
1051 {
1052     unwind_exception->barrier_cache.bitpattern[0] = (uint32_t)results.adjustedPtr;
1053     unwind_exception->barrier_cache.bitpattern[1] = (uint32_t)results.actionRecord;
1054     unwind_exception->barrier_cache.bitpattern[2] = (uint32_t)results.languageSpecificData;
1055     unwind_exception->barrier_cache.bitpattern[3] = (uint32_t)results.landingPad;
1056     unwind_exception->barrier_cache.bitpattern[4] = (uint32_t)results.ttypeIndex;
1057 }
1058 
load_results_from_barrier_cache(scan_results & results,const _Unwind_Exception * unwind_exception)1059 static void load_results_from_barrier_cache(scan_results& results,
1060                                             const _Unwind_Exception* unwind_exception)
1061 {
1062     results.adjustedPtr = (void*)unwind_exception->barrier_cache.bitpattern[0];
1063     results.actionRecord = (const uint8_t*)unwind_exception->barrier_cache.bitpattern[1];
1064     results.languageSpecificData = (const uint8_t*)unwind_exception->barrier_cache.bitpattern[2];
1065     results.landingPad = (uintptr_t)unwind_exception->barrier_cache.bitpattern[3];
1066     results.ttypeIndex = (int64_t)(int32_t)unwind_exception->barrier_cache.bitpattern[4];
1067 }
1068 
1069 extern "C" _LIBCXXABI_FUNC_VIS _Unwind_Reason_Code
__gxx_personality_v0(_Unwind_State state,_Unwind_Exception * unwind_exception,_Unwind_Context * context)1070 __gxx_personality_v0(_Unwind_State state,
1071                      _Unwind_Exception* unwind_exception,
1072                      _Unwind_Context* context)
1073 {
1074     if (unwind_exception == 0 || context == 0)
1075         return _URC_FATAL_PHASE1_ERROR;
1076 
1077     bool native_exception = (unwind_exception->exception_class & get_vendor_and_language) ==
1078                             (kOurExceptionClass & get_vendor_and_language);
1079 
1080 #if !defined(LIBCXXABI_USE_LLVM_UNWINDER)
1081     // Copy the address of _Unwind_Control_Block to r12 so that
1082     // _Unwind_GetLanguageSpecificData() and _Unwind_GetRegionStart() can
1083     // return correct address.
1084     _Unwind_SetGR(context, REG_UCB, reinterpret_cast<uint32_t>(unwind_exception));
1085 #endif
1086 
1087     // Check the undocumented force unwinding behavior
1088     bool is_force_unwinding = state & _US_FORCE_UNWIND;
1089     state &= ~_US_FORCE_UNWIND;
1090 
1091     scan_results results;
1092     switch (state) {
1093     case _US_VIRTUAL_UNWIND_FRAME:
1094         if (is_force_unwinding)
1095             return continue_unwind(unwind_exception, context);
1096 
1097         // Phase 1 search:  All we're looking for in phase 1 is a handler that halts unwinding
1098         scan_eh_tab(results, _UA_SEARCH_PHASE, native_exception, unwind_exception, context);
1099         if (results.reason == _URC_HANDLER_FOUND)
1100         {
1101             unwind_exception->barrier_cache.sp = _Unwind_GetGR(context, REG_SP);
1102             if (native_exception)
1103                 save_results_to_barrier_cache(unwind_exception, results);
1104             return _URC_HANDLER_FOUND;
1105         }
1106         // Did not find the catch handler
1107         if (results.reason == _URC_CONTINUE_UNWIND)
1108             return continue_unwind(unwind_exception, context);
1109         return results.reason;
1110 
1111     case _US_UNWIND_FRAME_STARTING:
1112         // TODO: Support force unwinding in the phase 2 search.
1113         // NOTE: In order to call the cleanup functions, _Unwind_ForcedUnwind()
1114         // will call this personality function with (_US_FORCE_UNWIND |
1115         // _US_UNWIND_FRAME_STARTING).
1116 
1117         // Phase 2 search
1118         if (unwind_exception->barrier_cache.sp == _Unwind_GetGR(context, REG_SP))
1119         {
1120             // Found a catching handler in phase 1
1121             if (native_exception)
1122             {
1123                 // Load the result from the native exception barrier cache.
1124                 load_results_from_barrier_cache(results, unwind_exception);
1125                 results.reason = _URC_HANDLER_FOUND;
1126             }
1127             else
1128             {
1129                 // Search for the catching handler again for the foreign exception.
1130                 scan_eh_tab(results, static_cast<_Unwind_Action>(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME),
1131                             native_exception, unwind_exception, context);
1132                 if (results.reason != _URC_HANDLER_FOUND)  // phase1 search should guarantee to find one
1133                     call_terminate(native_exception, unwind_exception);
1134             }
1135 
1136             // Install the context for the catching handler
1137             set_registers(unwind_exception, context, results);
1138             return _URC_INSTALL_CONTEXT;
1139         }
1140 
1141         // Either we didn't do a phase 1 search (due to forced unwinding), or
1142         //  phase 1 reported no catching-handlers.
1143         // Search for a (non-catching) cleanup
1144         scan_eh_tab(results, _UA_CLEANUP_PHASE, native_exception, unwind_exception, context);
1145         if (results.reason == _URC_HANDLER_FOUND)
1146         {
1147             // Found a non-catching handler
1148 
1149             // ARM EHABI 8.4.2: Before we can jump to the cleanup handler, we have to setup some
1150             // internal data structures, so that __cxa_end_cleanup() can get unwind_exception from
1151             // __cxa_get_globals().
1152             __cxa_begin_cleanup(unwind_exception);
1153 
1154             // Install the context for the cleanup handler
1155             set_registers(unwind_exception, context, results);
1156             return _URC_INSTALL_CONTEXT;
1157         }
1158 
1159         // Did not find any handler
1160         if (results.reason == _URC_CONTINUE_UNWIND)
1161             return continue_unwind(unwind_exception, context);
1162         return results.reason;
1163 
1164     case _US_UNWIND_FRAME_RESUME:
1165         return continue_unwind(unwind_exception, context);
1166     }
1167 
1168     // We were called improperly: neither a phase 1 or phase 2 search
1169     return _URC_FATAL_PHASE1_ERROR;
1170 }
1171 #endif
1172 
1173 
1174 __attribute__((noreturn))
1175 _LIBCXXABI_FUNC_VIS void
__cxa_call_unexpected(void * arg)1176 __cxa_call_unexpected(void* arg)
1177 {
1178     _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(arg);
1179     if (unwind_exception == 0)
1180         call_terminate(false, unwind_exception);
1181     __cxa_begin_catch(unwind_exception);
1182     bool native_old_exception =
1183         (unwind_exception->exception_class & get_vendor_and_language) ==
1184         (kOurExceptionClass                & get_vendor_and_language);
1185     std::unexpected_handler u_handler;
1186     std::terminate_handler t_handler;
1187     __cxa_exception* old_exception_header = 0;
1188     int64_t ttypeIndex;
1189     const uint8_t* lsda;
1190     if (native_old_exception)
1191     {
1192         old_exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
1193         t_handler = old_exception_header->terminateHandler;
1194         u_handler = old_exception_header->unexpectedHandler;
1195         // If std::__unexpected(u_handler) rethrows the same exception,
1196         //   these values get overwritten by the rethrow.  So save them now:
1197 #if LIBCXXABI_ARM_EHABI
1198         ttypeIndex = (int64_t)(int32_t)unwind_exception->barrier_cache.bitpattern[4];
1199         lsda = (const uint8_t*)unwind_exception->barrier_cache.bitpattern[2];
1200 #else
1201         ttypeIndex = old_exception_header->handlerSwitchValue;
1202         lsda = old_exception_header->languageSpecificData;
1203 #endif
1204     }
1205     else
1206     {
1207         t_handler = std::get_terminate();
1208         u_handler = std::get_unexpected();
1209     }
1210     try
1211     {
1212         std::__unexpected(u_handler);
1213     }
1214     catch (...)
1215     {
1216         // If the old exception is foreign, then all we can do is terminate.
1217         //   We have no way to recover the needed old exception spec.  There's
1218         //   no way to pass that information here.  And the personality routine
1219         //   can't call us directly and do anything but terminate() if we throw
1220         //   from here.
1221         if (native_old_exception)
1222         {
1223             // Have:
1224             //   old_exception_header->languageSpecificData
1225             //   old_exception_header->actionRecord
1226             // Need
1227             //   const uint8_t* classInfo
1228             //   uint8_t ttypeEncoding
1229             uint8_t lpStartEncoding = *lsda++;
1230             const uint8_t* lpStart = (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
1231             (void)lpStart;  // purposefully unused.  Just needed to increment lsda.
1232             uint8_t ttypeEncoding = *lsda++;
1233             if (ttypeEncoding == DW_EH_PE_omit)
1234                 std::__terminate(t_handler);
1235             uintptr_t classInfoOffset = readULEB128(&lsda);
1236             const uint8_t* classInfo = lsda + classInfoOffset;
1237             // Is this new exception catchable by the exception spec at ttypeIndex?
1238             // The answer is obviously yes if the new and old exceptions are the same exception
1239             // If no
1240             //    throw;
1241             __cxa_eh_globals* globals = __cxa_get_globals_fast();
1242             __cxa_exception* new_exception_header = globals->caughtExceptions;
1243             if (new_exception_header == 0)
1244                 // This shouldn't be able to happen!
1245                 std::__terminate(t_handler);
1246             bool native_new_exception =
1247                 (new_exception_header->unwindHeader.exception_class & get_vendor_and_language) ==
1248                                                 (kOurExceptionClass & get_vendor_and_language);
1249             void* adjustedPtr;
1250             if (native_new_exception && (new_exception_header != old_exception_header))
1251             {
1252                 const __shim_type_info* excpType =
1253                     static_cast<const __shim_type_info*>(new_exception_header->exceptionType);
1254                 adjustedPtr =
1255                     new_exception_header->unwindHeader.exception_class == kOurDependentExceptionClass ?
1256                         ((__cxa_dependent_exception*)new_exception_header)->primaryException :
1257                         new_exception_header + 1;
1258                 if (!exception_spec_can_catch(ttypeIndex, classInfo, ttypeEncoding,
1259                                               excpType, adjustedPtr, unwind_exception))
1260                 {
1261                     // We need to __cxa_end_catch, but for the old exception,
1262                     //   not the new one.  This is a little tricky ...
1263                     // Disguise new_exception_header as a rethrown exception, but
1264                     //   don't actually rethrow it.  This means you can temporarily
1265                     //   end the catch clause enclosing new_exception_header without
1266                     //   __cxa_end_catch destroying new_exception_header.
1267                     new_exception_header->handlerCount = -new_exception_header->handlerCount;
1268                     globals->uncaughtExceptions += 1;
1269                     // Call __cxa_end_catch for new_exception_header
1270                     __cxa_end_catch();
1271                     // Call __cxa_end_catch for old_exception_header
1272                     __cxa_end_catch();
1273                     // Renter this catch clause with new_exception_header
1274                     __cxa_begin_catch(&new_exception_header->unwindHeader);
1275                     // Rethrow new_exception_header
1276                     throw;
1277                 }
1278             }
1279             // Will a std::bad_exception be catchable by the exception spec at
1280             //   ttypeIndex?
1281             // If no
1282             //    throw std::bad_exception();
1283             const __shim_type_info* excpType =
1284                 static_cast<const __shim_type_info*>(&typeid(std::bad_exception));
1285             std::bad_exception be;
1286             adjustedPtr = &be;
1287             if (!exception_spec_can_catch(ttypeIndex, classInfo, ttypeEncoding,
1288                                           excpType, adjustedPtr, unwind_exception))
1289             {
1290                 // We need to __cxa_end_catch for both the old exception and the
1291                 //   new exception.  Technically we should do it in that order.
1292                 //   But it is expedient to do it in the opposite order:
1293                 // Call __cxa_end_catch for new_exception_header
1294                 __cxa_end_catch();
1295                 // Throw std::bad_exception will __cxa_end_catch for
1296                 //   old_exception_header
1297                 throw be;
1298             }
1299         }
1300     }
1301     std::__terminate(t_handler);
1302 }
1303 
1304 }  // extern "C"
1305 
1306 }  // __cxxabiv1
1307