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