1 // -*- C++ -*- The GNU C++ exception personality routine. 2 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 3 // 2011 4 // Free Software Foundation, Inc. 5 // 6 // This file is part of GCC. 7 // 8 // GCC is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3, or (at your option) 11 // any later version. 12 // 13 // GCC is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 // 18 // Under Section 7 of GPL version 3, you are granted additional 19 // permissions described in the GCC Runtime Library Exception, version 20 // 3.1, as published by the Free Software Foundation. 21 22 // You should have received a copy of the GNU General Public License and 23 // a copy of the GCC Runtime Library Exception along with this program; 24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 25 // <http://www.gnu.org/licenses/>. 26 27 #include <bits/c++config.h> 28 #include <cstdlib> 29 #include <bits/exception_defines.h> 30 #include <cxxabi.h> 31 #include "unwind-cxx.h" 32 33 34 using namespace __cxxabiv1; 35 36 #include "unwind-pe.h" 37 38 39 struct lsda_header_info 40 { 41 _Unwind_Ptr Start; 42 _Unwind_Ptr LPStart; 43 _Unwind_Ptr ttype_base; 44 const unsigned char *TType; 45 const unsigned char *action_table; 46 unsigned char ttype_encoding; 47 unsigned char call_site_encoding; 48 }; 49 50 static const unsigned char * 51 parse_lsda_header (_Unwind_Context *context, const unsigned char *p, 52 lsda_header_info *info) 53 { 54 _uleb128_t tmp; 55 unsigned char lpstart_encoding; 56 57 info->Start = (context ? _Unwind_GetRegionStart (context) : 0); 58 59 // Find @LPStart, the base to which landing pad offsets are relative. 60 lpstart_encoding = *p++; 61 if (lpstart_encoding != DW_EH_PE_omit) 62 p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart); 63 else 64 info->LPStart = info->Start; 65 66 // Find @TType, the base of the handler and exception spec type data. 67 info->ttype_encoding = *p++; 68 if (info->ttype_encoding != DW_EH_PE_omit) 69 { 70 #if _GLIBCXX_OVERRIDE_TTYPE_ENCODING 71 /* Older ARM EABI toolchains set this value incorrectly, so use a 72 hardcoded OS-specific format. */ 73 info->ttype_encoding = _GLIBCXX_OVERRIDE_TTYPE_ENCODING; 74 #endif 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 // Return an element from a type table. 91 92 static const std::type_info * 93 get_ttype_entry (lsda_header_info *info, _uleb128_t i) 94 { 95 _Unwind_Ptr ptr; 96 97 i *= size_of_encoded_value (info->ttype_encoding); 98 read_encoded_value_with_base (info->ttype_encoding, info->ttype_base, 99 info->TType - i, &ptr); 100 101 return reinterpret_cast<const std::type_info *>(ptr); 102 } 103 104 #ifdef __ARM_EABI_UNWINDER__ 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_typeinfo_ptr(info->ttype_base, (_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, UNWIND_STACK_REG); 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 // Given the thrown type THROW_TYPE, pointer to a variable containing a 212 // pointer to the exception object THROWN_PTR_P and a type CATCH_TYPE to 213 // compare against, return whether or not there is a match and if so, 214 // update *THROWN_PTR_P. 215 216 static bool 217 get_adjusted_ptr (const std::type_info *catch_type, 218 const std::type_info *throw_type, 219 void **thrown_ptr_p) 220 { 221 void *thrown_ptr = *thrown_ptr_p; 222 223 // Pointer types need to adjust the actual pointer, not 224 // the pointer to pointer that is the exception object. 225 // This also has the effect of passing pointer types 226 // "by value" through the __cxa_begin_catch return value. 227 if (throw_type->__is_pointer_p ()) 228 thrown_ptr = *(void **) thrown_ptr; 229 230 if (catch_type->__do_catch (throw_type, &thrown_ptr, 1)) 231 { 232 *thrown_ptr_p = thrown_ptr; 233 return true; 234 } 235 236 return false; 237 } 238 239 // Return true if THROW_TYPE matches one if the filter types. 240 241 static bool 242 check_exception_spec(lsda_header_info* info, _throw_typet* throw_type, 243 void* thrown_ptr, _sleb128_t filter_value) 244 { 245 const unsigned char *e = info->TType - filter_value - 1; 246 247 while (1) 248 { 249 const std::type_info *catch_type; 250 _uleb128_t tmp; 251 252 e = read_uleb128 (e, &tmp); 253 254 // Zero signals the end of the list. If we've not found 255 // a match by now, then we've failed the specification. 256 if (tmp == 0) 257 return false; 258 259 // Match a ttype entry. 260 catch_type = get_ttype_entry (info, tmp); 261 262 // ??? There is currently no way to ask the RTTI code about the 263 // relationship between two types without reference to a specific 264 // object. There should be; then we wouldn't need to mess with 265 // thrown_ptr here. 266 if (get_adjusted_ptr (catch_type, throw_type, &thrown_ptr)) 267 return true; 268 } 269 } 270 271 272 // Save stage1 handler information in the exception object 273 274 static inline void 275 save_caught_exception(struct _Unwind_Exception* ue_header, 276 struct _Unwind_Context* context 277 __attribute__((__unused__)), 278 void* thrown_ptr, 279 int handler_switch_value, 280 const unsigned char* language_specific_data, 281 _Unwind_Ptr landing_pad __attribute__((__unused__)), 282 const unsigned char* action_record) 283 { 284 __cxa_exception* xh = __get_exception_header_from_ue(ue_header); 285 286 xh->handlerSwitchValue = handler_switch_value; 287 xh->actionRecord = action_record; 288 xh->languageSpecificData = language_specific_data; 289 xh->adjustedPtr = thrown_ptr; 290 291 // ??? Completely unknown what this field is supposed to be for. 292 // ??? Need to cache TType encoding base for call_unexpected. 293 xh->catchTemp = landing_pad; 294 } 295 296 297 // Restore the catch handler information saved during phase1. 298 299 static inline void 300 restore_caught_exception(struct _Unwind_Exception* ue_header, 301 int& handler_switch_value, 302 const unsigned char*& language_specific_data, 303 _Unwind_Ptr& landing_pad) 304 { 305 __cxa_exception* xh = __get_exception_header_from_ue(ue_header); 306 handler_switch_value = xh->handlerSwitchValue; 307 language_specific_data = xh->languageSpecificData; 308 landing_pad = (_Unwind_Ptr) xh->catchTemp; 309 } 310 311 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND 312 313 // Return true if the filter spec is empty, ie throw(). 314 315 static bool 316 empty_exception_spec (lsda_header_info *info, _Unwind_Sword filter_value) 317 { 318 const unsigned char *e = info->TType - filter_value - 1; 319 _uleb128_t tmp; 320 321 e = read_uleb128 (e, &tmp); 322 return tmp == 0; 323 } 324 325 #endif // !__ARM_EABI_UNWINDER__ 326 327 namespace __cxxabiv1 328 { 329 330 // Using a different personality function name causes link failures 331 // when trying to mix code using different exception handling models. 332 #ifdef _GLIBCXX_SJLJ_EXCEPTIONS 333 #define PERSONALITY_FUNCTION __gxx_personality_sj0 334 #define __builtin_eh_return_data_regno(x) x 335 #else 336 #define PERSONALITY_FUNCTION __gxx_personality_v0 337 #endif 338 339 extern "C" _Unwind_Reason_Code 340 #ifdef __ARM_EABI_UNWINDER__ 341 PERSONALITY_FUNCTION (_Unwind_State state, 342 struct _Unwind_Exception* ue_header, 343 struct _Unwind_Context* context) 344 #else 345 PERSONALITY_FUNCTION (int version, 346 _Unwind_Action actions, 347 _Unwind_Exception_Class exception_class, 348 struct _Unwind_Exception *ue_header, 349 struct _Unwind_Context *context) 350 #endif 351 { 352 enum found_handler_type 353 { 354 found_nothing, 355 found_terminate, 356 found_cleanup, 357 found_handler 358 } found_type; 359 360 lsda_header_info info; 361 const unsigned char *language_specific_data; 362 const unsigned char *action_record; 363 const unsigned char *p; 364 _Unwind_Ptr landing_pad, ip; 365 int handler_switch_value; 366 void* thrown_ptr = 0; 367 bool foreign_exception; 368 int ip_before_insn = 0; 369 370 #ifdef __ARM_EABI_UNWINDER__ 371 _Unwind_Action actions; 372 373 switch (state & _US_ACTION_MASK) 374 { 375 case _US_VIRTUAL_UNWIND_FRAME: 376 actions = _UA_SEARCH_PHASE; 377 break; 378 379 case _US_UNWIND_FRAME_STARTING: 380 actions = _UA_CLEANUP_PHASE; 381 if (!(state & _US_FORCE_UNWIND) 382 && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 383 UNWIND_STACK_REG)) 384 actions |= _UA_HANDLER_FRAME; 385 break; 386 387 case _US_UNWIND_FRAME_RESUME: 388 CONTINUE_UNWINDING; 389 break; 390 391 default: 392 std::abort(); 393 } 394 actions |= state & _US_FORCE_UNWIND; 395 396 // We don't know which runtime we're working with, so can't check this. 397 // However the ABI routines hide this from us, and we don't actually need 398 // to know. 399 foreign_exception = false; 400 401 // The dwarf unwinder assumes the context structure holds things like the 402 // function and LSDA pointers. The ARM implementation caches these in 403 // the exception header (UCB). To avoid rewriting everything we make a 404 // virtual scratch register point at the UCB. 405 ip = (_Unwind_Ptr) ue_header; 406 _Unwind_SetGR(context, UNWIND_POINTER_REG, ip); 407 #else 408 __cxa_exception* xh = __get_exception_header_from_ue(ue_header); 409 410 // Interface version check. 411 if (version != 1) 412 return _URC_FATAL_PHASE1_ERROR; 413 foreign_exception = !__is_gxx_exception_class(exception_class); 414 #endif 415 416 // Shortcut for phase 2 found handler for domestic exception. 417 if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME) 418 && !foreign_exception) 419 { 420 restore_caught_exception(ue_header, handler_switch_value, 421 language_specific_data, landing_pad); 422 found_type = (landing_pad == 0 ? found_terminate : found_handler); 423 goto install_context; 424 } 425 426 language_specific_data = (const unsigned char *) 427 _Unwind_GetLanguageSpecificData (context); 428 429 // If no LSDA, then there are no handlers or cleanups. 430 if (! language_specific_data) 431 CONTINUE_UNWINDING; 432 433 // Parse the LSDA header. 434 p = parse_lsda_header (context, language_specific_data, &info); 435 info.ttype_base = base_of_encoded_value (info.ttype_encoding, context); 436 #ifdef _GLIBCXX_HAVE_GETIPINFO 437 ip = _Unwind_GetIPInfo (context, &ip_before_insn); 438 #else 439 ip = _Unwind_GetIP (context); 440 #endif 441 if (! ip_before_insn) 442 --ip; 443 landing_pad = 0; 444 action_record = 0; 445 handler_switch_value = 0; 446 447 #ifdef _GLIBCXX_SJLJ_EXCEPTIONS 448 // The given "IP" is an index into the call-site table, with two 449 // exceptions -- -1 means no-action, and 0 means terminate. But 450 // since we're using uleb128 values, we've not got random access 451 // to the array. 452 if ((int) ip < 0) 453 return _URC_CONTINUE_UNWIND; 454 else if (ip == 0) 455 { 456 // Fall through to set found_terminate. 457 } 458 else 459 { 460 _uleb128_t cs_lp, cs_action; 461 do 462 { 463 p = read_uleb128 (p, &cs_lp); 464 p = read_uleb128 (p, &cs_action); 465 } 466 while (--ip); 467 468 // Can never have null landing pad for sjlj -- that would have 469 // been indicated by a -1 call site index. 470 landing_pad = cs_lp + 1; 471 if (cs_action) 472 action_record = info.action_table + cs_action - 1; 473 goto found_something; 474 } 475 #else 476 // Search the call-site table for the action associated with this IP. 477 while (p < info.action_table) 478 { 479 _Unwind_Ptr cs_start, cs_len, cs_lp; 480 _uleb128_t cs_action; 481 482 // Note that all call-site encodings are "absolute" displacements. 483 p = read_encoded_value (0, info.call_site_encoding, p, &cs_start); 484 p = read_encoded_value (0, info.call_site_encoding, p, &cs_len); 485 p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp); 486 p = read_uleb128 (p, &cs_action); 487 488 // The table is sorted, so if we've passed the ip, stop. 489 if (ip < info.Start + cs_start) 490 p = info.action_table; 491 else if (ip < info.Start + cs_start + cs_len) 492 { 493 if (cs_lp) 494 landing_pad = info.LPStart + cs_lp; 495 if (cs_action) 496 action_record = info.action_table + cs_action - 1; 497 goto found_something; 498 } 499 } 500 #endif // _GLIBCXX_SJLJ_EXCEPTIONS 501 502 // If ip is not present in the table, call terminate. This is for 503 // a destructor inside a cleanup, or a library routine the compiler 504 // was not expecting to throw. 505 found_type = found_terminate; 506 goto do_something; 507 508 found_something: 509 if (landing_pad == 0) 510 { 511 // If ip is present, and has a null landing pad, there are 512 // no cleanups or handlers to be run. 513 found_type = found_nothing; 514 } 515 else if (action_record == 0) 516 { 517 // If ip is present, has a non-null landing pad, and a null 518 // action table offset, then there are only cleanups present. 519 // Cleanups use a zero switch value, as set above. 520 found_type = found_cleanup; 521 } 522 else 523 { 524 // Otherwise we have a catch handler or exception specification. 525 526 _sleb128_t ar_filter, ar_disp; 527 const std::type_info* catch_type; 528 _throw_typet* throw_type; 529 bool saw_cleanup = false; 530 bool saw_handler = false; 531 532 #ifdef __ARM_EABI_UNWINDER__ 533 // ??? How does this work - more importantly, how does it interact with 534 // dependent exceptions? 535 throw_type = ue_header; 536 if (actions & _UA_FORCE_UNWIND) 537 { 538 __GXX_INIT_FORCED_UNWIND_CLASS(ue_header->exception_class); 539 } 540 else if (!foreign_exception) 541 thrown_ptr = __get_object_from_ue (ue_header); 542 #else 543 #ifdef __GXX_RTTI 544 // During forced unwinding, match a magic exception type. 545 if (actions & _UA_FORCE_UNWIND) 546 { 547 throw_type = &typeid(abi::__forced_unwind); 548 } 549 // With a foreign exception class, there's no exception type. 550 // ??? What to do about GNU Java and GNU Ada exceptions? 551 else if (foreign_exception) 552 { 553 throw_type = &typeid(abi::__foreign_exception); 554 } 555 else 556 #endif 557 { 558 thrown_ptr = __get_object_from_ue (ue_header); 559 throw_type = __get_exception_header_from_obj 560 (thrown_ptr)->exceptionType; 561 } 562 #endif 563 564 while (1) 565 { 566 p = action_record; 567 p = read_sleb128 (p, &ar_filter); 568 read_sleb128 (p, &ar_disp); 569 570 if (ar_filter == 0) 571 { 572 // Zero filter values are cleanups. 573 saw_cleanup = true; 574 } 575 else if (ar_filter > 0) 576 { 577 // Positive filter values are handlers. 578 catch_type = get_ttype_entry (&info, ar_filter); 579 580 // Null catch type is a catch-all handler; we can catch foreign 581 // exceptions with this. Otherwise we must match types. 582 if (! catch_type 583 || (throw_type 584 && get_adjusted_ptr (catch_type, throw_type, 585 &thrown_ptr))) 586 { 587 saw_handler = true; 588 break; 589 } 590 } 591 else 592 { 593 // Negative filter values are exception specifications. 594 // ??? How do foreign exceptions fit in? As far as I can 595 // see we can't match because there's no __cxa_exception 596 // object to stuff bits in for __cxa_call_unexpected to use. 597 // Allow them iff the exception spec is non-empty. I.e. 598 // a throw() specification results in __unexpected. 599 if ((throw_type 600 && !(actions & _UA_FORCE_UNWIND) 601 && !foreign_exception) 602 ? ! check_exception_spec (&info, throw_type, thrown_ptr, 603 ar_filter) 604 : empty_exception_spec (&info, ar_filter)) 605 { 606 saw_handler = true; 607 break; 608 } 609 } 610 611 if (ar_disp == 0) 612 break; 613 action_record = p + ar_disp; 614 } 615 616 if (saw_handler) 617 { 618 handler_switch_value = ar_filter; 619 found_type = found_handler; 620 } 621 else 622 found_type = (saw_cleanup ? found_cleanup : found_nothing); 623 } 624 625 do_something: 626 if (found_type == found_nothing) 627 CONTINUE_UNWINDING; 628 629 if (actions & _UA_SEARCH_PHASE) 630 { 631 if (found_type == found_cleanup) 632 CONTINUE_UNWINDING; 633 634 // For domestic exceptions, we cache data from phase 1 for phase 2. 635 if (!foreign_exception) 636 { 637 save_caught_exception(ue_header, context, thrown_ptr, 638 handler_switch_value, language_specific_data, 639 landing_pad, action_record); 640 } 641 return _URC_HANDLER_FOUND; 642 } 643 644 install_context: 645 646 // We can't use any of the cxa routines with foreign exceptions, 647 // because they all expect ue_header to be a struct __cxa_exception. 648 // So in that case, call terminate or unexpected directly. 649 if ((actions & _UA_FORCE_UNWIND) 650 || foreign_exception) 651 { 652 if (found_type == found_terminate) 653 std::terminate (); 654 else if (handler_switch_value < 0) 655 { 656 __try 657 { std::unexpected (); } 658 __catch(...) 659 { std::terminate (); } 660 } 661 } 662 else 663 { 664 if (found_type == found_terminate) 665 __cxa_call_terminate(ue_header); 666 667 // Cache the TType base value for __cxa_call_unexpected, as we won't 668 // have an _Unwind_Context then. 669 if (handler_switch_value < 0) 670 { 671 parse_lsda_header (context, language_specific_data, &info); 672 info.ttype_base = base_of_encoded_value (info.ttype_encoding, 673 context); 674 675 #ifdef __ARM_EABI_UNWINDER__ 676 const _Unwind_Word* e; 677 _Unwind_Word n; 678 679 e = ((const _Unwind_Word*) info.TType) - handler_switch_value - 1; 680 // Count the number of rtti objects. 681 n = 0; 682 while (e[n] != 0) 683 n++; 684 685 // Count. 686 ue_header->barrier_cache.bitpattern[1] = n; 687 // Base 688 ue_header->barrier_cache.bitpattern[2] = info.ttype_base; 689 // Stride. 690 ue_header->barrier_cache.bitpattern[3] = 4; 691 // List head. 692 ue_header->barrier_cache.bitpattern[4] = (_Unwind_Word) e; 693 #else 694 xh->catchTemp = base_of_encoded_value (info.ttype_encoding, context); 695 #endif 696 } 697 } 698 699 /* For targets with pointers smaller than the word size, we must extend the 700 pointer, and this extension is target dependent. */ 701 _Unwind_SetGR (context, __builtin_eh_return_data_regno (0), 702 __builtin_extend_pointer (ue_header)); 703 _Unwind_SetGR (context, __builtin_eh_return_data_regno (1), 704 handler_switch_value); 705 _Unwind_SetIP (context, landing_pad); 706 #ifdef __ARM_EABI_UNWINDER__ 707 if (found_type == found_cleanup) 708 __cxa_begin_cleanup(ue_header); 709 #endif 710 return _URC_INSTALL_CONTEXT; 711 } 712 713 /* The ARM EABI implementation of __cxa_call_unexpected is in a 714 different file so that the personality routine (PR) can be used 715 standalone. The generic routine shared datastructures with the PR 716 so it is most convenient to implement it here. */ 717 #ifndef __ARM_EABI_UNWINDER__ 718 extern "C" void 719 __cxa_call_unexpected (void *exc_obj_in) 720 { 721 _Unwind_Exception *exc_obj 722 = reinterpret_cast <_Unwind_Exception *>(exc_obj_in); 723 724 __cxa_begin_catch (exc_obj); 725 726 // This function is a handler for our exception argument. If we exit 727 // by throwing a different exception, we'll need the original cleaned up. 728 struct end_catch_protect 729 { 730 end_catch_protect() { } 731 ~end_catch_protect() { __cxa_end_catch(); } 732 } end_catch_protect_obj; 733 734 lsda_header_info info; 735 __cxa_exception *xh = __get_exception_header_from_ue (exc_obj); 736 const unsigned char *xh_lsda; 737 _Unwind_Sword xh_switch_value; 738 std::terminate_handler xh_terminate_handler; 739 740 // If the unexpectedHandler rethrows the exception (e.g. to categorize it), 741 // it will clobber data about the current handler. So copy the data out now. 742 xh_lsda = xh->languageSpecificData; 743 xh_switch_value = xh->handlerSwitchValue; 744 xh_terminate_handler = xh->terminateHandler; 745 info.ttype_base = (_Unwind_Ptr) xh->catchTemp; 746 747 __try 748 { __unexpected (xh->unexpectedHandler); } 749 __catch(...) 750 { 751 // Get the exception thrown from unexpected. 752 753 __cxa_eh_globals *globals = __cxa_get_globals_fast (); 754 __cxa_exception *new_xh = globals->caughtExceptions; 755 void *new_ptr = __get_object_from_ambiguous_exception (new_xh); 756 757 // We don't quite have enough stuff cached; re-parse the LSDA. 758 parse_lsda_header (0, xh_lsda, &info); 759 760 // If this new exception meets the exception spec, allow it. 761 if (check_exception_spec (&info, __get_exception_header_from_obj 762 (new_ptr)->exceptionType, 763 new_ptr, xh_switch_value)) 764 __throw_exception_again; 765 766 // If the exception spec allows std::bad_exception, throw that. 767 // We don't have a thrown object to compare against, but since 768 // bad_exception doesn't have virtual bases, that's OK; just pass 0. 769 #if defined(__EXCEPTIONS) && defined(__GXX_RTTI) 770 const std::type_info &bad_exc = typeid (std::bad_exception); 771 if (check_exception_spec (&info, &bad_exc, 0, xh_switch_value)) 772 throw std::bad_exception(); 773 #endif 774 775 // Otherwise, die. 776 __terminate (xh_terminate_handler); 777 } 778 } 779 #endif 780 781 } // namespace __cxxabiv1 782