bbcc0072730074c3c87dd5c51b9c1bddd3c23a05
[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       // During forced unwinding, match a magic exception type.
546       if (actions & _UA_FORCE_UNWIND)
547         {
548           throw_type = &typeid(abi::__forced_unwind);
549           thrown_ptr = 0;
550         }
551       // With a foreign exception class, there's no exception type.
552       // ??? What to do about GNU Java and GNU Ada exceptions?
553       else if (foreign_exception)
554         {
555           throw_type = &typeid(abi::__foreign_exception);
556           thrown_ptr = 0;
557         }
558       else
559 #ifdef __ARM_EABI_UNWINDER__
560         throw_type = ue_header;
561 #else
562         throw_type = xh->exceptionType;
563 #endif
564
565       while (1)
566         {
567           p = action_record;
568           p = read_sleb128 (p, &ar_filter);
569           read_sleb128 (p, &ar_disp);
570
571           if (ar_filter == 0)
572             {
573               // Zero filter values are cleanups.
574               saw_cleanup = true;
575             }
576           else if (ar_filter > 0)
577             {
578               // Positive filter values are handlers.
579               catch_type = get_ttype_entry (&info, ar_filter);
580
581               // Null catch type is a catch-all handler; we can catch foreign
582               // exceptions with this.  Otherwise we must match types.
583               if (! catch_type
584                   || (throw_type
585                       && get_adjusted_ptr (catch_type, throw_type,
586                                            &thrown_ptr)))
587                 {
588                   saw_handler = true;
589                   break;
590                 }
591             }
592           else
593             {
594               // Negative filter values are exception specifications.
595               // ??? How do foreign exceptions fit in?  As far as I can
596               // see we can't match because there's no __cxa_exception
597               // object to stuff bits in for __cxa_call_unexpected to use.
598               // Allow them iff the exception spec is non-empty.  I.e.
599               // a throw() specification results in __unexpected.
600               if ((throw_type
601                    && !(actions & _UA_FORCE_UNWIND)
602                    && !foreign_exception)
603                   ? ! check_exception_spec (&info, throw_type, thrown_ptr,
604                                             ar_filter)
605                   : empty_exception_spec (&info, ar_filter))
606                 {
607                   saw_handler = true;
608                   break;
609                 }
610             }
611
612           if (ar_disp == 0)
613             break;
614           action_record = p + ar_disp;
615         }
616
617       if (saw_handler)
618         {
619           handler_switch_value = ar_filter;
620           found_type = found_handler;
621         }
622       else
623         found_type = (saw_cleanup ? found_cleanup : found_nothing);
624     }
625
626  do_something:
627    if (found_type == found_nothing)
628      CONTINUE_UNWINDING;
629
630   if (actions & _UA_SEARCH_PHASE)
631     {
632       if (found_type == found_cleanup)
633         CONTINUE_UNWINDING;
634
635       // For domestic exceptions, we cache data from phase 1 for phase 2.
636       if (!foreign_exception)
637         {
638           save_caught_exception(ue_header, context, thrown_ptr,
639                                 handler_switch_value, language_specific_data,
640                                 landing_pad, action_record);
641         }
642       return _URC_HANDLER_FOUND;
643     }
644
645  install_context:
646   
647   // We can't use any of the cxa routines with foreign exceptions,
648   // because they all expect ue_header to be a struct __cxa_exception.
649   // So in that case, call terminate or unexpected directly.
650   if ((actions & _UA_FORCE_UNWIND)
651       || foreign_exception)
652     {
653       if (found_type == found_terminate)
654         std::terminate ();
655       else if (handler_switch_value < 0)
656         {
657           try 
658             { std::unexpected (); } 
659           catch(...) 
660             { std::terminate (); }
661         }
662     }
663   else
664     {
665       if (found_type == found_terminate)
666         __cxa_call_terminate(ue_header);
667
668       // Cache the TType base value for __cxa_call_unexpected, as we won't
669       // have an _Unwind_Context then.
670       if (handler_switch_value < 0)
671         {
672           parse_lsda_header (context, language_specific_data, &info);
673
674 #ifdef __ARM_EABI_UNWINDER__
675           const _Unwind_Word* e;
676           _Unwind_Word n;
677           
678           e = ((const _Unwind_Word*) info.TType) - handler_switch_value - 1;
679           // Count the number of rtti objects.
680           n = 0;
681           while (e[n] != 0)
682             n++;
683
684           // Count.
685           ue_header->barrier_cache.bitpattern[1] = n;
686           // Base (obsolete)
687           ue_header->barrier_cache.bitpattern[2] = 0;
688           // Stride.
689           ue_header->barrier_cache.bitpattern[3] = 4;
690           // List head.
691           ue_header->barrier_cache.bitpattern[4] = (_Unwind_Word) e;
692 #else
693           xh->catchTemp = base_of_encoded_value (info.ttype_encoding, context);
694 #endif
695         }
696     }
697
698   /* For targets with pointers smaller than the word size, we must extend the
699      pointer, and this extension is target dependent.  */
700   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
701                  __builtin_extend_pointer (ue_header));
702   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
703                  handler_switch_value);
704   _Unwind_SetIP (context, landing_pad);
705 #ifdef __ARM_EABI_UNWINDER__
706   if (found_type == found_cleanup)
707     __cxa_begin_cleanup(ue_header);
708 #endif
709   return _URC_INSTALL_CONTEXT;
710 }
711
712 /* The ARM EABI implementation of __cxa_call_unexpected is in a
713    different file so that the personality routine (PR) can be used
714    standalone.  The generic routine shared datastructures with the PR
715    so it is most convenient to implement it here.  */
716 #ifndef __ARM_EABI_UNWINDER__
717 extern "C" void
718 __cxa_call_unexpected (void *exc_obj_in)
719 {
720   _Unwind_Exception *exc_obj
721     = reinterpret_cast <_Unwind_Exception *>(exc_obj_in);
722
723   __cxa_begin_catch (exc_obj);
724
725   // This function is a handler for our exception argument.  If we exit
726   // by throwing a different exception, we'll need the original cleaned up.
727   struct end_catch_protect
728   {
729     end_catch_protect() { }
730     ~end_catch_protect() { __cxa_end_catch(); }
731   } end_catch_protect_obj;
732
733   lsda_header_info info;
734   __cxa_exception *xh = __get_exception_header_from_ue (exc_obj);
735   const unsigned char *xh_lsda;
736   _Unwind_Sword xh_switch_value;
737   std::terminate_handler xh_terminate_handler;
738
739   // If the unexpectedHandler rethrows the exception (e.g. to categorize it),
740   // it will clobber data about the current handler.  So copy the data out now.
741   xh_lsda = xh->languageSpecificData;
742   xh_switch_value = xh->handlerSwitchValue;
743   xh_terminate_handler = xh->terminateHandler;
744   info.ttype_base = (_Unwind_Ptr) xh->catchTemp;
745
746   try 
747     { __unexpected (xh->unexpectedHandler); } 
748   catch(...) 
749     {
750       // Get the exception thrown from unexpected.
751
752       __cxa_eh_globals *globals = __cxa_get_globals_fast ();
753       __cxa_exception *new_xh = globals->caughtExceptions;
754       void *new_ptr = new_xh + 1;
755
756       // We don't quite have enough stuff cached; re-parse the LSDA.
757       parse_lsda_header (0, xh_lsda, &info);
758
759       // If this new exception meets the exception spec, allow it.
760       if (check_exception_spec (&info, new_xh->exceptionType,
761                                 new_ptr, xh_switch_value))
762         __throw_exception_again;
763
764       // If the exception spec allows std::bad_exception, throw that.
765       // We don't have a thrown object to compare against, but since
766       // bad_exception doesn't have virtual bases, that's OK; just pass 0.
767 #ifdef __EXCEPTIONS  
768       const std::type_info &bad_exc = typeid (std::bad_exception);
769       if (check_exception_spec (&info, &bad_exc, 0, xh_switch_value))
770         throw std::bad_exception();
771 #endif   
772
773       // Otherwise, die.
774       __terminate (xh_terminate_handler);
775     }
776 }
777 #endif
778
779 } // namespace __cxxabiv1