* libsupc++/eh_arm.cc (__cxa_type_match): Handle foreign
[people/dverkamp/gcc.git] / libstdc++-v3 / libsupc++ / eh_personality.cc
1 // -*- C++ -*- The GNU C++ exception personality routine.
2 // Copyright (C) 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
3 //
4 // This file is part of GCC.
5 //
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)
9 // any later version.
10 //
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.
15 //
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.
20
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.
29
30 #include <bits/c++config.h>
31 #include <cstdlib>
32 #include <exception_defines.h>
33 #include <cxxabi.h>
34 #include "unwind-cxx.h"
35
36 using namespace __cxxabiv1;
37
38 #ifdef __ARM_EABI_UNWINDER__
39 #define NO_SIZE_OF_ENCODED_VALUE
40 #endif
41
42 #include "unwind-pe.h"
43
44 \f
45 struct lsda_header_info
46 {
47   _Unwind_Ptr Start;
48   _Unwind_Ptr LPStart;
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;
54 };
55
56 static const unsigned char *
57 parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
58                    lsda_header_info *info)
59 {
60   _uleb128_t tmp;
61   unsigned char lpstart_encoding;
62
63   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
64
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);
69   else
70     info->LPStart = info->Start;
71
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)
75     {
76       p = read_uleb128 (p, &tmp);
77       info->TType = p + tmp;
78     }
79   else
80     info->TType = 0;
81
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;
87
88   return p;
89 }
90
91 #ifdef __ARM_EABI_UNWINDER__
92
93 // Return an element from a type table.
94
95 static const std::type_info*
96 get_ttype_entry(lsda_header_info* info, _uleb128_t i)
97 {
98   _Unwind_Ptr ptr;
99
100   ptr = (_Unwind_Ptr) (info->TType - (i * 4));
101   ptr = _Unwind_decode_target2(ptr);
102   
103   return reinterpret_cast<const std::type_info *>(ptr);
104 }
105
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) \
110    != ctm_failed)
111
112 // Return true if THROW_TYPE matches one if the filter types.
113
114 static bool
115 check_exception_spec(lsda_header_info* info, _throw_typet* throw_type,
116                      void* thrown_ptr, _sleb128_t filter_value)
117 {
118   const _uleb128_t* e = ((const _uleb128_t*) info->TType)
119                           - filter_value - 1;
120
121   while (1)
122     {
123       const std::type_info* catch_type;
124       _uleb128_t tmp;
125
126       tmp = *e;
127       
128       // Zero signals the end of the list.  If we've not found
129       // a match by now, then we've failed the specification.
130       if (tmp == 0)
131         return false;
132
133       tmp = _Unwind_decode_target2((_Unwind_Word) e);
134
135       // Match a ttype entry.
136       catch_type = reinterpret_cast<const std::type_info*>(tmp);
137
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
141       // thrown_ptr here.
142       if (get_adjusted_ptr(catch_type, throw_type, &thrown_ptr))
143         return true;
144
145       // Advance to the next entry.
146       e++;
147     }
148 }
149
150
151 // Save stage1 handler information in the exception object
152
153 static inline void
154 save_caught_exception(struct _Unwind_Exception* ue_header,
155                       struct _Unwind_Context* context,
156                       void* thrown_ptr,
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__)))
162 {
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;
170 }
171
172
173 // Restore the catch handler data saved during phase1.
174
175 static inline void
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)
180 {
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];
185 }
186
187 #define CONTINUE_UNWINDING \
188   do                                                            \
189     {                                                           \
190       if (__gnu_unwind_frame(ue_header, context) != _URC_OK)    \
191         return _URC_FAILURE;                                    \
192       return _URC_CONTINUE_UNWIND;                              \
193     }                                                           \
194   while (0)
195
196 // Return true if the filter spec is empty, ie throw().
197
198 static bool
199 empty_exception_spec (lsda_header_info *info, _Unwind_Sword filter_value)
200 {
201   const _Unwind_Word* e = ((const _Unwind_Word*) info->TType)
202                           - filter_value - 1;
203
204   return *e == 0;
205 }
206
207 #else
208 typedef const std::type_info _throw_typet;
209
210
211 // Return an element from a type table.
212
213 static const std::type_info *
214 get_ttype_entry (lsda_header_info *info, _uleb128_t i)
215 {
216   _Unwind_Ptr ptr;
217
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);
221
222   return reinterpret_cast<const std::type_info *>(ptr);
223 }
224
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.
229
230 static bool
231 get_adjusted_ptr (const std::type_info *catch_type,
232                   const std::type_info *throw_type,
233                   void **thrown_ptr_p)
234 {
235   void *thrown_ptr = *thrown_ptr_p;
236
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;
243
244   if (catch_type->__do_catch (throw_type, &thrown_ptr, 1))
245     {
246       *thrown_ptr_p = thrown_ptr;
247       return true;
248     }
249
250   return false;
251 }
252
253 // Return true if THROW_TYPE matches one if the filter types.
254
255 static bool
256 check_exception_spec(lsda_header_info* info, _throw_typet* throw_type,
257                       void* thrown_ptr, _sleb128_t filter_value)
258 {
259   const unsigned char *e = info->TType - filter_value - 1;
260
261   while (1)
262     {
263       const std::type_info *catch_type;
264       _uleb128_t tmp;
265
266       e = read_uleb128 (e, &tmp);
267
268       // Zero signals the end of the list.  If we've not found
269       // a match by now, then we've failed the specification.
270       if (tmp == 0)
271         return false;
272
273       // Match a ttype entry.
274       catch_type = get_ttype_entry (info, tmp);
275
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
279       // thrown_ptr here.
280       if (get_adjusted_ptr (catch_type, throw_type, &thrown_ptr))
281         return true;
282     }
283 }
284
285
286 // Save stage1 handler information in the exception object
287
288 static inline void
289 save_caught_exception(struct _Unwind_Exception* ue_header,
290                       struct _Unwind_Context* context
291                         __attribute__((__unused__)),
292                       void* thrown_ptr,
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)
297 {
298   __cxa_exception* xh = __get_exception_header_from_ue(ue_header);
299
300   xh->handlerSwitchValue = handler_switch_value;
301   xh->actionRecord = action_record;
302   xh->languageSpecificData = language_specific_data;
303   xh->adjustedPtr = thrown_ptr;
304
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;
308 }
309
310
311 // Restore the catch handler information saved during phase1.
312
313 static inline void
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)
318 {
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;
323 }
324
325 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
326
327 // Return true if the filter spec is empty, ie throw().
328
329 static bool
330 empty_exception_spec (lsda_header_info *info, _Unwind_Sword filter_value)
331 {
332   const unsigned char *e = info->TType - filter_value - 1;
333   _uleb128_t tmp;
334
335   e = read_uleb128 (e, &tmp);
336   return tmp == 0;
337 }
338
339 #endif // !__ARM_EABI_UNWINDER__
340
341 namespace __cxxabiv1
342 {
343
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
349 #else
350 #define PERSONALITY_FUNCTION    __gxx_personality_v0
351 #endif
352
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)
358 #else
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)
364 #endif
365 {
366   enum found_handler_type
367   {
368     found_nothing,
369     found_terminate,
370     found_cleanup,
371     found_handler
372   } found_type;
373
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 = ue_header + 1;
381   bool foreign_exception;
382   int ip_before_insn = 0;
383
384 #ifdef __ARM_EABI_UNWINDER__
385   _Unwind_Action actions;
386
387   switch (state & _US_ACTION_MASK)
388     {
389     case _US_VIRTUAL_UNWIND_FRAME:
390       actions = _UA_SEARCH_PHASE;
391       break;
392
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;
398       break;
399
400     case _US_UNWIND_FRAME_RESUME:
401       CONTINUE_UNWINDING;
402       break;
403
404     default:
405       std::abort();
406     }
407   actions |= state & _US_FORCE_UNWIND;
408
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
411   // to know.
412   foreign_exception = false;
413
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);
420 #else
421   __cxa_exception* xh = __get_exception_header_from_ue(ue_header);
422
423   // Interface version check.
424   if (version != 1)
425     return _URC_FATAL_PHASE1_ERROR;
426   foreign_exception = !__is_gxx_exception_class(exception_class);
427 #endif
428
429   // Shortcut for phase 2 found handler for domestic exception.
430   if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
431       && !foreign_exception)
432     {
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;
437     }
438
439   language_specific_data = (const unsigned char *)
440     _Unwind_GetLanguageSpecificData (context);
441
442   // If no LSDA, then there are no handlers or cleanups.
443   if (! language_specific_data)
444     CONTINUE_UNWINDING;
445
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 HAVE_GETIPINFO
450   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
451 #else
452   ip = _Unwind_GetIP (context);
453 #endif
454   if (! ip_before_insn)
455     --ip;
456   landing_pad = 0;
457   action_record = 0;
458   handler_switch_value = 0;
459
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
464   // to the array.
465   if ((int) ip < 0)
466     return _URC_CONTINUE_UNWIND;
467   else if (ip == 0)
468     {
469       // Fall through to set found_terminate.
470     }
471   else
472     {
473       _uleb128_t cs_lp, cs_action;
474       do
475         {
476           p = read_uleb128 (p, &cs_lp);
477           p = read_uleb128 (p, &cs_action);
478         }
479       while (--ip);
480
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;
484       if (cs_action)
485         action_record = info.action_table + cs_action - 1;
486       goto found_something;
487     }
488 #else
489   // Search the call-site table for the action associated with this IP.
490   while (p < info.action_table)
491     {
492       _Unwind_Ptr cs_start, cs_len, cs_lp;
493       _uleb128_t cs_action;
494
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);
500
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)
505         {
506           if (cs_lp)
507             landing_pad = info.LPStart + cs_lp;
508           if (cs_action)
509             action_record = info.action_table + cs_action - 1;
510           goto found_something;
511         }
512     }
513 #endif // _GLIBCXX_SJLJ_EXCEPTIONS
514
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;
519   goto do_something;
520
521  found_something:
522   if (landing_pad == 0)
523     {
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;
527     }
528   else if (action_record == 0)
529     {
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;
534     }
535   else
536     {
537       // Otherwise we have a catch handler or exception specification.
538
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;
544
545 #ifdef __ARM_EABI_UNWINDER__
546       throw_type = ue_header;
547       if ((actions & _UA_FORCE_UNWIND)
548           || foreign_exception)
549         thrown_ptr = 0;
550 #else
551       // During forced unwinding, match a magic exception type.
552       if (actions & _UA_FORCE_UNWIND)
553         {
554           throw_type = &typeid(abi::__forced_unwind);
555           thrown_ptr = 0;
556         }
557       // With a foreign exception class, there's no exception type.
558       // ??? What to do about GNU Java and GNU Ada exceptions?
559       else if (foreign_exception)
560         {
561           throw_type = &typeid(abi::__foreign_exception);
562           thrown_ptr = 0;
563         }
564       else
565         throw_type = xh->exceptionType;
566 #endif
567
568       while (1)
569         {
570           p = action_record;
571           p = read_sleb128 (p, &ar_filter);
572           read_sleb128 (p, &ar_disp);
573
574           if (ar_filter == 0)
575             {
576               // Zero filter values are cleanups.
577               saw_cleanup = true;
578             }
579           else if (ar_filter > 0)
580             {
581               // Positive filter values are handlers.
582               catch_type = get_ttype_entry (&info, ar_filter);
583
584               // Null catch type is a catch-all handler; we can catch foreign
585               // exceptions with this.  Otherwise we must match types.
586               if (! catch_type
587                   || (throw_type
588                       && get_adjusted_ptr (catch_type, throw_type,
589                                            &thrown_ptr)))
590                 {
591                   saw_handler = true;
592                   break;
593                 }
594             }
595           else
596             {
597               // Negative filter values are exception specifications.
598               // ??? How do foreign exceptions fit in?  As far as I can
599               // see we can't match because there's no __cxa_exception
600               // object to stuff bits in for __cxa_call_unexpected to use.
601               // Allow them iff the exception spec is non-empty.  I.e.
602               // a throw() specification results in __unexpected.
603               if ((throw_type
604                    && !(actions & _UA_FORCE_UNWIND)
605                    && !foreign_exception)
606                   ? ! check_exception_spec (&info, throw_type, thrown_ptr,
607                                             ar_filter)
608                   : empty_exception_spec (&info, ar_filter))
609                 {
610                   saw_handler = true;
611                   break;
612                 }
613             }
614
615           if (ar_disp == 0)
616             break;
617           action_record = p + ar_disp;
618         }
619
620       if (saw_handler)
621         {
622           handler_switch_value = ar_filter;
623           found_type = found_handler;
624         }
625       else
626         found_type = (saw_cleanup ? found_cleanup : found_nothing);
627     }
628
629  do_something:
630    if (found_type == found_nothing)
631      CONTINUE_UNWINDING;
632
633   if (actions & _UA_SEARCH_PHASE)
634     {
635       if (found_type == found_cleanup)
636         CONTINUE_UNWINDING;
637
638       // For domestic exceptions, we cache data from phase 1 for phase 2.
639       if (!foreign_exception)
640         {
641           save_caught_exception(ue_header, context, thrown_ptr,
642                                 handler_switch_value, language_specific_data,
643                                 landing_pad, action_record);
644         }
645       return _URC_HANDLER_FOUND;
646     }
647
648  install_context:
649   
650   // We can't use any of the cxa routines with foreign exceptions,
651   // because they all expect ue_header to be a struct __cxa_exception.
652   // So in that case, call terminate or unexpected directly.
653   if ((actions & _UA_FORCE_UNWIND)
654       || foreign_exception)
655     {
656       if (found_type == found_terminate)
657         std::terminate ();
658       else if (handler_switch_value < 0)
659         {
660           try 
661             { std::unexpected (); } 
662           catch(...) 
663             { std::terminate (); }
664         }
665     }
666   else
667     {
668       if (found_type == found_terminate)
669         __cxa_call_terminate(ue_header);
670
671       // Cache the TType base value for __cxa_call_unexpected, as we won't
672       // have an _Unwind_Context then.
673       if (handler_switch_value < 0)
674         {
675           parse_lsda_header (context, language_specific_data, &info);
676
677 #ifdef __ARM_EABI_UNWINDER__
678           const _Unwind_Word* e;
679           _Unwind_Word n;
680           
681           e = ((const _Unwind_Word*) info.TType) - handler_switch_value - 1;
682           // Count the number of rtti objects.
683           n = 0;
684           while (e[n] != 0)
685             n++;
686
687           // Count.
688           ue_header->barrier_cache.bitpattern[1] = n;
689           // Base (obsolete)
690           ue_header->barrier_cache.bitpattern[2] = 0;
691           // Stride.
692           ue_header->barrier_cache.bitpattern[3] = 4;
693           // List head.
694           ue_header->barrier_cache.bitpattern[4] = (_Unwind_Word) e;
695 #else
696           xh->catchTemp = base_of_encoded_value (info.ttype_encoding, context);
697 #endif
698         }
699     }
700
701   /* For targets with pointers smaller than the word size, we must extend the
702      pointer, and this extension is target dependent.  */
703   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
704                  __builtin_extend_pointer (ue_header));
705   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
706                  handler_switch_value);
707   _Unwind_SetIP (context, landing_pad);
708 #ifdef __ARM_EABI_UNWINDER__
709   if (found_type == found_cleanup)
710     __cxa_begin_cleanup(ue_header);
711 #endif
712   return _URC_INSTALL_CONTEXT;
713 }
714
715 /* The ARM EABI implementation of __cxa_call_unexpected is in a
716    different file so that the personality routine (PR) can be used
717    standalone.  The generic routine shared datastructures with the PR
718    so it is most convenient to implement it here.  */
719 #ifndef __ARM_EABI_UNWINDER__
720 extern "C" void
721 __cxa_call_unexpected (void *exc_obj_in)
722 {
723   _Unwind_Exception *exc_obj
724     = reinterpret_cast <_Unwind_Exception *>(exc_obj_in);
725
726   __cxa_begin_catch (exc_obj);
727
728   // This function is a handler for our exception argument.  If we exit
729   // by throwing a different exception, we'll need the original cleaned up.
730   struct end_catch_protect
731   {
732     end_catch_protect() { }
733     ~end_catch_protect() { __cxa_end_catch(); }
734   } end_catch_protect_obj;
735
736   lsda_header_info info;
737   __cxa_exception *xh = __get_exception_header_from_ue (exc_obj);
738   const unsigned char *xh_lsda;
739   _Unwind_Sword xh_switch_value;
740   std::terminate_handler xh_terminate_handler;
741
742   // If the unexpectedHandler rethrows the exception (e.g. to categorize it),
743   // it will clobber data about the current handler.  So copy the data out now.
744   xh_lsda = xh->languageSpecificData;
745   xh_switch_value = xh->handlerSwitchValue;
746   xh_terminate_handler = xh->terminateHandler;
747   info.ttype_base = (_Unwind_Ptr) xh->catchTemp;
748
749   try 
750     { __unexpected (xh->unexpectedHandler); } 
751   catch(...) 
752     {
753       // Get the exception thrown from unexpected.
754
755       __cxa_eh_globals *globals = __cxa_get_globals_fast ();
756       __cxa_exception *new_xh = globals->caughtExceptions;
757       void *new_ptr = new_xh + 1;
758
759       // We don't quite have enough stuff cached; re-parse the LSDA.
760       parse_lsda_header (0, xh_lsda, &info);
761
762       // If this new exception meets the exception spec, allow it.
763       if (check_exception_spec (&info, new_xh->exceptionType,
764                                 new_ptr, xh_switch_value))
765         __throw_exception_again;
766
767       // If the exception spec allows std::bad_exception, throw that.
768       // We don't have a thrown object to compare against, but since
769       // bad_exception doesn't have virtual bases, that's OK; just pass 0.
770 #ifdef __EXCEPTIONS  
771       const std::type_info &bad_exc = typeid (std::bad_exception);
772       if (check_exception_spec (&info, &bad_exc, 0, xh_switch_value))
773         throw std::bad_exception();
774 #endif   
775
776       // Otherwise, die.
777       __terminate (xh_terminate_handler);
778     }
779 }
780 #endif
781
782 } // namespace __cxxabiv1