OSDN Git Service

7576d407da42377ef5c3c2521c47b2314fa50748
[pf3gnuchains/gcc-fork.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 "unwind-cxx.h"
34
35 using namespace __cxxabiv1;
36
37 #ifdef __ARM_EABI_UNWINDER__
38 #define NO_SIZE_OF_ENCODED_VALUE
39 #endif
40
41 #include "unwind-pe.h"
42
43 \f
44 struct lsda_header_info
45 {
46   _Unwind_Ptr Start;
47   _Unwind_Ptr LPStart;
48   _Unwind_Ptr ttype_base;
49   const unsigned char *TType;
50   const unsigned char *action_table;
51   unsigned char ttype_encoding;
52   unsigned char call_site_encoding;
53 };
54
55 static const unsigned char *
56 parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
57                    lsda_header_info *info)
58 {
59   _Unwind_Word tmp;
60   unsigned char lpstart_encoding;
61
62   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
63
64   // Find @LPStart, the base to which landing pad offsets are relative.
65   lpstart_encoding = *p++;
66   if (lpstart_encoding != DW_EH_PE_omit)
67     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
68   else
69     info->LPStart = info->Start;
70
71   // Find @TType, the base of the handler and exception spec type data.
72   info->ttype_encoding = *p++;
73   if (info->ttype_encoding != DW_EH_PE_omit)
74     {
75       p = read_uleb128 (p, &tmp);
76       info->TType = p + tmp;
77     }
78   else
79     info->TType = 0;
80
81   // The encoding and length of the call-site table; the action table
82   // immediately follows.
83   info->call_site_encoding = *p++;
84   p = read_uleb128 (p, &tmp);
85   info->action_table = p + tmp;
86
87   return p;
88 }
89
90 #ifdef __ARM_EABI_UNWINDER__
91
92 // Return an element from a type table.
93
94 static const std::type_info*
95 get_ttype_entry(lsda_header_info* info, _Unwind_Word i)
96 {
97   _Unwind_Ptr ptr;
98
99   ptr = (_Unwind_Ptr) (info->TType - (i * 4));
100   ptr = _Unwind_decode_target2(ptr);
101   
102   return reinterpret_cast<const std::type_info *>(ptr);
103 }
104
105 // The ABI provides a routine for matching exception object types.
106 typedef _Unwind_Control_Block _throw_typet;
107 #define get_adjusted_ptr(catch_type, throw_type, thrown_ptr_p) \
108   (__cxa_type_match (throw_type, catch_type, false, thrown_ptr_p) \
109    != ctm_failed)
110
111 // Return true if THROW_TYPE matches one if the filter types.
112
113 static bool
114 check_exception_spec(lsda_header_info* info, _throw_typet* throw_type,
115                      void* thrown_ptr, _Unwind_Sword filter_value)
116 {
117   const _Unwind_Word* e = ((const _Unwind_Word*) info->TType)
118                           - filter_value - 1;
119
120   while (1)
121     {
122       const std::type_info* catch_type;
123       _Unwind_Word tmp;
124
125       tmp = *e;
126       
127       // Zero signals the end of the list.  If we've not found
128       // a match by now, then we've failed the specification.
129       if (tmp == 0)
130         return false;
131
132       tmp = _Unwind_decode_target2((_Unwind_Word) e);
133
134       // Match a ttype entry.
135       catch_type = reinterpret_cast<const std::type_info*>(tmp);
136
137       // ??? There is currently no way to ask the RTTI code about the
138       // relationship between two types without reference to a specific
139       // object.  There should be; then we wouldn't need to mess with
140       // thrown_ptr here.
141       if (get_adjusted_ptr(catch_type, throw_type, &thrown_ptr))
142         return true;
143
144       // Advance to the next entry.
145       e++;
146     }
147 }
148
149
150 // Save stage1 handler information in the exception object
151
152 static inline void
153 save_caught_exception(struct _Unwind_Exception* ue_header,
154                       struct _Unwind_Context* context,
155                       void* thrown_ptr,
156                       int handler_switch_value,
157                       const unsigned char* language_specific_data,
158                       _Unwind_Ptr landing_pad,
159                       const unsigned char* action_record
160                         __attribute__((__unused__)))
161 {
162     ue_header->barrier_cache.sp = _Unwind_GetGR(context, 13);
163     ue_header->barrier_cache.bitpattern[0] = (_uw) thrown_ptr;
164     ue_header->barrier_cache.bitpattern[1]
165       = (_uw) handler_switch_value;
166     ue_header->barrier_cache.bitpattern[2]
167       = (_uw) language_specific_data;
168     ue_header->barrier_cache.bitpattern[3] = (_uw) landing_pad;
169 }
170
171
172 // Restore the catch handler data saved during phase1.
173
174 static inline void
175 restore_caught_exception(struct _Unwind_Exception* ue_header,
176                          int& handler_switch_value,
177                          const unsigned char*& language_specific_data,
178                          _Unwind_Ptr& landing_pad)
179 {
180   handler_switch_value = (int) ue_header->barrier_cache.bitpattern[1];
181   language_specific_data =
182     (const unsigned char*) ue_header->barrier_cache.bitpattern[2];
183   landing_pad = (_Unwind_Ptr) ue_header->barrier_cache.bitpattern[3];
184 }
185
186 #define CONTINUE_UNWINDING \
187   do                                                            \
188     {                                                           \
189       if (__gnu_unwind_frame(ue_header, context) != _URC_OK)    \
190         return _URC_FAILURE;                                    \
191       return _URC_CONTINUE_UNWIND;                              \
192     }                                                           \
193   while (0)
194
195 #else
196 typedef const std::type_info _throw_typet;
197
198
199 // Return an element from a type table.
200
201 static const std::type_info *
202 get_ttype_entry (lsda_header_info *info, _Unwind_Word i)
203 {
204   _Unwind_Ptr ptr;
205
206   i *= size_of_encoded_value (info->ttype_encoding);
207   read_encoded_value_with_base (info->ttype_encoding, info->ttype_base,
208                                 info->TType - i, &ptr);
209
210   return reinterpret_cast<const std::type_info *>(ptr);
211 }
212
213 // Given the thrown type THROW_TYPE, pointer to a variable containing a
214 // pointer to the exception object THROWN_PTR_P and a type CATCH_TYPE to
215 // compare against, return whether or not there is a match and if so,
216 // update *THROWN_PTR_P.
217
218 static bool
219 get_adjusted_ptr (const std::type_info *catch_type,
220                   const std::type_info *throw_type,
221                   void **thrown_ptr_p)
222 {
223   void *thrown_ptr = *thrown_ptr_p;
224
225   // Pointer types need to adjust the actual pointer, not
226   // the pointer to pointer that is the exception object.
227   // This also has the effect of passing pointer types
228   // "by value" through the __cxa_begin_catch return value.
229   if (throw_type->__is_pointer_p ())
230     thrown_ptr = *(void **) thrown_ptr;
231
232   if (catch_type->__do_catch (throw_type, &thrown_ptr, 1))
233     {
234       *thrown_ptr_p = thrown_ptr;
235       return true;
236     }
237
238   return false;
239 }
240
241 // Return true if THROW_TYPE matches one if the filter types.
242
243 static bool
244 check_exception_spec(lsda_header_info* info, _throw_typet* throw_type,
245                       void* thrown_ptr, _Unwind_Sword filter_value)
246 {
247   const unsigned char *e = info->TType - filter_value - 1;
248
249   while (1)
250     {
251       const std::type_info *catch_type;
252       _Unwind_Word tmp;
253
254       e = read_uleb128 (e, &tmp);
255
256       // Zero signals the end of the list.  If we've not found
257       // a match by now, then we've failed the specification.
258       if (tmp == 0)
259         return false;
260
261       // Match a ttype entry.
262       catch_type = get_ttype_entry (info, tmp);
263
264       // ??? There is currently no way to ask the RTTI code about the
265       // relationship between two types without reference to a specific
266       // object.  There should be; then we wouldn't need to mess with
267       // thrown_ptr here.
268       if (get_adjusted_ptr (catch_type, throw_type, &thrown_ptr))
269         return true;
270     }
271 }
272
273
274 // Save stage1 handler information in the exception object
275
276 static inline void
277 save_caught_exception(struct _Unwind_Exception* ue_header,
278                       struct _Unwind_Context* context
279                         __attribute__((__unused__)),
280                       void* thrown_ptr,
281                       int handler_switch_value,
282                       const unsigned char* language_specific_data,
283                       _Unwind_Ptr landing_pad __attribute__((__unused__)),
284                       const unsigned char* action_record)
285 {
286   __cxa_exception* xh = __get_exception_header_from_ue(ue_header);
287
288   xh->handlerSwitchValue = handler_switch_value;
289   xh->actionRecord = action_record;
290   xh->languageSpecificData = language_specific_data;
291   xh->adjustedPtr = thrown_ptr;
292
293   // ??? Completely unknown what this field is supposed to be for.
294   // ??? Need to cache TType encoding base for call_unexpected.
295   xh->catchTemp = landing_pad;
296 }
297
298
299 // Restore the catch handler information saved during phase1.
300
301 static inline void
302 restore_caught_exception(struct _Unwind_Exception* ue_header,
303                          int& handler_switch_value,
304                          const unsigned char*& language_specific_data,
305                          _Unwind_Ptr& landing_pad)
306 {
307   __cxa_exception* xh = __get_exception_header_from_ue(ue_header);
308   handler_switch_value = xh->handlerSwitchValue;
309   language_specific_data = xh->languageSpecificData;
310   landing_pad = (_Unwind_Ptr) xh->catchTemp;
311 }
312
313 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
314
315 #endif // !__ARM_EABI_UNWINDER__
316
317 // Return true if the filter spec is empty, ie throw().
318
319 static bool
320 empty_exception_spec (lsda_header_info *info, _Unwind_Sword filter_value)
321 {
322   const unsigned char *e = info->TType - filter_value - 1;
323   _Unwind_Word tmp;
324
325   e = read_uleb128 (e, &tmp);
326   return tmp == 0;
327 }
328
329 namespace __cxxabiv1
330 {
331
332 // Using a different personality function name causes link failures
333 // when trying to mix code using different exception handling models.
334 #ifdef _GLIBCXX_SJLJ_EXCEPTIONS
335 #define PERSONALITY_FUNCTION    __gxx_personality_sj0
336 #define __builtin_eh_return_data_regno(x) x
337 #else
338 #define PERSONALITY_FUNCTION    __gxx_personality_v0
339 #endif
340
341 extern "C" _Unwind_Reason_Code
342 #ifdef __ARM_EABI_UNWINDER__
343 PERSONALITY_FUNCTION (_Unwind_State state,
344                       struct _Unwind_Exception* ue_header,
345                       struct _Unwind_Context* context)
346 #else
347 PERSONALITY_FUNCTION (int version,
348                       _Unwind_Action actions,
349                       _Unwind_Exception_Class exception_class,
350                       struct _Unwind_Exception *ue_header,
351                       struct _Unwind_Context *context)
352 #endif
353 {
354   enum found_handler_type
355   {
356     found_nothing,
357     found_terminate,
358     found_cleanup,
359     found_handler
360   } found_type;
361
362   lsda_header_info info;
363   const unsigned char *language_specific_data;
364   const unsigned char *action_record;
365   const unsigned char *p;
366   _Unwind_Ptr landing_pad, ip;
367   int handler_switch_value;
368   void* thrown_ptr = ue_header + 1;
369   bool foreign_exception;
370   int ip_before_insn = 0;
371
372 #ifdef __ARM_EABI_UNWINDER__
373   _Unwind_Action actions;
374
375   switch (state & _US_ACTION_MASK)
376     {
377     case _US_VIRTUAL_UNWIND_FRAME:
378       actions = _UA_SEARCH_PHASE;
379       break;
380
381     case _US_UNWIND_FRAME_STARTING:
382       actions = _UA_CLEANUP_PHASE;
383       if (!(state & _US_FORCE_UNWIND)
384           && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 13))
385         actions |= _UA_HANDLER_FRAME;
386       break;
387
388     case _US_UNWIND_FRAME_RESUME:
389       CONTINUE_UNWINDING;
390       break;
391
392     default:
393       std::abort();
394     }
395   actions |= state & _US_FORCE_UNWIND;
396
397   // We don't know which runtime we're working with, so can't check this.
398   // However the ABI routines hide this from us, and we don't actually need
399   // to know.
400   foreign_exception = false;
401
402   // The dwarf unwinder assumes the context structure holds things like the
403   // function and LSDA pointers.  The ARM implementation caches these in
404   // the exception header (UCB).  To avoid rewriting everything we make the
405   // virtual IP register point at the UCB.
406   ip = (_Unwind_Ptr) ue_header;
407   _Unwind_SetGR(context, 12, ip);
408 #else
409   __cxa_exception* xh = __get_exception_header_from_ue(ue_header);
410
411   // Interface version check.
412   if (version != 1)
413     return _URC_FATAL_PHASE1_ERROR;
414   foreign_exception = !__is_gxx_exception_class(exception_class);
415 #endif
416
417   // Shortcut for phase 2 found handler for domestic exception.
418   if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
419       && !foreign_exception)
420     {
421       restore_caught_exception(ue_header, handler_switch_value,
422                                language_specific_data, landing_pad);
423       found_type = (landing_pad == 0 ? found_terminate : found_handler);
424       goto install_context;
425     }
426
427   language_specific_data = (const unsigned char *)
428     _Unwind_GetLanguageSpecificData (context);
429
430   // If no LSDA, then there are no handlers or cleanups.
431   if (! language_specific_data)
432     CONTINUE_UNWINDING;
433
434   // Parse the LSDA header.
435   p = parse_lsda_header (context, language_specific_data, &info);
436   info.ttype_base = base_of_encoded_value (info.ttype_encoding, context);
437   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
438   if (! ip_before_insn)
439     --ip;
440   landing_pad = 0;
441   action_record = 0;
442   handler_switch_value = 0;
443
444 #ifdef _GLIBCXX_SJLJ_EXCEPTIONS
445   // The given "IP" is an index into the call-site table, with two
446   // exceptions -- -1 means no-action, and 0 means terminate.  But
447   // since we're using uleb128 values, we've not got random access
448   // to the array.
449   if ((int) ip < 0)
450     return _URC_CONTINUE_UNWIND;
451   else if (ip == 0)
452     {
453       // Fall through to set found_terminate.
454     }
455   else
456     {
457       _Unwind_Word cs_lp, cs_action;
458       do
459         {
460           p = read_uleb128 (p, &cs_lp);
461           p = read_uleb128 (p, &cs_action);
462         }
463       while (--ip);
464
465       // Can never have null landing pad for sjlj -- that would have
466       // been indicated by a -1 call site index.
467       landing_pad = cs_lp + 1;
468       if (cs_action)
469         action_record = info.action_table + cs_action - 1;
470       goto found_something;
471     }
472 #else
473   // Search the call-site table for the action associated with this IP.
474   while (p < info.action_table)
475     {
476       _Unwind_Ptr cs_start, cs_len, cs_lp;
477       _Unwind_Word cs_action;
478
479       // Note that all call-site encodings are "absolute" displacements.
480       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
481       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
482       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
483       p = read_uleb128 (p, &cs_action);
484
485       // The table is sorted, so if we've passed the ip, stop.
486       if (ip < info.Start + cs_start)
487         p = info.action_table;
488       else if (ip < info.Start + cs_start + cs_len)
489         {
490           if (cs_lp)
491             landing_pad = info.LPStart + cs_lp;
492           if (cs_action)
493             action_record = info.action_table + cs_action - 1;
494           goto found_something;
495         }
496     }
497 #endif // _GLIBCXX_SJLJ_EXCEPTIONS
498
499   // If ip is not present in the table, call terminate.  This is for
500   // a destructor inside a cleanup, or a library routine the compiler
501   // was not expecting to throw.
502   found_type = found_terminate;
503   goto do_something;
504
505  found_something:
506   if (landing_pad == 0)
507     {
508       // If ip is present, and has a null landing pad, there are
509       // no cleanups or handlers to be run.
510       found_type = found_nothing;
511     }
512   else if (action_record == 0)
513     {
514       // If ip is present, has a non-null landing pad, and a null
515       // action table offset, then there are only cleanups present.
516       // Cleanups use a zero switch value, as set above.
517       found_type = found_cleanup;
518     }
519   else
520     {
521       // Otherwise we have a catch handler or exception specification.
522
523       _Unwind_Sword ar_filter, ar_disp;
524       const std::type_info* catch_type;
525       _throw_typet* throw_type;
526       bool saw_cleanup = false;
527       bool saw_handler = false;
528
529       // During forced unwinding, we only run cleanups.  With a foreign
530       // exception class, there's no exception type.
531       // ??? What to do about GNU Java and GNU Ada exceptions.
532
533       if ((actions & _UA_FORCE_UNWIND)
534           || foreign_exception)
535         throw_type = 0;
536       else
537 #ifdef __ARM_EABI_UNWINDER__
538         throw_type = ue_header;
539 #else
540         throw_type = xh->exceptionType;
541 #endif
542
543       while (1)
544         {
545           p = action_record;
546           p = read_sleb128 (p, &ar_filter);
547           read_sleb128 (p, &ar_disp);
548
549           if (ar_filter == 0)
550             {
551               // Zero filter values are cleanups.
552               saw_cleanup = true;
553             }
554           else if (ar_filter > 0)
555             {
556               // Positive filter values are handlers.
557               catch_type = get_ttype_entry (&info, ar_filter);
558
559               // Null catch type is a catch-all handler; we can catch foreign
560               // exceptions with this.  Otherwise we must match types.
561               if (! catch_type
562                   || (throw_type
563                       && get_adjusted_ptr (catch_type, throw_type,
564                                            &thrown_ptr)))
565                 {
566                   saw_handler = true;
567                   break;
568                 }
569             }
570           else
571             {
572               // Negative filter values are exception specifications.
573               // ??? How do foreign exceptions fit in?  As far as I can
574               // see we can't match because there's no __cxa_exception
575               // object to stuff bits in for __cxa_call_unexpected to use.
576               // Allow them iff the exception spec is non-empty.  I.e.
577               // a throw() specification results in __unexpected.
578               if (throw_type
579                   ? ! check_exception_spec (&info, throw_type, thrown_ptr,
580                                             ar_filter)
581                   : empty_exception_spec (&info, ar_filter))
582                 {
583                   saw_handler = true;
584                   break;
585                 }
586             }
587
588           if (ar_disp == 0)
589             break;
590           action_record = p + ar_disp;
591         }
592
593       if (saw_handler)
594         {
595           handler_switch_value = ar_filter;
596           found_type = found_handler;
597         }
598       else
599         found_type = (saw_cleanup ? found_cleanup : found_nothing);
600     }
601
602  do_something:
603    if (found_type == found_nothing)
604      CONTINUE_UNWINDING;
605
606   if (actions & _UA_SEARCH_PHASE)
607     {
608       if (found_type == found_cleanup)
609         CONTINUE_UNWINDING;
610
611       // For domestic exceptions, we cache data from phase 1 for phase 2.
612       if (!foreign_exception)
613         {
614           save_caught_exception(ue_header, context, thrown_ptr,
615                                 handler_switch_value, language_specific_data,
616                                 landing_pad, action_record);
617         }
618       return _URC_HANDLER_FOUND;
619     }
620
621  install_context:
622   
623   // We can't use any of the cxa routines with foreign exceptions,
624   // because they all expect ue_header to be a struct __cxa_exception.
625   // So in that case, call terminate or unexpected directly.
626   if ((actions & _UA_FORCE_UNWIND)
627       || foreign_exception)
628     {
629       if (found_type == found_terminate)
630         std::terminate ();
631       else if (handler_switch_value < 0)
632         {
633           try 
634             { std::unexpected (); } 
635           catch(...) 
636             { std::terminate (); }
637         }
638     }
639   else
640     {
641       if (found_type == found_terminate)
642         __cxa_call_terminate(ue_header);
643
644       // Cache the TType base value for __cxa_call_unexpected, as we won't
645       // have an _Unwind_Context then.
646       if (handler_switch_value < 0)
647         {
648           parse_lsda_header (context, language_specific_data, &info);
649
650 #ifdef __ARM_EABI_UNWINDER__
651           const _Unwind_Word* e;
652           _Unwind_Word n;
653           
654           e = ((const _Unwind_Word*) info.TType) - handler_switch_value - 1;
655           // Count the number of rtti objects.
656           n = 0;
657           while (e[n] != 0)
658             n++;
659
660           // Count.
661           ue_header->barrier_cache.bitpattern[1] = n;
662           // Base (obsolete)
663           ue_header->barrier_cache.bitpattern[2] = 0;
664           // Stride.
665           ue_header->barrier_cache.bitpattern[3] = 4;
666           // List head.
667           ue_header->barrier_cache.bitpattern[4] = (_Unwind_Word) e;
668 #else
669           xh->catchTemp = base_of_encoded_value (info.ttype_encoding, context);
670 #endif
671         }
672     }
673
674   /* For targets with pointers smaller than the word size, we must extend the
675      pointer, and this extension is target dependent.  */
676   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
677                  __builtin_extend_pointer (ue_header));
678   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
679                  handler_switch_value);
680   _Unwind_SetIP (context, landing_pad);
681 #ifdef __ARM_EABI_UNWINDER__
682   if (found_type == found_cleanup)
683     __cxa_begin_cleanup(ue_header);
684 #endif
685   return _URC_INSTALL_CONTEXT;
686 }
687
688 /* The ARM EABI implementation of __cxa_call_unexpected is in a
689    different file so that the personality routine (PR) can be used
690    standalone.  The generic routine shared datastructures with the PR
691    so it is most convenient to implement it here.  */
692 #ifndef __ARM_EABI_UNWINDER__
693 extern "C" void
694 __cxa_call_unexpected (void *exc_obj_in)
695 {
696   _Unwind_Exception *exc_obj
697     = reinterpret_cast <_Unwind_Exception *>(exc_obj_in);
698
699   __cxa_begin_catch (exc_obj);
700
701   // This function is a handler for our exception argument.  If we exit
702   // by throwing a different exception, we'll need the original cleaned up.
703   struct end_catch_protect
704   {
705     end_catch_protect() { }
706     ~end_catch_protect() { __cxa_end_catch(); }
707   } end_catch_protect_obj;
708
709   lsda_header_info info;
710   __cxa_exception *xh = __get_exception_header_from_ue (exc_obj);
711   const unsigned char *xh_lsda;
712   _Unwind_Sword xh_switch_value;
713   std::terminate_handler xh_terminate_handler;
714
715   // If the unexpectedHandler rethrows the exception (e.g. to categorize it),
716   // it will clobber data about the current handler.  So copy the data out now.
717   xh_lsda = xh->languageSpecificData;
718   xh_switch_value = xh->handlerSwitchValue;
719   xh_terminate_handler = xh->terminateHandler;
720   info.ttype_base = (_Unwind_Ptr) xh->catchTemp;
721
722   try 
723     { __unexpected (xh->unexpectedHandler); } 
724   catch(...) 
725     {
726       // Get the exception thrown from unexpected.
727
728       __cxa_eh_globals *globals = __cxa_get_globals_fast ();
729       __cxa_exception *new_xh = globals->caughtExceptions;
730       void *new_ptr = new_xh + 1;
731
732       // We don't quite have enough stuff cached; re-parse the LSDA.
733       parse_lsda_header (0, xh_lsda, &info);
734
735       // If this new exception meets the exception spec, allow it.
736       if (check_exception_spec (&info, new_xh->exceptionType,
737                                 new_ptr, xh_switch_value))
738         __throw_exception_again;
739
740       // If the exception spec allows std::bad_exception, throw that.
741       // We don't have a thrown object to compare against, but since
742       // bad_exception doesn't have virtual bases, that's OK; just pass 0.
743 #ifdef __EXCEPTIONS  
744       const std::type_info &bad_exc = typeid (std::bad_exception);
745       if (check_exception_spec (&info, &bad_exc, 0, xh_switch_value))
746         throw std::bad_exception();
747 #endif   
748
749       // Otherwise, die.
750       __terminate (xh_terminate_handler);
751     }
752 }
753 #endif
754
755 } // namespace __cxxabiv1