libstdc++-v3/libsupc++/unwind-cxx.h

   1 // -*- C++ -*- Exception handling and frame unwind runtime interface routines.
   2 // Copyright (C) 2001 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, 59 Temple Place - Suite 330,
  19 // Boston, MA 02111-1307, 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 // This is derived from the C++ ABI for IA-64.  Where we diverge
  31 // for cross-architecture compatibility are noted with "@@@".
  32
  33 #ifndef _UNWIND_CXX_H
  34 #define _UNWIND_CXX_H 1
  35
  36 // Level 2: C++ ABI
  37
  38 #include <typeinfo>
  39 #include <exception>
  40 #include <cstddef>
  41 #include "unwind.h"
  42
  43 namespace __cxxabiv1
  44 {
  45
  46 // A C++ exception object consists of a header, which is a wrapper around
  47 // an unwind object header with additional C++ specific information,
  48 // followed by the exception object itself.
  49
  50 struct __cxa_exception
  51 {
  52   // Manage the exception object itself.
  53   std::type_info *exceptionType;
  54   void (*exceptionDestructor)(void *);
  55
  56   // The C++ standard has entertaining rules wrt calling set_terminate
  57   // and set_unexpected in the middle of the exception cleanup process.
  58   std::unexpected_handler unexpectedHandler;
  59   std::terminate_handler terminateHandler;
  60
  61   // The caught exception stack threads through here.
  62   __cxa_exception *nextException;
  63
  64   // How many nested handlers have caught this exception.  A negated
  65   // value is a signal that this object has been rethrown.
  66   int handlerCount;
  67
  68   // Cache parsed handler data from the personality routine Phase 1
  69   // for Phase 2 and __cxa_call_unexpected.
  70   int handlerSwitchValue;
  71   const unsigned char *actionRecord;
  72   const unsigned char *languageSpecificData;
  73   _Unwind_Ptr catchTemp;
  74   void *adjustedPtr;
  75
  76   // The generic exception header.  Must be last.
  77   _Unwind_Exception unwindHeader;
  78 };
  79
  80 // Each thread in a C++ program has access to a __cxa_eh_globals object.
  81 struct __cxa_eh_globals
  82 {
  83   __cxa_exception *caughtExceptions;
  84   unsigned int uncaughtExceptions;
  85 };
  86
  87
  88 // The __cxa_eh_globals for the current thread can be obtained by using
  89 // either of the following functions.  The "fast" version assumes at least
  90 // one prior call of __cxa_get_globals has been made from the current
  91 // thread, so no initialization is necessary.
  92 extern "C" __cxa_eh_globals *__cxa_get_globals () throw();
  93 extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw();
  94
  95 // Allocate memory for the exception plus the thown object.
  96 extern "C" void *__cxa_allocate_exception(std::size_t thrown_size) throw();
  97
  98 // Free the space allocated for the exception.
  99 extern "C" void __cxa_free_exception(void *thrown_exception) throw();
 100
 101 // Throw the exception.
 102 extern "C" void __cxa_throw (void *thrown_exception,
 103                              std::type_info *tinfo,
 104                              void (*dest) (void *))
 105      __attribute__((noreturn));
 106
 107 // Used to implement exception handlers.
 108 extern "C" void *__cxa_begin_catch (void *) throw();
 109 extern "C" void __cxa_end_catch ();
 110 extern "C" void __cxa_rethrow () __attribute__((noreturn));
 111
 112 // These facilitate code generation for recurring situations.
 113 extern "C" void __cxa_bad_cast ();
 114 extern "C" void __cxa_bad_typeid ();
 115
 116 // @@@ These are not directly specified by the IA-64 C++ ABI.
 117
 118 // Handles re-checking the exception specification if unexpectedHandler
 119 // throws, and if bad_exception needs to be thrown.  Called from the
 120 // compiler.
 121 extern "C" void __cxa_call_unexpected (void *) __attribute__((noreturn));
 122
 123 // Invokes given handler, dying appropriately if the user handler was
 124 // so inconsiderate as to return.
 125 extern void __terminate(std::terminate_handler) __attribute__((noreturn));
 126 extern void __unexpected(std::unexpected_handler) __attribute__((noreturn));
 127
 128 // The current installed user handlers.
 129 extern std::terminate_handler __terminate_handler;
 130 extern std::unexpected_handler __unexpected_handler;
 131
 132 // These are explicitly GNU C++ specific.
 133
 134 // This is the exception class we report -- "GNUCC++\0".
 135 const _Unwind_Exception_Class __gxx_exception_class
 136 = ((((((((_Unwind_Exception_Class) 'G'
 137          << 8 | (_Unwind_Exception_Class) 'N')
 138         << 8 | (_Unwind_Exception_Class) 'U')
 139        << 8 | (_Unwind_Exception_Class) 'C')
 140       << 8 | (_Unwind_Exception_Class) 'C')
 141      << 8 | (_Unwind_Exception_Class) '+')
 142     << 8 | (_Unwind_Exception_Class) '+')
 143    << 8 | (_Unwind_Exception_Class) '\0');
 144
 145 // GNU C++ personality routine, Version 0.
 146 extern "C" _Unwind_Reason_Code __gxx_personality_v0
 147      (int, _Unwind_Action, _Unwind_Exception_Class,
 148       struct _Unwind_Exception *, struct _Unwind_Context *);
 149
 150 // GNU C++ sjlj personality routine, Version 0.
 151 extern "C" _Unwind_Reason_Code __gxx_personality_sj0
 152      (int, _Unwind_Action, _Unwind_Exception_Class,
 153       struct _Unwind_Exception *, struct _Unwind_Context *);
 154
 155 // Acquire the C++ exception header from the C++ object.
 156 static inline __cxa_exception *
 157 __get_exception_header_from_obj (void *ptr)
 158 {
 159   return reinterpret_cast<__cxa_exception *>(ptr) - 1;
 160 }
 161
 162 // Acquire the C++ exception header from the generic exception header.
 163 static inline __cxa_exception *
 164 __get_exception_header_from_ue (_Unwind_Exception *exc)
 165 {
 166   return reinterpret_cast<__cxa_exception *>(exc + 1) - 1;
 167 }
 168
 169 } /* namespace __cxxabiv1 */
 170
 171 #endif // _UNWIND_CXX_H