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