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