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