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