libstdc++-v3/libsupc++/eh_call.cc

   1 // -*- C++ -*- Helpers for calling unextected and terminate
   2 // Copyright (C) 2001, 2002, 2003 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 #include "unwind-pe.h"
  38
  39
  40 // Helper routine for when the exception handling code needs to call
  41 // terminate.
  42
  43 extern "C" void
  44 __cxa_call_terminate(_Unwind_Exception* ue_header)
  45 {
  46
  47   if (ue_header)
  48     {
  49       // terminate is classed as a catch handler.
  50       __cxa_begin_catch(ue_header);
  51
  52       // Call the terminate handler that was in effect when we threw this
  53       // exception.  */
  54       if (__is_gxx_exception_class(ue_header->exception_class))
  55         {
  56           __cxa_exception* xh;
  57
  58           xh = __get_exception_header_from_ue(ue_header);
  59           __terminate(xh->terminateHandler);
  60         }
  61     }
  62   /* Call the global routine if we don't have anything better.  */
  63   std::terminate();
  64 }
  65
  66
  67 #ifdef __ARM_EABI_UNWINDER__
  68 // The ARM EABI __cxa_call_unexpected has the same semantics as the generic
  69 // routine, but the exception specification has a different format.
  70 extern "C" void
  71 __cxa_call_unexpected(void* exc_obj_in)
  72 {
  73   _Unwind_Exception* exc_obj
  74     = reinterpret_cast<_Unwind_Exception*>(exc_obj_in);
  75
  76   int rtti_count = 0;
  77   _Unwind_Word rtti_stride = 0;
  78   _Unwind_Word* rtti_list = NULL;
  79   bool foreign_exception;
  80   std::unexpected_handler unexpectedHandler = NULL;
  81   std::terminate_handler terminateHandler = NULL;
  82   __cxa_exception* xh;
  83   if (__is_gxx_exception_class(exc_obj->exception_class))
  84     {
  85       // Save data from the EO, which may be clobbered by _cxa_begin_catch.
  86       xh = __get_exception_header_from_ue(exc_obj);
  87       unexpectedHandler = xh->unexpectedHandler;
  88       terminateHandler = xh->terminateHandler;
  89       rtti_count = exc_obj->barrier_cache.bitpattern[1];
  90
  91       rtti_stride = exc_obj->barrier_cache.bitpattern[3];
  92       rtti_list = (_Unwind_Word*) exc_obj->barrier_cache.bitpattern[4];
  93       foreign_exception = false;
  94     }
  95   else
  96     foreign_exception = true;
  97
  98   /* This must be called after extracting data from the EO, but before
  99      calling unexpected().   */
 100   __cxa_begin_catch(exc_obj);
 101
 102   // This function is a handler for our exception argument.  If we exit
 103   // by throwing a different exception, we'll need the original cleaned up.
 104   struct end_catch_protect
 105   {
 106     end_catch_protect() { }
 107     ~end_catch_protect() { __cxa_end_catch(); }
 108   } end_catch_protect_obj;
 109
 110
 111   try
 112     {
 113       if (foreign_exception)
 114         std::unexpected();
 115       else
 116         __unexpected(unexpectedHandler);
 117     }
 118   catch(...)
 119     {
 120       /* See if the new exception matches the rtti list.  */
 121       if (foreign_exception)
 122         std::terminate();
 123
 124       // Get the exception thrown from unexpected.
 125
 126       __cxa_eh_globals* globals = __cxa_get_globals_fast();
 127       __cxa_exception* new_xh = globals->caughtExceptions;
 128       void* new_ptr = new_xh + 1;
 129       const std::type_info* catch_type;
 130       int n;
 131       bool bad_exception_allowed = false;
 132       const std::type_info& bad_exc = typeid(std::bad_exception);
 133
 134       // Check the new exception against the rtti list
 135       for (n = 0; n < rtti_count; n++)
 136         {
 137           _Unwind_Word offset;
 138
 139           offset = (_Unwind_Word) &rtti_list[n * (rtti_stride >> 2)];
 140           offset = _Unwind_decode_target2(offset);
 141           catch_type = (const std::type_info*) (offset);
 142
 143           if (__cxa_type_match(&new_xh->unwindHeader, catch_type, false,
 144                                &new_ptr) != ctm_failed)
 145             __throw_exception_again;
 146
 147           if (catch_type->__do_catch(&bad_exc, 0, 1))
 148             bad_exception_allowed = true;
 149         }
 150
 151       // If the exception spec allows std::bad_exception, throw that.
 152 #ifdef __EXCEPTIONS
 153       if (bad_exception_allowed)
 154         throw std::bad_exception();
 155 #endif
 156
 157       // Otherwise, die.
 158       __terminate(terminateHandler);
 159     }
 160 }
 161 #endif // __ARM_EABI_UNWINDER__