1// ABI Support -*- C++ -*- 2 3// Copyright (C) 2000, 2002, 2003, 2004, 2006, 2007, 2009, 2010, 2011 4// Free Software Foundation, Inc. 5// 6// This file is part of GCC. 7// 8// GCC is free software; you can redistribute it and/or modify 9// it under the terms of the GNU General Public License as published by 10// the Free Software Foundation; either version 3, or (at your option) 11// any later version. 12// 13// GCC is distributed in the hope that it will be useful, 14// but WITHOUT ANY WARRANTY; without even the implied warranty of 15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16// GNU General Public License for more details. 17// 18// Under Section 7 of GPL version 3, you are granted additional 19// permissions described in the GCC Runtime Library Exception, version 20// 3.1, as published by the Free Software Foundation. 21 22// You should have received a copy of the GNU General Public License and 23// a copy of the GCC Runtime Library Exception along with this program; 24// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 25// <http://www.gnu.org/licenses/>. 26 27// Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com> 28 29/* This file declares the new abi entry points into the runtime. It is not 30 normally necessary for user programs to include this header, or use the 31 entry points directly. However, this header is available should that be 32 needed. 33 34 Some of the entry points are intended for both C and C++, thus this header 35 is includable from both C and C++. Though the C++ specific parts are not 36 available in C, naturally enough. */ 37 38/** @file cxxabi.h 39 * The header provides an interface to the C++ ABI. 40 */ 41 42#ifndef _CXXABI_H 43#define _CXXABI_H 1 44 45#pragma GCC system_header 46 47#pragma GCC visibility push(default) 48 49#include <stddef.h> 50#include <bits/c++config.h> 51#include <bits/cxxabi_tweaks.h> 52#include <bits/cxxabi_forced.h> 53 54#ifndef _GLIBCXX_CDTOR_CALLABI 55#define _GLIBCXX_CDTOR_CALLABI 56#endif 57 58#ifdef __cplusplus 59namespace __cxxabiv1 60{ 61 extern "C" 62 { 63#endif 64 65 typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *); 66 67 // Allocate array. 68 void* 69 __cxa_vec_new(size_t __element_count, size_t __element_size, 70 size_t __padding_size, __cxa_cdtor_type __constructor, 71 __cxa_cdtor_type __destructor); 72 73 void* 74 __cxa_vec_new2(size_t __element_count, size_t __element_size, 75 size_t __padding_size, __cxa_cdtor_type __constructor, 76 __cxa_cdtor_type __destructor, void *(*__alloc) (size_t), 77 void (*__dealloc) (void*)); 78 79 void* 80 __cxa_vec_new3(size_t __element_count, size_t __element_size, 81 size_t __padding_size, __cxa_cdtor_type __constructor, 82 __cxa_cdtor_type __destructor, void *(*__alloc) (size_t), 83 void (*__dealloc) (void*, size_t)); 84 85 // Construct array. 86 __cxa_vec_ctor_return_type 87 __cxa_vec_ctor(void* __array_address, size_t __element_count, 88 size_t __element_size, __cxa_cdtor_type __constructor, 89 __cxa_cdtor_type __destructor); 90 91 __cxa_vec_ctor_return_type 92 __cxa_vec_cctor(void* __dest_array, void* __src_array, 93 size_t __element_count, size_t __element_size, 94 __cxa_cdtor_return_type (*__constructor) (void*, void*), 95 __cxa_cdtor_type __destructor); 96 97 // Destruct array. 98 void 99 __cxa_vec_dtor(void* __array_address, size_t __element_count, 100 size_t __element_size, __cxa_cdtor_type __destructor); 101 102 void 103 __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s, 104 __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW; 105 106 // Destruct and release array. 107 void 108 __cxa_vec_delete(void* __array_address, size_t __element_size, 109 size_t __padding_size, __cxa_cdtor_type __destructor); 110 111 void 112 __cxa_vec_delete2(void* __array_address, size_t __element_size, 113 size_t __padding_size, __cxa_cdtor_type __destructor, 114 void (*__dealloc) (void*)); 115 116 void 117 __cxa_vec_delete3(void* __array_address, size_t __element_size, 118 size_t __padding_size, __cxa_cdtor_type __destructor, 119 void (*__dealloc) (void*, size_t)); 120 121 int 122 __cxa_guard_acquire(__guard*); 123 124 void 125 __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW; 126 127 void 128 __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW; 129 130 // DSO destruction. 131 int 132 __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW; 133 134 int 135 __cxa_finalize(void*); 136 137 // Pure virtual functions. 138 void 139 __cxa_pure_virtual(void) __attribute__ ((__noreturn__)); 140 141 void 142 __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); 143 144 // Exception handling auxillary. 145 void 146 __cxa_bad_cast() __attribute__((__noreturn__)); 147 148 void 149 __cxa_bad_typeid() __attribute__((__noreturn__)); 150 151 152 /** 153 * @brief Demangling routine. 154 * ABI-mandated entry point in the C++ runtime library for demangling. 155 * 156 * @param __mangled_name A NUL-terminated character string 157 * containing the name to be demangled. 158 * 159 * @param __output_buffer A region of memory, allocated with 160 * malloc, of @a *__length bytes, into which the demangled name is 161 * stored. If @a __output_buffer is not long enough, it is 162 * expanded using realloc. @a __output_buffer may instead be NULL; 163 * in that case, the demangled name is placed in a region of memory 164 * allocated with malloc. 165 * 166 * @param __length If @a __length is non-NULL, the length of the 167 * buffer containing the demangled name is placed in @a *__length. 168 * 169 * @param __status @a *__status is set to one of the following values: 170 * 0: The demangling operation succeeded. 171 * -1: A memory allocation failure occurred. 172 * -2: @a mangled_name is not a valid name under the C++ ABI mangling rules. 173 * -3: One of the arguments is invalid. 174 * 175 * @return A pointer to the start of the NUL-terminated demangled 176 * name, or NULL if the demangling fails. The caller is 177 * responsible for deallocating this memory using @c free. 178 * 179 * The demangling is performed using the C++ ABI mangling rules, 180 * with GNU extensions. For example, this function is used in 181 * __gnu_cxx::__verbose_terminate_handler. 182 * 183 * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html 184 * for other examples of use. 185 * 186 * @note The same demangling functionality is available via 187 * libiberty (@c <libiberty/demangle.h> and @c libiberty.a) in GCC 188 * 3.1 and later, but that requires explicit installation (@c 189 * --enable-install-libiberty) and uses a different API, although 190 * the ABI is unchanged. 191 */ 192 char* 193 __cxa_demangle(const char* __mangled_name, char* __output_buffer, 194 size_t* __length, int* __status); 195 196#ifdef __cplusplus 197 } 198} // namespace __cxxabiv1 199#endif 200 201#ifdef __cplusplus 202 203#include <typeinfo> 204 205namespace __cxxabiv1 206{ 207 // Type information for int, float etc. 208 class __fundamental_type_info : public std::type_info 209 { 210 public: 211 explicit 212 __fundamental_type_info(const char* __n) : std::type_info(__n) { } 213 214 virtual 215 ~__fundamental_type_info(); 216 }; 217 218 // Type information for array objects. 219 class __array_type_info : public std::type_info 220 { 221 public: 222 explicit 223 __array_type_info(const char* __n) : std::type_info(__n) { } 224 225 virtual 226 ~__array_type_info(); 227 }; 228 229 // Type information for functions (both member and non-member). 230 class __function_type_info : public std::type_info 231 { 232 public: 233 explicit 234 __function_type_info(const char* __n) : std::type_info(__n) { } 235 236 virtual 237 ~__function_type_info(); 238 239 protected: 240 // Implementation defined member function. 241 virtual bool 242 __is_function_p() const; 243 }; 244 245 // Type information for enumerations. 246 class __enum_type_info : public std::type_info 247 { 248 public: 249 explicit 250 __enum_type_info(const char* __n) : std::type_info(__n) { } 251 252 virtual 253 ~__enum_type_info(); 254 }; 255 256 // Common type information for simple pointers and pointers to member. 257 class __pbase_type_info : public std::type_info 258 { 259 public: 260 unsigned int __flags; // Qualification of the target object. 261 const std::type_info* __pointee; // Type of pointed to object. 262 263 explicit 264 __pbase_type_info(const char* __n, int __quals, 265 const std::type_info* __type) 266 : std::type_info(__n), __flags(__quals), __pointee(__type) 267 { } 268 269 virtual 270 ~__pbase_type_info(); 271 272 // Implementation defined type. 273 enum __masks 274 { 275 __const_mask = 0x1, 276 __volatile_mask = 0x2, 277 __restrict_mask = 0x4, 278 __incomplete_mask = 0x8, 279 __incomplete_class_mask = 0x10 280 }; 281 282 protected: 283 __pbase_type_info(const __pbase_type_info&); 284 285 __pbase_type_info& 286 operator=(const __pbase_type_info&); 287 288 // Implementation defined member functions. 289 virtual bool 290 __do_catch(const std::type_info* __thr_type, void** __thr_obj, 291 unsigned int __outer) const; 292 293 inline virtual bool 294 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 295 unsigned __outer) const; 296 }; 297 298 // Type information for simple pointers. 299 class __pointer_type_info : public __pbase_type_info 300 { 301 public: 302 explicit 303 __pointer_type_info(const char* __n, int __quals, 304 const std::type_info* __type) 305 : __pbase_type_info (__n, __quals, __type) { } 306 307 308 virtual 309 ~__pointer_type_info(); 310 311 protected: 312 // Implementation defined member functions. 313 virtual bool 314 __is_pointer_p() const; 315 316 virtual bool 317 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 318 unsigned __outer) const; 319 }; 320 321 class __class_type_info; 322 323 // Type information for a pointer to member variable. 324 class __pointer_to_member_type_info : public __pbase_type_info 325 { 326 public: 327 __class_type_info* __context; // Class of the member. 328 329 explicit 330 __pointer_to_member_type_info(const char* __n, int __quals, 331 const std::type_info* __type, 332 __class_type_info* __klass) 333 : __pbase_type_info(__n, __quals, __type), __context(__klass) { } 334 335 virtual 336 ~__pointer_to_member_type_info(); 337 338 protected: 339 __pointer_to_member_type_info(const __pointer_to_member_type_info&); 340 341 __pointer_to_member_type_info& 342 operator=(const __pointer_to_member_type_info&); 343 344 // Implementation defined member function. 345 virtual bool 346 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 347 unsigned __outer) const; 348 }; 349 350 // Helper class for __vmi_class_type. 351 class __base_class_type_info 352 { 353 public: 354 const __class_type_info* __base_type; // Base class type. 355 long __offset_flags; // Offset and info. 356 357 enum __offset_flags_masks 358 { 359 __virtual_mask = 0x1, 360 __public_mask = 0x2, 361 __hwm_bit = 2, 362 __offset_shift = 8 // Bits to shift offset. 363 }; 364 365 // Implementation defined member functions. 366 bool 367 __is_virtual_p() const 368 { return __offset_flags & __virtual_mask; } 369 370 bool 371 __is_public_p() const 372 { return __offset_flags & __public_mask; } 373 374 ptrdiff_t 375 __offset() const 376 { 377 // This shift, being of a signed type, is implementation 378 // defined. GCC implements such shifts as arithmetic, which is 379 // what we want. 380 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift; 381 } 382 }; 383 384 // Type information for a class. 385 class __class_type_info : public std::type_info 386 { 387 public: 388 explicit 389 __class_type_info (const char *__n) : type_info(__n) { } 390 391 virtual 392 ~__class_type_info (); 393 394 // Implementation defined types. 395 // The type sub_kind tells us about how a base object is contained 396 // within a derived object. We often do this lazily, hence the 397 // UNKNOWN value. At other times we may use NOT_CONTAINED to mean 398 // not publicly contained. 399 enum __sub_kind 400 { 401 // We have no idea. 402 __unknown = 0, 403 404 // Not contained within us (in some circumstances this might 405 // mean not contained publicly) 406 __not_contained, 407 408 // Contained ambiguously. 409 __contained_ambig, 410 411 // Via a virtual path. 412 __contained_virtual_mask = __base_class_type_info::__virtual_mask, 413 414 // Via a public path. 415 __contained_public_mask = __base_class_type_info::__public_mask, 416 417 // Contained within us. 418 __contained_mask = 1 << __base_class_type_info::__hwm_bit, 419 420 __contained_private = __contained_mask, 421 __contained_public = __contained_mask | __contained_public_mask 422 }; 423 424 struct __upcast_result; 425 struct __dyncast_result; 426 427 protected: 428 // Implementation defined member functions. 429 virtual bool 430 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const; 431 432 virtual bool 433 __do_catch(const type_info* __thr_type, void** __thr_obj, 434 unsigned __outer) const; 435 436 public: 437 // Helper for upcast. See if DST is us, or one of our bases. 438 // Return false if not found, true if found. 439 virtual bool 440 __do_upcast(const __class_type_info* __dst, const void* __obj, 441 __upcast_result& __restrict __result) const; 442 443 // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly 444 // within OBJ_PTR. OBJ_PTR points to a base object of our type, 445 // which is the destination type. SRC2DST indicates how SRC 446 // objects might be contained within this type. If SRC_PTR is one 447 // of our SRC_TYPE bases, indicate the virtuality. Returns 448 // not_contained for non containment or private containment. 449 inline __sub_kind 450 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 451 const __class_type_info* __src_type, 452 const void* __src_ptr) const; 453 454 // Helper for dynamic cast. ACCESS_PATH gives the access from the 455 // most derived object to this base. DST_TYPE indicates the 456 // desired type we want. OBJ_PTR points to a base of our type 457 // within the complete object. SRC_TYPE indicates the static type 458 // started from and SRC_PTR points to that base within the most 459 // derived object. Fill in RESULT with what we find. Return true 460 // if we have located an ambiguous match. 461 virtual bool 462 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, 463 const __class_type_info* __dst_type, const void* __obj_ptr, 464 const __class_type_info* __src_type, const void* __src_ptr, 465 __dyncast_result& __result) const; 466 467 // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE 468 // bases are inherited by the type started from -- which is not 469 // necessarily the current type. The current type will be a base 470 // of the destination type. OBJ_PTR points to the current base. 471 virtual __sub_kind 472 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 473 const __class_type_info* __src_type, 474 const void* __src_ptr) const; 475 }; 476 477 // Type information for a class with a single non-virtual base. 478 class __si_class_type_info : public __class_type_info 479 { 480 public: 481 const __class_type_info* __base_type; 482 483 explicit 484 __si_class_type_info(const char *__n, const __class_type_info *__base) 485 : __class_type_info(__n), __base_type(__base) { } 486 487 virtual 488 ~__si_class_type_info(); 489 490 protected: 491 __si_class_type_info(const __si_class_type_info&); 492 493 __si_class_type_info& 494 operator=(const __si_class_type_info&); 495 496 // Implementation defined member functions. 497 virtual bool 498 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, 499 const __class_type_info* __dst_type, const void* __obj_ptr, 500 const __class_type_info* __src_type, const void* __src_ptr, 501 __dyncast_result& __result) const; 502 503 virtual __sub_kind 504 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 505 const __class_type_info* __src_type, 506 const void* __sub_ptr) const; 507 508 virtual bool 509 __do_upcast(const __class_type_info*__dst, const void*__obj, 510 __upcast_result& __restrict __result) const; 511 }; 512 513 // Type information for a class with multiple and/or virtual bases. 514 class __vmi_class_type_info : public __class_type_info 515 { 516 public: 517 unsigned int __flags; // Details about the class hierarchy. 518 unsigned int __base_count; // Number of direct bases. 519 520 // The array of bases uses the trailing array struct hack so this 521 // class is not constructable with a normal constructor. It is 522 // internally generated by the compiler. 523 __base_class_type_info __base_info[1]; // Array of bases. 524 525 explicit 526 __vmi_class_type_info(const char* __n, int ___flags) 527 : __class_type_info(__n), __flags(___flags), __base_count(0) { } 528 529 virtual 530 ~__vmi_class_type_info(); 531 532 // Implementation defined types. 533 enum __flags_masks 534 { 535 __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base. 536 __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance. 537 __flags_unknown_mask = 0x10 538 }; 539 540 protected: 541 // Implementation defined member functions. 542 virtual bool 543 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, 544 const __class_type_info* __dst_type, const void* __obj_ptr, 545 const __class_type_info* __src_type, const void* __src_ptr, 546 __dyncast_result& __result) const; 547 548 virtual __sub_kind 549 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 550 const __class_type_info* __src_type, 551 const void* __src_ptr) const; 552 553 virtual bool 554 __do_upcast(const __class_type_info* __dst, const void* __obj, 555 __upcast_result& __restrict __result) const; 556 }; 557 558 // Exception handling forward declarations. 559 struct __cxa_exception; 560 struct __cxa_refcounted_exception; 561 struct __cxa_dependent_exception; 562 struct __cxa_eh_globals; 563 564 extern "C" 565 { 566 // Dynamic cast runtime. 567 568 // src2dst has the following possible values 569 // >-1: src_type is a unique public non-virtual base of dst_type 570 // dst_ptr + src2dst == src_ptr 571 // -1: unspecified relationship 572 // -2: src_type is not a public base of dst_type 573 // -3: src_type is a multiple public non-virtual base of dst_type 574 void* 575 __dynamic_cast(const void* __src_ptr, // Starting object. 576 const __class_type_info* __src_type, // Static type of object. 577 const __class_type_info* __dst_type, // Desired target type. 578 ptrdiff_t __src2dst); // How src and dst are related. 579 580 581 // Exception handling runtime. 582 583 // The __cxa_eh_globals for the current thread can be obtained by using 584 // either of the following functions. The "fast" version assumes at least 585 // one prior call of __cxa_get_globals has been made from the current 586 // thread, so no initialization is necessary. 587 __cxa_eh_globals* 588 __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__)); 589 590 __cxa_eh_globals* 591 __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__)); 592 593 // Allocate memory for the primary exception plus the thrown object. 594 void* 595 __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW; 596 597 // Free the space allocated for the primary exception. 598 void 599 __cxa_free_exception(void*) _GLIBCXX_NOTHROW; 600 601 // Throw the exception. 602 void 603 __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *)) 604 __attribute__((__noreturn__)); 605 606 // Used to implement exception handlers. 607 void* 608 __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__)); 609 610 void* 611 __cxa_begin_catch(void*) _GLIBCXX_NOTHROW; 612 613 void 614 __cxa_end_catch(); 615 616 void 617 __cxa_rethrow() __attribute__((__noreturn__)); 618 619 // Returns the type_info for the currently handled exception [15.3/8], or 620 // null if there is none. 621 std::type_info* 622 __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__)); 623 624 // GNU Extensions. 625 626 // Allocate memory for a dependent exception. 627 __cxa_dependent_exception* 628 __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW; 629 630 // Free the space allocated for the dependent exception. 631 void 632 __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW; 633 634 } // extern "C" 635 636 // A magic placeholder class that can be caught by reference 637 // to recognize foreign exceptions. 638 class __foreign_exception 639 { 640 virtual ~__foreign_exception() throw(); 641 virtual void __pure_dummy() = 0; // prevent catch by value 642 }; 643 644} // namespace __cxxabiv1 645 646/** @namespace abi 647 * @brief The cross-vendor C++ Application Binary Interface. A 648 * namespace alias to __cxxabiv1, but user programs should use the 649 * alias 'abi'. 650 * 651 * A brief overview of an ABI is given in the libstdc++ FAQ, question 652 * 5.8 (you may have a copy of the FAQ locally, or you can view the online 653 * version at http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#5_8 ). 654 * 655 * GCC subscribes to a cross-vendor ABI for C++, sometimes 656 * called the IA64 ABI because it happens to be the native ABI for that 657 * platform. It is summarized at http://www.codesourcery.com/cxx-abi/ 658 * along with the current specification. 659 * 660 * For users of GCC greater than or equal to 3.x, entry points are 661 * available in <cxxabi.h>, which notes, <em>'It is not normally 662 * necessary for user programs to include this header, or use the 663 * entry points directly. However, this header is available should 664 * that be needed.'</em> 665*/ 666namespace abi = __cxxabiv1; 667 668namespace __gnu_cxx 669{ 670 /** 671 * @brief Exception thrown by __cxa_guard_acquire. 672 * @ingroup exceptions 673 * 674 * 6.7[stmt.dcl]/4: If control re-enters the declaration (recursively) 675 * while the object is being initialized, the behavior is undefined. 676 * 677 * Since we already have a library function to handle locking, we might 678 * as well check for this situation and throw an exception. 679 * We use the second byte of the guard variable to remember that we're 680 * in the middle of an initialization. 681 */ 682 class recursive_init_error: public std::exception 683 { 684 public: 685 recursive_init_error() throw() { } 686 virtual ~recursive_init_error() throw (); 687 }; 688} 689#endif // __cplusplus 690 691#pragma GCC visibility pop 692 693#endif // __CXXABI_H 694