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