libstdc++
|
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