libstdc++
cxxabi.h
Go to the documentation of this file.
00001 // ABI Support -*- C++ -*-
00002 
00003 // Copyright (C) 2000-2013 Free Software Foundation, Inc.
00004 //
00005 // This file is part of GCC.
00006 //
00007 // GCC is free software; you can redistribute it and/or modify
00008 // it under the terms of the GNU General Public License as published by
00009 // the Free Software Foundation; either version 3, or (at your option)
00010 // any later version.
00011 //
00012 // GCC is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 //
00017 // Under Section 7 of GPL version 3, you are granted additional
00018 // permissions described in the GCC Runtime Library Exception, version
00019 // 3.1, as published by the Free Software Foundation.
00020 
00021 // You should have received a copy of the GNU General Public License and
00022 // a copy of the GCC Runtime Library Exception along with this program;
00023 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00024 // <http://www.gnu.org/licenses/>.
00025 
00026 // Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
00027 
00028 /* This file declares the new abi entry points into the runtime. It is not
00029    normally necessary for user programs to include this header, or use the
00030    entry points directly. However, this header is available should that be
00031    needed.
00032 
00033    Some of the entry points are intended for both C and C++, thus this header
00034    is includable from both C and C++. Though the C++ specific parts are not
00035    available in C, naturally enough.  */
00036 
00037 /** @file cxxabi.h
00038  *  The header provides an interface to the C++ ABI.
00039  */
00040 
00041 #ifndef _CXXABI_H
00042 #define _CXXABI_H 1
00043 
00044 #pragma GCC system_header
00045 
00046 #pragma GCC visibility push(default)
00047 
00048 #include <stddef.h>
00049 #include <bits/c++config.h>
00050 #include <bits/cxxabi_tweaks.h>
00051 #include <bits/cxxabi_forced.h>
00052 
00053 #ifndef _GLIBCXX_CDTOR_CALLABI
00054 #define _GLIBCXX_CDTOR_CALLABI
00055 #endif
00056 
00057 #ifdef __cplusplus
00058 namespace __cxxabiv1
00059 {
00060   extern "C"
00061   {
00062 #endif
00063 
00064   typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
00065 
00066   // Allocate array.
00067   void*
00068   __cxa_vec_new(size_t __element_count, size_t __element_size,
00069         size_t __padding_size, __cxa_cdtor_type __constructor,
00070         __cxa_cdtor_type __destructor);
00071 
00072   void*
00073   __cxa_vec_new2(size_t __element_count, size_t __element_size,
00074          size_t __padding_size, __cxa_cdtor_type __constructor,
00075          __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
00076          void (*__dealloc) (void*));
00077 
00078   void*
00079   __cxa_vec_new3(size_t __element_count, size_t __element_size,
00080          size_t __padding_size, __cxa_cdtor_type __constructor,
00081          __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
00082          void (*__dealloc) (void*, size_t));
00083 
00084   // Construct array.
00085   __cxa_vec_ctor_return_type
00086   __cxa_vec_ctor(void* __array_address, size_t __element_count,
00087          size_t __element_size, __cxa_cdtor_type __constructor,
00088          __cxa_cdtor_type __destructor);
00089 
00090   __cxa_vec_ctor_return_type
00091   __cxa_vec_cctor(void* __dest_array, void* __src_array,
00092           size_t __element_count, size_t __element_size,
00093           __cxa_cdtor_return_type (*__constructor) (void*, void*),
00094           __cxa_cdtor_type __destructor);
00095 
00096   // Destruct array.
00097   void
00098   __cxa_vec_dtor(void* __array_address, size_t __element_count,
00099          size_t __element_size, __cxa_cdtor_type __destructor);
00100 
00101   void
00102   __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
00103             __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW;
00104 
00105   // Destruct and release array.
00106   void
00107   __cxa_vec_delete(void* __array_address, size_t __element_size,
00108            size_t __padding_size, __cxa_cdtor_type __destructor);
00109 
00110   void
00111   __cxa_vec_delete2(void* __array_address, size_t __element_size,
00112             size_t __padding_size, __cxa_cdtor_type __destructor,
00113             void (*__dealloc) (void*));
00114 
00115   void
00116   __cxa_vec_delete3(void* __array_address, size_t __element_size,
00117             size_t __padding_size, __cxa_cdtor_type __destructor,
00118             void (*__dealloc) (void*, size_t));
00119 
00120   int
00121   __cxa_guard_acquire(__guard*);
00122 
00123   void
00124   __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW;
00125 
00126   void
00127   __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW;
00128 
00129   // DSO destruction.
00130   int
00131   __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW;
00132 
00133   int
00134   __cxa_finalize(void*);
00135 
00136   // TLS destruction.
00137   int
00138   __cxa_thread_atexit(void (*)(void*), void*, void *) _GLIBCXX_NOTHROW;
00139 
00140   // Pure virtual functions.
00141   void
00142   __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
00143 
00144   void
00145   __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
00146 
00147   // Exception handling auxillary.
00148   void 
00149   __cxa_bad_cast() __attribute__((__noreturn__));
00150 
00151   void 
00152   __cxa_bad_typeid() __attribute__((__noreturn__));
00153 
00154 
00155   /**
00156    *  @brief Demangling routine.
00157    *  ABI-mandated entry point in the C++ runtime library for demangling.
00158    *
00159    *  @param __mangled_name A NUL-terminated character string
00160    *  containing the name to be demangled.
00161    *
00162    *  @param __output_buffer A region of memory, allocated with
00163    *  malloc, of @a *__length bytes, into which the demangled name is
00164    *  stored.  If @a __output_buffer is not long enough, it is
00165    *  expanded using realloc.  @a __output_buffer may instead be NULL;
00166    *  in that case, the demangled name is placed in a region of memory
00167    *  allocated with malloc.
00168    *
00169    *  @param __length If @a __length is non-NULL, the length of the
00170    *  buffer containing the demangled name is placed in @a *__length.
00171    *
00172    *  @param __status @a *__status is set to one of the following values:
00173    *   0: The demangling operation succeeded.
00174    *  -1: A memory allocation failure occurred.
00175    *  -2: @a mangled_name is not a valid name under the C++ ABI mangling rules.
00176    *  -3: One of the arguments is invalid.
00177    *
00178    *  @return A pointer to the start of the NUL-terminated demangled
00179    *  name, or NULL if the demangling fails.  The caller is
00180    *  responsible for deallocating this memory using @c free.
00181    *
00182    *  The demangling is performed using the C++ ABI mangling rules,
00183    *  with GNU extensions. For example, this function is used in
00184    *  __gnu_cxx::__verbose_terminate_handler.
00185    *
00186    *  See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html
00187    *  for other examples of use.
00188    *
00189    *  @note The same demangling functionality is available via
00190    *  libiberty (@c <libiberty/demangle.h> and @c libiberty.a) in GCC
00191    *  3.1 and later, but that requires explicit installation (@c
00192    *  --enable-install-libiberty) and uses a different API, although
00193    *  the ABI is unchanged.
00194    */
00195   char*
00196   __cxa_demangle(const char* __mangled_name, char* __output_buffer,
00197          size_t* __length, int* __status);
00198 
00199 #ifdef __cplusplus
00200   }
00201 } // namespace __cxxabiv1
00202 #endif
00203 
00204 #ifdef __cplusplus
00205 
00206 #include <typeinfo>
00207 
00208 namespace __cxxabiv1
00209 {
00210   // Type information for int, float etc.
00211   class __fundamental_type_info : public std::type_info
00212   {
00213   public:
00214     explicit
00215     __fundamental_type_info(const char* __n) : std::type_info(__n) { }
00216 
00217     virtual
00218     ~__fundamental_type_info();
00219   };
00220 
00221   // Type information for array objects.
00222   class __array_type_info : public std::type_info
00223   {
00224   public:
00225     explicit
00226     __array_type_info(const char* __n) : std::type_info(__n) { }
00227 
00228     virtual
00229     ~__array_type_info();
00230   };
00231 
00232   // Type information for functions (both member and non-member).
00233   class __function_type_info : public std::type_info
00234   {
00235   public:
00236     explicit
00237     __function_type_info(const char* __n) : std::type_info(__n) { }
00238 
00239     virtual
00240     ~__function_type_info();
00241 
00242   protected:
00243     // Implementation defined member function.
00244     virtual bool
00245     __is_function_p() const;
00246   };
00247 
00248   // Type information for enumerations.
00249   class __enum_type_info : public std::type_info
00250   {
00251   public:
00252     explicit
00253     __enum_type_info(const char* __n) : std::type_info(__n) { }
00254 
00255     virtual
00256     ~__enum_type_info();
00257   };
00258 
00259   // Common type information for simple pointers and pointers to member.
00260   class __pbase_type_info : public std::type_info
00261   {
00262   public:
00263     unsigned int        __flags; // Qualification of the target object.
00264     const std::type_info*   __pointee; // Type of pointed to object.
00265 
00266     explicit
00267     __pbase_type_info(const char* __n, int __quals,
00268               const std::type_info* __type)
00269     : std::type_info(__n), __flags(__quals), __pointee(__type)
00270     { }
00271 
00272     virtual
00273     ~__pbase_type_info();
00274 
00275     // Implementation defined type.
00276     enum __masks
00277       {
00278     __const_mask = 0x1,
00279     __volatile_mask = 0x2,
00280     __restrict_mask = 0x4,
00281     __incomplete_mask = 0x8,
00282     __incomplete_class_mask = 0x10
00283       };
00284 
00285   protected:
00286     __pbase_type_info(const __pbase_type_info&);
00287 
00288     __pbase_type_info&
00289     operator=(const __pbase_type_info&);
00290 
00291     // Implementation defined member functions.
00292     virtual bool
00293     __do_catch(const std::type_info* __thr_type, void** __thr_obj,
00294            unsigned int __outer) const;
00295 
00296     inline virtual bool
00297     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00298             unsigned __outer) const;
00299   };
00300 
00301   // Type information for simple pointers.
00302   class __pointer_type_info : public __pbase_type_info
00303   {
00304   public:
00305     explicit
00306     __pointer_type_info(const char* __n, int __quals,
00307             const std::type_info* __type)
00308     : __pbase_type_info (__n, __quals, __type) { }
00309 
00310 
00311     virtual
00312     ~__pointer_type_info();
00313 
00314   protected:
00315     // Implementation defined member functions.
00316     virtual bool
00317     __is_pointer_p() const;
00318 
00319     virtual bool
00320     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00321             unsigned __outer) const;
00322   };
00323 
00324   class __class_type_info;
00325 
00326   // Type information for a pointer to member variable.
00327   class __pointer_to_member_type_info : public __pbase_type_info
00328   {
00329   public:
00330     __class_type_info* __context;   // Class of the member.
00331 
00332     explicit
00333     __pointer_to_member_type_info(const char* __n, int __quals,
00334                   const std::type_info* __type,
00335                   __class_type_info* __klass)
00336     : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
00337 
00338     virtual
00339     ~__pointer_to_member_type_info();
00340 
00341   protected:
00342     __pointer_to_member_type_info(const __pointer_to_member_type_info&);
00343 
00344     __pointer_to_member_type_info&
00345     operator=(const __pointer_to_member_type_info&);
00346 
00347     // Implementation defined member function.
00348     virtual bool
00349     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00350             unsigned __outer) const;
00351   };
00352 
00353   // Helper class for __vmi_class_type.
00354   class __base_class_type_info
00355   {
00356   public:
00357     const __class_type_info*    __base_type;  // Base class type.
00358 #ifdef _GLIBCXX_LLP64
00359     long long           __offset_flags;  // Offset and info.
00360 #else
00361     long            __offset_flags;  // Offset and info.
00362 #endif
00363 
00364     enum __offset_flags_masks
00365       {
00366     __virtual_mask = 0x1,
00367     __public_mask = 0x2,
00368     __hwm_bit = 2,
00369     __offset_shift = 8          // Bits to shift offset.
00370       };
00371 
00372     // Implementation defined member functions.
00373     bool
00374     __is_virtual_p() const
00375     { return __offset_flags & __virtual_mask; }
00376 
00377     bool
00378     __is_public_p() const
00379     { return __offset_flags & __public_mask; }
00380 
00381     ptrdiff_t
00382     __offset() const
00383     {
00384       // This shift, being of a signed type, is implementation
00385       // defined. GCC implements such shifts as arithmetic, which is
00386       // what we want.
00387       return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
00388     }
00389   };
00390 
00391   // Type information for a class.
00392   class __class_type_info : public std::type_info
00393   {
00394   public:
00395     explicit
00396     __class_type_info (const char *__n) : type_info(__n) { }
00397 
00398     virtual
00399     ~__class_type_info ();
00400 
00401     // Implementation defined types.
00402     // The type sub_kind tells us about how a base object is contained
00403     // within a derived object. We often do this lazily, hence the
00404     // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
00405     // not publicly contained.
00406     enum __sub_kind
00407       {
00408     // We have no idea.
00409     __unknown = 0,
00410 
00411     // Not contained within us (in some circumstances this might
00412     // mean not contained publicly)
00413     __not_contained,
00414 
00415     // Contained ambiguously.
00416     __contained_ambig,
00417 
00418     // Via a virtual path.
00419     __contained_virtual_mask = __base_class_type_info::__virtual_mask,
00420 
00421     // Via a public path.
00422     __contained_public_mask = __base_class_type_info::__public_mask,
00423 
00424     // Contained within us.
00425     __contained_mask = 1 << __base_class_type_info::__hwm_bit,
00426 
00427     __contained_private = __contained_mask,
00428     __contained_public = __contained_mask | __contained_public_mask
00429       };
00430 
00431     struct __upcast_result;
00432     struct __dyncast_result;
00433 
00434   protected:
00435     // Implementation defined member functions.
00436     virtual bool
00437     __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
00438 
00439     virtual bool
00440     __do_catch(const type_info* __thr_type, void** __thr_obj,
00441            unsigned __outer) const;
00442 
00443   public:
00444     // Helper for upcast. See if DST is us, or one of our bases.
00445     // Return false if not found, true if found.
00446     virtual bool
00447     __do_upcast(const __class_type_info* __dst, const void* __obj,
00448         __upcast_result& __restrict __result) const;
00449 
00450     // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
00451     // within OBJ_PTR. OBJ_PTR points to a base object of our type,
00452     // which is the destination type. SRC2DST indicates how SRC
00453     // objects might be contained within this type.  If SRC_PTR is one
00454     // of our SRC_TYPE bases, indicate the virtuality. Returns
00455     // not_contained for non containment or private containment.
00456     inline __sub_kind
00457     __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00458               const __class_type_info* __src_type,
00459               const void* __src_ptr) const;
00460 
00461     // Helper for dynamic cast. ACCESS_PATH gives the access from the
00462     // most derived object to this base. DST_TYPE indicates the
00463     // desired type we want. OBJ_PTR points to a base of our type
00464     // within the complete object. SRC_TYPE indicates the static type
00465     // started from and SRC_PTR points to that base within the most
00466     // derived object. Fill in RESULT with what we find. Return true
00467     // if we have located an ambiguous match.
00468     virtual bool
00469     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00470          const __class_type_info* __dst_type, const void* __obj_ptr,
00471          const __class_type_info* __src_type, const void* __src_ptr,
00472          __dyncast_result& __result) const;
00473 
00474     // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
00475     // bases are inherited by the type started from -- which is not
00476     // necessarily the current type. The current type will be a base
00477     // of the destination type.  OBJ_PTR points to the current base.
00478     virtual __sub_kind
00479     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00480              const __class_type_info* __src_type,
00481              const void* __src_ptr) const;
00482   };
00483 
00484   // Type information for a class with a single non-virtual base.
00485   class __si_class_type_info : public __class_type_info
00486   {
00487   public:
00488     const __class_type_info* __base_type;
00489 
00490     explicit
00491     __si_class_type_info(const char *__n, const __class_type_info *__base)
00492     : __class_type_info(__n), __base_type(__base) { }
00493 
00494     virtual
00495     ~__si_class_type_info();
00496 
00497   protected:
00498     __si_class_type_info(const __si_class_type_info&);
00499 
00500     __si_class_type_info&
00501     operator=(const __si_class_type_info&);
00502 
00503     // Implementation defined member functions.
00504     virtual bool
00505     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00506          const __class_type_info* __dst_type, const void* __obj_ptr,
00507          const __class_type_info* __src_type, const void* __src_ptr,
00508          __dyncast_result& __result) const;
00509 
00510     virtual __sub_kind
00511     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00512              const __class_type_info* __src_type,
00513              const void* __sub_ptr) const;
00514 
00515     virtual bool
00516     __do_upcast(const __class_type_info*__dst, const void*__obj,
00517         __upcast_result& __restrict __result) const;
00518   };
00519 
00520   // Type information for a class with multiple and/or virtual bases.
00521   class __vmi_class_type_info : public __class_type_info
00522   {
00523   public:
00524     unsigned int        __flags;  // Details about the class hierarchy.
00525     unsigned int        __base_count;  // Number of direct bases.
00526 
00527     // The array of bases uses the trailing array struct hack so this
00528     // class is not constructable with a normal constructor. It is
00529     // internally generated by the compiler.
00530     __base_class_type_info  __base_info[1];  // Array of bases.
00531 
00532     explicit
00533     __vmi_class_type_info(const char* __n, int ___flags)
00534     : __class_type_info(__n), __flags(___flags), __base_count(0) { }
00535 
00536     virtual
00537     ~__vmi_class_type_info();
00538 
00539     // Implementation defined types.
00540     enum __flags_masks
00541       {
00542     __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
00543     __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
00544     __flags_unknown_mask = 0x10
00545       };
00546 
00547   protected:
00548     // Implementation defined member functions.
00549     virtual bool
00550     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00551          const __class_type_info* __dst_type, const void* __obj_ptr,
00552          const __class_type_info* __src_type, const void* __src_ptr,
00553          __dyncast_result& __result) const;
00554 
00555     virtual __sub_kind
00556     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00557              const __class_type_info* __src_type,
00558              const void* __src_ptr) const;
00559 
00560     virtual bool
00561     __do_upcast(const __class_type_info* __dst, const void* __obj,
00562         __upcast_result& __restrict __result) const;
00563   };
00564 
00565   // Exception handling forward declarations.
00566   struct __cxa_exception;
00567   struct __cxa_refcounted_exception;
00568   struct __cxa_dependent_exception;
00569   struct __cxa_eh_globals;
00570 
00571   extern "C"
00572   {
00573   // Dynamic cast runtime.
00574 
00575   // src2dst has the following possible values
00576   //  >-1: src_type is a unique public non-virtual base of dst_type
00577   //       dst_ptr + src2dst == src_ptr
00578   //   -1: unspecified relationship
00579   //   -2: src_type is not a public base of dst_type
00580   //   -3: src_type is a multiple public non-virtual base of dst_type
00581   void*
00582   __dynamic_cast(const void* __src_ptr, // Starting object.
00583          const __class_type_info* __src_type, // Static type of object.
00584          const __class_type_info* __dst_type, // Desired target type.
00585          ptrdiff_t __src2dst); // How src and dst are related.
00586 
00587 
00588   // Exception handling runtime.
00589 
00590   // The __cxa_eh_globals for the current thread can be obtained by using
00591   // either of the following functions.  The "fast" version assumes at least
00592   // one prior call of __cxa_get_globals has been made from the current
00593   // thread, so no initialization is necessary.
00594   __cxa_eh_globals*
00595   __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__));
00596 
00597   __cxa_eh_globals*
00598   __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__));
00599 
00600   // Allocate memory for the primary exception plus the thrown object.
00601   void*
00602   __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW;
00603 
00604   // Free the space allocated for the primary exception.
00605   void 
00606   __cxa_free_exception(void*) _GLIBCXX_NOTHROW;
00607 
00608   // Throw the exception.
00609   void
00610   __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *))
00611   __attribute__((__noreturn__));
00612 
00613   // Used to implement exception handlers.
00614   void*
00615   __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__));
00616 
00617   void*
00618   __cxa_begin_catch(void*) _GLIBCXX_NOTHROW;
00619 
00620   void 
00621   __cxa_end_catch();
00622 
00623   void 
00624   __cxa_rethrow() __attribute__((__noreturn__));
00625 
00626   // Returns the type_info for the currently handled exception [15.3/8], or
00627   // null if there is none.
00628   std::type_info*
00629   __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__));
00630 
00631   // GNU Extensions.
00632 
00633   // Allocate memory for a dependent exception.
00634   __cxa_dependent_exception*
00635   __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW;
00636 
00637   // Free the space allocated for the dependent exception.
00638   void
00639   __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW;
00640 
00641   } // extern "C"
00642 
00643   // A magic placeholder class that can be caught by reference
00644   // to recognize foreign exceptions.
00645   class __foreign_exception
00646   {
00647     virtual ~__foreign_exception() throw();
00648     virtual void __pure_dummy() = 0; // prevent catch by value
00649   };
00650 
00651 } // namespace __cxxabiv1
00652 
00653 /** @namespace abi
00654  *  @brief The cross-vendor C++ Application Binary Interface. A
00655  *  namespace alias to __cxxabiv1, but user programs should use the
00656  *  alias 'abi'.
00657  *
00658  *  A brief overview of an ABI is given in the libstdc++ FAQ, question
00659  *  5.8 (you may have a copy of the FAQ locally, or you can view the online
00660  *  version at http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#5_8 ).
00661  *
00662  *  GCC subscribes to a cross-vendor ABI for C++, sometimes
00663  *  called the IA64 ABI because it happens to be the native ABI for that
00664  *  platform.  It is summarized at http://www.codesourcery.com/cxx-abi/
00665  *  along with the current specification.
00666  *
00667  *  For users of GCC greater than or equal to 3.x, entry points are
00668  *  available in <cxxabi.h>, which notes, <em>'It is not normally
00669  *  necessary for user programs to include this header, or use the
00670  *  entry points directly.  However, this header is available should
00671  *  that be needed.'</em>
00672 */
00673 namespace abi = __cxxabiv1;
00674 
00675 namespace __gnu_cxx
00676 {
00677   /**
00678    *  @brief Exception thrown by __cxa_guard_acquire.
00679    *  @ingroup exceptions
00680    *
00681    *  6.7[stmt.dcl]/4: If control re-enters the declaration (recursively)
00682    *  while the object is being initialized, the behavior is undefined.
00683    *
00684    *  Since we already have a library function to handle locking, we might
00685    *  as well check for this situation and throw an exception.
00686    *  We use the second byte of the guard variable to remember that we're
00687    *  in the middle of an initialization.
00688    */
00689   class recursive_init_error: public std::exception
00690   {
00691   public:
00692     recursive_init_error() throw() { }
00693     virtual ~recursive_init_error() throw ();
00694   };
00695 }
00696 #endif // __cplusplus
00697 
00698 #pragma GCC visibility pop
00699 
00700 #endif // __CXXABI_H