1 // -*- C++ -*- The GNU C++ exception personality routine.
2 // Copyright (C) 2001, 2002, 2003, 2006, 2008 Free Software Foundation, Inc.
4 // This file is part of GCC.
6 // GCC is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 2, or (at your option)
11 // GCC is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // You should have received a copy of the GNU General Public License
17 // along with GCC; see the file COPYING. If not, write to
18 // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 // Boston, MA 02110-1301, USA.
21 // As a special exception, you may use this file as part of a free software
22 // library without restriction. Specifically, if other files instantiate
23 // templates or use macros or inline functions from this file, or you compile
24 // this file and link it with other files to produce an executable, this
25 // file does not by itself cause the resulting executable to be covered by
26 // the GNU General Public License. This exception does not however
27 // invalidate any other reasons why the executable file might be covered by
28 // the GNU General Public License.
30 #include <bits/c++config.h>
32 #include <exception_defines.h>
34 #include "unwind-cxx.h"
36 using namespace __cxxabiv1
;
38 #ifdef __ARM_EABI_UNWINDER__
39 #define NO_SIZE_OF_ENCODED_VALUE
42 #include "unwind-pe.h"
45 struct lsda_header_info
49 _Unwind_Ptr ttype_base
;
50 const unsigned char *TType
;
51 const unsigned char *action_table
;
52 unsigned char ttype_encoding
;
53 unsigned char call_site_encoding
;
56 static const unsigned char *
57 parse_lsda_header (_Unwind_Context
*context
, const unsigned char *p
,
58 lsda_header_info
*info
)
61 unsigned char lpstart_encoding
;
63 info
->Start
= (context
? _Unwind_GetRegionStart (context
) : 0);
65 // Find @LPStart, the base to which landing pad offsets are relative.
66 lpstart_encoding
= *p
++;
67 if (lpstart_encoding
!= DW_EH_PE_omit
)
68 p
= read_encoded_value (context
, lpstart_encoding
, p
, &info
->LPStart
);
70 info
->LPStart
= info
->Start
;
72 // Find @TType, the base of the handler and exception spec type data.
73 info
->ttype_encoding
= *p
++;
74 if (info
->ttype_encoding
!= DW_EH_PE_omit
)
76 p
= read_uleb128 (p
, &tmp
);
77 info
->TType
= p
+ tmp
;
82 // The encoding and length of the call-site table; the action table
83 // immediately follows.
84 info
->call_site_encoding
= *p
++;
85 p
= read_uleb128 (p
, &tmp
);
86 info
->action_table
= p
+ tmp
;
91 #ifdef __ARM_EABI_UNWINDER__
93 // Return an element from a type table.
95 static const std::type_info
*
96 get_ttype_entry(lsda_header_info
* info
, _uleb128_t i
)
100 ptr
= (_Unwind_Ptr
) (info
->TType
- (i
* 4));
101 ptr
= _Unwind_decode_target2(ptr
);
103 return reinterpret_cast<const std::type_info
*>(ptr
);
106 // The ABI provides a routine for matching exception object types.
107 typedef _Unwind_Control_Block _throw_typet
;
108 #define get_adjusted_ptr(catch_type, throw_type, thrown_ptr_p) \
109 (__cxa_type_match (throw_type, catch_type, false, thrown_ptr_p) \
112 // Return true if THROW_TYPE matches one if the filter types.
115 check_exception_spec(lsda_header_info
* info
, _throw_typet
* throw_type
,
116 void* thrown_ptr
, _sleb128_t filter_value
)
118 const _uleb128_t
* e
= ((const _uleb128_t
*) info
->TType
)
123 const std::type_info
* catch_type
;
128 // Zero signals the end of the list. If we've not found
129 // a match by now, then we've failed the specification.
133 tmp
= _Unwind_decode_target2((_Unwind_Word
) e
);
135 // Match a ttype entry.
136 catch_type
= reinterpret_cast<const std::type_info
*>(tmp
);
138 // ??? There is currently no way to ask the RTTI code about the
139 // relationship between two types without reference to a specific
140 // object. There should be; then we wouldn't need to mess with
142 if (get_adjusted_ptr(catch_type
, throw_type
, &thrown_ptr
))
145 // Advance to the next entry.
151 // Save stage1 handler information in the exception object
154 save_caught_exception(struct _Unwind_Exception
* ue_header
,
155 struct _Unwind_Context
* context
,
157 int handler_switch_value
,
158 const unsigned char* language_specific_data
,
159 _Unwind_Ptr landing_pad
,
160 const unsigned char* action_record
161 __attribute__((__unused__
)))
163 ue_header
->barrier_cache
.sp
= _Unwind_GetGR(context
, 13);
164 ue_header
->barrier_cache
.bitpattern
[0] = (_uw
) thrown_ptr
;
165 ue_header
->barrier_cache
.bitpattern
[1]
166 = (_uw
) handler_switch_value
;
167 ue_header
->barrier_cache
.bitpattern
[2]
168 = (_uw
) language_specific_data
;
169 ue_header
->barrier_cache
.bitpattern
[3] = (_uw
) landing_pad
;
173 // Restore the catch handler data saved during phase1.
176 restore_caught_exception(struct _Unwind_Exception
* ue_header
,
177 int& handler_switch_value
,
178 const unsigned char*& language_specific_data
,
179 _Unwind_Ptr
& landing_pad
)
181 handler_switch_value
= (int) ue_header
->barrier_cache
.bitpattern
[1];
182 language_specific_data
=
183 (const unsigned char*) ue_header
->barrier_cache
.bitpattern
[2];
184 landing_pad
= (_Unwind_Ptr
) ue_header
->barrier_cache
.bitpattern
[3];
187 #define CONTINUE_UNWINDING \
190 if (__gnu_unwind_frame(ue_header, context) != _URC_OK) \
191 return _URC_FAILURE; \
192 return _URC_CONTINUE_UNWIND; \
196 // Return true if the filter spec is empty, ie throw().
199 empty_exception_spec (lsda_header_info
*info
, _Unwind_Sword filter_value
)
201 const _Unwind_Word
* e
= ((const _Unwind_Word
*) info
->TType
)
208 typedef const std::type_info _throw_typet
;
211 // Return an element from a type table.
213 static const std::type_info
*
214 get_ttype_entry (lsda_header_info
*info
, _uleb128_t i
)
218 i
*= size_of_encoded_value (info
->ttype_encoding
);
219 read_encoded_value_with_base (info
->ttype_encoding
, info
->ttype_base
,
220 info
->TType
- i
, &ptr
);
222 return reinterpret_cast<const std::type_info
*>(ptr
);
225 // Given the thrown type THROW_TYPE, pointer to a variable containing a
226 // pointer to the exception object THROWN_PTR_P and a type CATCH_TYPE to
227 // compare against, return whether or not there is a match and if so,
228 // update *THROWN_PTR_P.
231 get_adjusted_ptr (const std::type_info
*catch_type
,
232 const std::type_info
*throw_type
,
235 void *thrown_ptr
= *thrown_ptr_p
;
237 // Pointer types need to adjust the actual pointer, not
238 // the pointer to pointer that is the exception object.
239 // This also has the effect of passing pointer types
240 // "by value" through the __cxa_begin_catch return value.
241 if (throw_type
->__is_pointer_p ())
242 thrown_ptr
= *(void **) thrown_ptr
;
244 if (catch_type
->__do_catch (throw_type
, &thrown_ptr
, 1))
246 *thrown_ptr_p
= thrown_ptr
;
253 // Return true if THROW_TYPE matches one if the filter types.
256 check_exception_spec(lsda_header_info
* info
, _throw_typet
* throw_type
,
257 void* thrown_ptr
, _sleb128_t filter_value
)
259 const unsigned char *e
= info
->TType
- filter_value
- 1;
263 const std::type_info
*catch_type
;
266 e
= read_uleb128 (e
, &tmp
);
268 // Zero signals the end of the list. If we've not found
269 // a match by now, then we've failed the specification.
273 // Match a ttype entry.
274 catch_type
= get_ttype_entry (info
, tmp
);
276 // ??? There is currently no way to ask the RTTI code about the
277 // relationship between two types without reference to a specific
278 // object. There should be; then we wouldn't need to mess with
280 if (get_adjusted_ptr (catch_type
, throw_type
, &thrown_ptr
))
286 // Save stage1 handler information in the exception object
289 save_caught_exception(struct _Unwind_Exception
* ue_header
,
290 struct _Unwind_Context
* context
291 __attribute__((__unused__
)),
293 int handler_switch_value
,
294 const unsigned char* language_specific_data
,
295 _Unwind_Ptr landing_pad
__attribute__((__unused__
)),
296 const unsigned char* action_record
)
298 __cxa_exception
* xh
= __get_exception_header_from_ue(ue_header
);
300 xh
->handlerSwitchValue
= handler_switch_value
;
301 xh
->actionRecord
= action_record
;
302 xh
->languageSpecificData
= language_specific_data
;
303 xh
->adjustedPtr
= thrown_ptr
;
305 // ??? Completely unknown what this field is supposed to be for.
306 // ??? Need to cache TType encoding base for call_unexpected.
307 xh
->catchTemp
= landing_pad
;
311 // Restore the catch handler information saved during phase1.
314 restore_caught_exception(struct _Unwind_Exception
* ue_header
,
315 int& handler_switch_value
,
316 const unsigned char*& language_specific_data
,
317 _Unwind_Ptr
& landing_pad
)
319 __cxa_exception
* xh
= __get_exception_header_from_ue(ue_header
);
320 handler_switch_value
= xh
->handlerSwitchValue
;
321 language_specific_data
= xh
->languageSpecificData
;
322 landing_pad
= (_Unwind_Ptr
) xh
->catchTemp
;
325 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
327 // Return true if the filter spec is empty, ie throw().
330 empty_exception_spec (lsda_header_info
*info
, _Unwind_Sword filter_value
)
332 const unsigned char *e
= info
->TType
- filter_value
- 1;
335 e
= read_uleb128 (e
, &tmp
);
339 #endif // !__ARM_EABI_UNWINDER__
344 // Using a different personality function name causes link failures
345 // when trying to mix code using different exception handling models.
346 #ifdef _GLIBCXX_SJLJ_EXCEPTIONS
347 #define PERSONALITY_FUNCTION __gxx_personality_sj0
348 #define __builtin_eh_return_data_regno(x) x
350 #define PERSONALITY_FUNCTION __gxx_personality_v0
353 extern "C" _Unwind_Reason_Code
354 #ifdef __ARM_EABI_UNWINDER__
355 PERSONALITY_FUNCTION (_Unwind_State state
,
356 struct _Unwind_Exception
* ue_header
,
357 struct _Unwind_Context
* context
)
359 PERSONALITY_FUNCTION (int version
,
360 _Unwind_Action actions
,
361 _Unwind_Exception_Class exception_class
,
362 struct _Unwind_Exception
*ue_header
,
363 struct _Unwind_Context
*context
)
366 enum found_handler_type
374 lsda_header_info info
;
375 const unsigned char *language_specific_data
;
376 const unsigned char *action_record
;
377 const unsigned char *p
;
378 _Unwind_Ptr landing_pad
, ip
;
379 int handler_switch_value
;
380 void* thrown_ptr
= 0;
381 bool foreign_exception
;
382 int ip_before_insn
= 0;
384 #ifdef __ARM_EABI_UNWINDER__
385 _Unwind_Action actions
;
387 switch (state
& _US_ACTION_MASK
)
389 case _US_VIRTUAL_UNWIND_FRAME
:
390 actions
= _UA_SEARCH_PHASE
;
393 case _US_UNWIND_FRAME_STARTING
:
394 actions
= _UA_CLEANUP_PHASE
;
395 if (!(state
& _US_FORCE_UNWIND
)
396 && ue_header
->barrier_cache
.sp
== _Unwind_GetGR(context
, 13))
397 actions
|= _UA_HANDLER_FRAME
;
400 case _US_UNWIND_FRAME_RESUME
:
407 actions
|= state
& _US_FORCE_UNWIND
;
409 // We don't know which runtime we're working with, so can't check this.
410 // However the ABI routines hide this from us, and we don't actually need
412 foreign_exception
= false;
414 // The dwarf unwinder assumes the context structure holds things like the
415 // function and LSDA pointers. The ARM implementation caches these in
416 // the exception header (UCB). To avoid rewriting everything we make the
417 // virtual IP register point at the UCB.
418 ip
= (_Unwind_Ptr
) ue_header
;
419 _Unwind_SetGR(context
, 12, ip
);
421 __cxa_exception
* xh
= __get_exception_header_from_ue(ue_header
);
423 // Interface version check.
425 return _URC_FATAL_PHASE1_ERROR
;
426 foreign_exception
= !__is_gxx_exception_class(exception_class
);
429 // Shortcut for phase 2 found handler for domestic exception.
430 if (actions
== (_UA_CLEANUP_PHASE
| _UA_HANDLER_FRAME
)
431 && !foreign_exception
)
433 restore_caught_exception(ue_header
, handler_switch_value
,
434 language_specific_data
, landing_pad
);
435 found_type
= (landing_pad
== 0 ? found_terminate
: found_handler
);
436 goto install_context
;
439 language_specific_data
= (const unsigned char *)
440 _Unwind_GetLanguageSpecificData (context
);
442 // If no LSDA, then there are no handlers or cleanups.
443 if (! language_specific_data
)
446 // Parse the LSDA header.
447 p
= parse_lsda_header (context
, language_specific_data
, &info
);
448 info
.ttype_base
= base_of_encoded_value (info
.ttype_encoding
, context
);
449 #ifdef _GLIBCXX_HAVE_GETIPINFO
450 ip
= _Unwind_GetIPInfo (context
, &ip_before_insn
);
452 ip
= _Unwind_GetIP (context
);
454 if (! ip_before_insn
)
458 handler_switch_value
= 0;
460 #ifdef _GLIBCXX_SJLJ_EXCEPTIONS
461 // The given "IP" is an index into the call-site table, with two
462 // exceptions -- -1 means no-action, and 0 means terminate. But
463 // since we're using uleb128 values, we've not got random access
466 return _URC_CONTINUE_UNWIND
;
469 // Fall through to set found_terminate.
473 _uleb128_t cs_lp
, cs_action
;
476 p
= read_uleb128 (p
, &cs_lp
);
477 p
= read_uleb128 (p
, &cs_action
);
481 // Can never have null landing pad for sjlj -- that would have
482 // been indicated by a -1 call site index.
483 landing_pad
= cs_lp
+ 1;
485 action_record
= info
.action_table
+ cs_action
- 1;
486 goto found_something
;
489 // Search the call-site table for the action associated with this IP.
490 while (p
< info
.action_table
)
492 _Unwind_Ptr cs_start
, cs_len
, cs_lp
;
493 _uleb128_t cs_action
;
495 // Note that all call-site encodings are "absolute" displacements.
496 p
= read_encoded_value (0, info
.call_site_encoding
, p
, &cs_start
);
497 p
= read_encoded_value (0, info
.call_site_encoding
, p
, &cs_len
);
498 p
= read_encoded_value (0, info
.call_site_encoding
, p
, &cs_lp
);
499 p
= read_uleb128 (p
, &cs_action
);
501 // The table is sorted, so if we've passed the ip, stop.
502 if (ip
< info
.Start
+ cs_start
)
503 p
= info
.action_table
;
504 else if (ip
< info
.Start
+ cs_start
+ cs_len
)
507 landing_pad
= info
.LPStart
+ cs_lp
;
509 action_record
= info
.action_table
+ cs_action
- 1;
510 goto found_something
;
513 #endif // _GLIBCXX_SJLJ_EXCEPTIONS
515 // If ip is not present in the table, call terminate. This is for
516 // a destructor inside a cleanup, or a library routine the compiler
517 // was not expecting to throw.
518 found_type
= found_terminate
;
522 if (landing_pad
== 0)
524 // If ip is present, and has a null landing pad, there are
525 // no cleanups or handlers to be run.
526 found_type
= found_nothing
;
528 else if (action_record
== 0)
530 // If ip is present, has a non-null landing pad, and a null
531 // action table offset, then there are only cleanups present.
532 // Cleanups use a zero switch value, as set above.
533 found_type
= found_cleanup
;
537 // Otherwise we have a catch handler or exception specification.
539 _sleb128_t ar_filter
, ar_disp
;
540 const std::type_info
* catch_type
;
541 _throw_typet
* throw_type
;
542 bool saw_cleanup
= false;
543 bool saw_handler
= false;
545 #ifdef __ARM_EABI_UNWINDER__
546 // ??? How does this work - more importantly, how does it interact with
547 // dependent exceptions?
548 throw_type
= ue_header
;
549 if (actions
& _UA_FORCE_UNWIND
)
551 __GXX_INIT_FORCED_UNWIND_CLASS(ue_header
->exception_class
);
553 else if (!foreign_exception
)
554 thrown_ptr
= __get_object_from_ue (ue_header
);
556 // During forced unwinding, match a magic exception type.
557 if (actions
& _UA_FORCE_UNWIND
)
559 throw_type
= &typeid(abi::__forced_unwind
);
561 // With a foreign exception class, there's no exception type.
562 // ??? What to do about GNU Java and GNU Ada exceptions?
563 else if (foreign_exception
)
565 throw_type
= &typeid(abi::__foreign_exception
);
569 thrown_ptr
= __get_object_from_ue (ue_header
);
570 throw_type
= __get_exception_header_from_obj
571 (thrown_ptr
)->exceptionType
;
578 p
= read_sleb128 (p
, &ar_filter
);
579 read_sleb128 (p
, &ar_disp
);
583 // Zero filter values are cleanups.
586 else if (ar_filter
> 0)
588 // Positive filter values are handlers.
589 catch_type
= get_ttype_entry (&info
, ar_filter
);
591 // Null catch type is a catch-all handler; we can catch foreign
592 // exceptions with this. Otherwise we must match types.
595 && get_adjusted_ptr (catch_type
, throw_type
,
604 // Negative filter values are exception specifications.
605 // ??? How do foreign exceptions fit in? As far as I can
606 // see we can't match because there's no __cxa_exception
607 // object to stuff bits in for __cxa_call_unexpected to use.
608 // Allow them iff the exception spec is non-empty. I.e.
609 // a throw() specification results in __unexpected.
611 && !(actions
& _UA_FORCE_UNWIND
)
612 && !foreign_exception
)
613 ? ! check_exception_spec (&info
, throw_type
, thrown_ptr
,
615 : empty_exception_spec (&info
, ar_filter
))
624 action_record
= p
+ ar_disp
;
629 handler_switch_value
= ar_filter
;
630 found_type
= found_handler
;
633 found_type
= (saw_cleanup
? found_cleanup
: found_nothing
);
637 if (found_type
== found_nothing
)
640 if (actions
& _UA_SEARCH_PHASE
)
642 if (found_type
== found_cleanup
)
645 // For domestic exceptions, we cache data from phase 1 for phase 2.
646 if (!foreign_exception
)
648 save_caught_exception(ue_header
, context
, thrown_ptr
,
649 handler_switch_value
, language_specific_data
,
650 landing_pad
, action_record
);
652 return _URC_HANDLER_FOUND
;
657 // We can't use any of the cxa routines with foreign exceptions,
658 // because they all expect ue_header to be a struct __cxa_exception.
659 // So in that case, call terminate or unexpected directly.
660 if ((actions
& _UA_FORCE_UNWIND
)
661 || foreign_exception
)
663 if (found_type
== found_terminate
)
665 else if (handler_switch_value
< 0)
668 { std::unexpected (); }
670 { std::terminate (); }
675 if (found_type
== found_terminate
)
676 __cxa_call_terminate(ue_header
);
678 // Cache the TType base value for __cxa_call_unexpected, as we won't
679 // have an _Unwind_Context then.
680 if (handler_switch_value
< 0)
682 parse_lsda_header (context
, language_specific_data
, &info
);
684 #ifdef __ARM_EABI_UNWINDER__
685 const _Unwind_Word
* e
;
688 e
= ((const _Unwind_Word
*) info
.TType
) - handler_switch_value
- 1;
689 // Count the number of rtti objects.
695 ue_header
->barrier_cache
.bitpattern
[1] = n
;
697 ue_header
->barrier_cache
.bitpattern
[2] = 0;
699 ue_header
->barrier_cache
.bitpattern
[3] = 4;
701 ue_header
->barrier_cache
.bitpattern
[4] = (_Unwind_Word
) e
;
703 xh
->catchTemp
= base_of_encoded_value (info
.ttype_encoding
, context
);
708 /* For targets with pointers smaller than the word size, we must extend the
709 pointer, and this extension is target dependent. */
710 _Unwind_SetGR (context
, __builtin_eh_return_data_regno (0),
711 __builtin_extend_pointer (ue_header
));
712 _Unwind_SetGR (context
, __builtin_eh_return_data_regno (1),
713 handler_switch_value
);
714 _Unwind_SetIP (context
, landing_pad
);
715 #ifdef __ARM_EABI_UNWINDER__
716 if (found_type
== found_cleanup
)
717 __cxa_begin_cleanup(ue_header
);
719 return _URC_INSTALL_CONTEXT
;
722 /* The ARM EABI implementation of __cxa_call_unexpected is in a
723 different file so that the personality routine (PR) can be used
724 standalone. The generic routine shared datastructures with the PR
725 so it is most convenient to implement it here. */
726 #ifndef __ARM_EABI_UNWINDER__
728 __cxa_call_unexpected (void *exc_obj_in
)
730 _Unwind_Exception
*exc_obj
731 = reinterpret_cast <_Unwind_Exception
*>(exc_obj_in
);
733 __cxa_begin_catch (exc_obj
);
735 // This function is a handler for our exception argument. If we exit
736 // by throwing a different exception, we'll need the original cleaned up.
737 struct end_catch_protect
739 end_catch_protect() { }
740 ~end_catch_protect() { __cxa_end_catch(); }
741 } end_catch_protect_obj
;
743 lsda_header_info info
;
744 __cxa_exception
*xh
= __get_exception_header_from_ue (exc_obj
);
745 const unsigned char *xh_lsda
;
746 _Unwind_Sword xh_switch_value
;
747 std::terminate_handler xh_terminate_handler
;
749 // If the unexpectedHandler rethrows the exception (e.g. to categorize it),
750 // it will clobber data about the current handler. So copy the data out now.
751 xh_lsda
= xh
->languageSpecificData
;
752 xh_switch_value
= xh
->handlerSwitchValue
;
753 xh_terminate_handler
= xh
->terminateHandler
;
754 info
.ttype_base
= (_Unwind_Ptr
) xh
->catchTemp
;
757 { __unexpected (xh
->unexpectedHandler
); }
760 // Get the exception thrown from unexpected.
762 __cxa_eh_globals
*globals
= __cxa_get_globals_fast ();
763 __cxa_exception
*new_xh
= globals
->caughtExceptions
;
764 void *new_ptr
= __get_object_from_ambiguous_exception (new_xh
);
766 // We don't quite have enough stuff cached; re-parse the LSDA.
767 parse_lsda_header (0, xh_lsda
, &info
);
769 // If this new exception meets the exception spec, allow it.
770 if (check_exception_spec (&info
, __get_exception_header_from_obj
771 (new_ptr
)->exceptionType
,
772 new_ptr
, xh_switch_value
))
773 __throw_exception_again
;
775 // If the exception spec allows std::bad_exception, throw that.
776 // We don't have a thrown object to compare against, but since
777 // bad_exception doesn't have virtual bases, that's OK; just pass 0.
779 const std::type_info
&bad_exc
= typeid (std::bad_exception
);
780 if (check_exception_spec (&info
, &bad_exc
, 0, xh_switch_value
))
781 throw std::bad_exception();
785 __terminate (xh_terminate_handler
);
790 } // namespace __cxxabiv1