1// new abi support -*- C++ -*- 2 3// Copyright (C) 2000, 2002, 2003, 2004, 2006, 2007, 2009 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 visibility push(default) 46 47#include <stddef.h> 48#include <bits/cxxabi_tweaks.h> 49#include <cxxabi-forced.h> 50 51#ifdef __cplusplus 52#define _GLIBCXX_NOTHROW throw() 53#else 54#define _GLIBCXX_NOTHROW __attribute__((nothrow)) 55#endif 56 57#ifdef __cplusplus 58namespace __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, size_t element_count, 92 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, 103 size_t __element_size, __cxa_cdtor_type destructor); 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*); 125 126 void 127 __cxa_guard_abort(__guard*); 128 129 // Pure virtual functions. 130 void 131 __cxa_pure_virtual(void); 132 133 // Exception handling. 134 void 135 __cxa_bad_cast(); 136 137 void 138 __cxa_bad_typeid(); 139 140 // DSO destruction. 141 int 142 __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW; 143 144 int 145 __cxa_finalize(void*); 146 147 148 /** 149 * @brief Demangling routine. 150 * ABI-mandated entry point in the C++ runtime library for demangling. 151 * 152 * @param __mangled_name A NUL-terminated character string 153 * containing the name to be demangled. 154 * 155 * @param __output_buffer A region of memory, allocated with 156 * malloc, of @a *__length bytes, into which the demangled name is 157 * stored. If @a __output_buffer is not long enough, it is 158 * expanded using realloc. @a __output_buffer may instead be NULL; 159 * in that case, the demangled name is placed in a region of memory 160 * allocated with malloc. 161 * 162 * @param __length If @a __length is non-NULL, the length of the 163 * buffer containing the demangled name is placed in @a *__length. 164 * 165 * @param __status @a *__status is set to one of the following values: 166 * 0: The demangling operation succeeded. 167 * -1: A memory allocation failiure occurred. 168 * -2: @a mangled_name is not a valid name under the C++ ABI mangling rules. 169 * -3: One of the arguments is invalid. 170 * 171 * @return A pointer to the start of the NUL-terminated demangled 172 * name, or NULL if the demangling fails. The caller is 173 * responsible for deallocating this memory using @c free. 174 * 175 * The demangling is performed using the C++ ABI mangling rules, 176 * with GNU extensions. For example, this function is used in 177 * __gnu_cxx::__verbose_terminate_handler. 178 * 179 * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html 180 * for other examples of use. 181 * 182 * @note The same demangling functionality is available via 183 * libiberty (@c <libiberty/demangle.h> and @c libiberty.a) in GCC 184 * 3.1 and later, but that requires explicit installation (@c 185 * --enable-install-libiberty) and uses a different API, although 186 * the ABI is unchanged. 187 */ 188 char* 189 __cxa_demangle(const char* __mangled_name, char* __output_buffer, 190 size_t* __length, int* __status); 191#ifdef __cplusplus 192 } 193} // namespace __cxxabiv1 194#endif 195 196#ifdef __cplusplus 197 198#include <typeinfo> 199 200namespace __cxxabiv1 201{ 202 // Type information for int, float etc. 203 class __fundamental_type_info : public std::type_info 204 { 205 public: 206 explicit 207 __fundamental_type_info(const char* __n) : std::type_info(__n) { } 208 209 virtual 210 ~__fundamental_type_info(); 211 }; 212 213 // Type information for array objects. 214 class __array_type_info : public std::type_info 215 { 216 public: 217 explicit 218 __array_type_info(const char* __n) : std::type_info(__n) { } 219 220 virtual 221 ~__array_type_info(); 222 }; 223 224 // Type information for functions (both member and non-member). 225 class __function_type_info : public std::type_info 226 { 227 public: 228 explicit 229 __function_type_info(const char* __n) : std::type_info(__n) { } 230 231 virtual 232 ~__function_type_info(); 233 234 protected: 235 // Implementation defined member function. 236 virtual bool 237 __is_function_p() const; 238 }; 239 240 // Type information for enumerations. 241 class __enum_type_info : public std::type_info 242 { 243 public: 244 explicit 245 __enum_type_info(const char* __n) : std::type_info(__n) { } 246 247 virtual 248 ~__enum_type_info(); 249 }; 250 251 // Common type information for simple pointers and pointers to member. 252 class __pbase_type_info : public std::type_info 253 { 254 public: 255 unsigned int __flags; // Qualification of the target object. 256 const std::type_info* __pointee; // Type of pointed to object. 257 258 explicit 259 __pbase_type_info(const char* __n, int __quals, 260 const std::type_info* __type) 261 : std::type_info(__n), __flags(__quals), __pointee(__type) 262 { } 263 264 virtual 265 ~__pbase_type_info(); 266 267 // Implementation defined type. 268 enum __masks 269 { 270 __const_mask = 0x1, 271 __volatile_mask = 0x2, 272 __restrict_mask = 0x4, 273 __incomplete_mask = 0x8, 274 __incomplete_class_mask = 0x10 275 }; 276 277 protected: 278 __pbase_type_info(const __pbase_type_info&); 279 280 __pbase_type_info& 281 operator=(const __pbase_type_info&); 282 283 // Implementation defined member functions. 284 virtual bool 285 __do_catch(const std::type_info* __thr_type, void** __thr_obj, 286 unsigned int __outer) const; 287 288 inline virtual bool 289 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 290 unsigned __outer) const; 291 }; 292 293 // Type information for simple pointers. 294 class __pointer_type_info : public __pbase_type_info 295 { 296 public: 297 explicit 298 __pointer_type_info(const char* __n, int __quals, 299 const std::type_info* __type) 300 : __pbase_type_info (__n, __quals, __type) { } 301 302 303 virtual 304 ~__pointer_type_info(); 305 306 protected: 307 // Implementation defined member functions. 308 virtual bool 309 __is_pointer_p() const; 310 311 virtual bool 312 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 313 unsigned __outer) const; 314 }; 315 316 class __class_type_info; 317 318 // Type information for a pointer to member variable. 319 class __pointer_to_member_type_info : public __pbase_type_info 320 { 321 public: 322 __class_type_info* __context; // Class of the member. 323 324 explicit 325 __pointer_to_member_type_info(const char* __n, int __quals, 326 const std::type_info* __type, 327 __class_type_info* __klass) 328 : __pbase_type_info(__n, __quals, __type), __context(__klass) { } 329 330 virtual 331 ~__pointer_to_member_type_info(); 332 333 protected: 334 __pointer_to_member_type_info(const __pointer_to_member_type_info&); 335 336 __pointer_to_member_type_info& 337 operator=(const __pointer_to_member_type_info&); 338 339 // Implementation defined member function. 340 virtual bool 341 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, 342 unsigned __outer) const; 343 }; 344 345 // Helper class for __vmi_class_type. 346 class __base_class_type_info 347 { 348 public: 349 const __class_type_info* __base_type; // Base class type. 350 long __offset_flags; // Offset and info. 351 352 enum __offset_flags_masks 353 { 354 __virtual_mask = 0x1, 355 __public_mask = 0x2, 356 __hwm_bit = 2, 357 __offset_shift = 8 // Bits to shift offset. 358 }; 359 360 // Implementation defined member functions. 361 bool 362 __is_virtual_p() const 363 { return __offset_flags & __virtual_mask; } 364 365 bool 366 __is_public_p() const 367 { return __offset_flags & __public_mask; } 368 369 ptrdiff_t 370 __offset() const 371 { 372 // This shift, being of a signed type, is implementation 373 // defined. GCC implements such shifts as arithmetic, which is 374 // what we want. 375 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift; 376 } 377 }; 378 379 // Type information for a class. 380 class __class_type_info : public std::type_info 381 { 382 public: 383 explicit 384 __class_type_info (const char *__n) : type_info(__n) { } 385 386 virtual 387 ~__class_type_info (); 388 389 // Implementation defined types. 390 // The type sub_kind tells us about how a base object is contained 391 // within a derived object. We often do this lazily, hence the 392 // UNKNOWN value. At other times we may use NOT_CONTAINED to mean 393 // not publicly contained. 394 enum __sub_kind 395 { 396 // We have no idea. 397 __unknown = 0, 398 399 // Not contained within us (in some circumstances this might 400 // mean not contained publicly) 401 __not_contained, 402 403 // Contained ambiguously. 404 __contained_ambig, 405 406 // Via a virtual path. 407 __contained_virtual_mask = __base_class_type_info::__virtual_mask, 408 409 // Via a public path. 410 __contained_public_mask = __base_class_type_info::__public_mask, 411 412 // Contained within us. 413 __contained_mask = 1 << __base_class_type_info::__hwm_bit, 414 415 __contained_private = __contained_mask, 416 __contained_public = __contained_mask | __contained_public_mask 417 }; 418 419 struct __upcast_result; 420 struct __dyncast_result; 421 422 protected: 423 // Implementation defined member functions. 424 virtual bool 425 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const; 426 427 virtual bool 428 __do_catch(const type_info* __thr_type, void** __thr_obj, 429 unsigned __outer) const; 430 431 public: 432 // Helper for upcast. See if DST is us, or one of our bases. 433 // Return false if not found, true if found. 434 virtual bool 435 __do_upcast(const __class_type_info* __dst, const void* __obj, 436 __upcast_result& __restrict __result) const; 437 438 // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly 439 // within OBJ_PTR. OBJ_PTR points to a base object of our type, 440 // which is the destination type. SRC2DST indicates how SRC 441 // objects might be contained within this type. If SRC_PTR is one 442 // of our SRC_TYPE bases, indicate the virtuality. Returns 443 // not_contained for non containment or private containment. 444 inline __sub_kind 445 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 446 const __class_type_info* __src_type, 447 const void* __src_ptr) const; 448 449 // Helper for dynamic cast. ACCESS_PATH gives the access from the 450 // most derived object to this base. DST_TYPE indicates the 451 // desired type we want. OBJ_PTR points to a base of our type 452 // within the complete object. SRC_TYPE indicates the static type 453 // started from and SRC_PTR points to that base within the most 454 // derived object. Fill in RESULT with what we find. Return true 455 // if we have located an ambiguous match. 456 virtual bool 457 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, 458 const __class_type_info* __dst_type, const void* __obj_ptr, 459 const __class_type_info* __src_type, const void* __src_ptr, 460 __dyncast_result& __result) const; 461 462 // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE 463 // bases are inherited by the type started from -- which is not 464 // necessarily the current type. The current type will be a base 465 // of the destination type. OBJ_PTR points to the current base. 466 virtual __sub_kind 467 __do_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 472 // Type information for a class with a single non-virtual base. 473 class __si_class_type_info : public __class_type_info 474 { 475 public: 476 const __class_type_info* __base_type; 477 478 explicit 479 __si_class_type_info(const char *__n, const __class_type_info *__base) 480 : __class_type_info(__n), __base_type(__base) { } 481 482 virtual 483 ~__si_class_type_info(); 484 485 protected: 486 __si_class_type_info(const __si_class_type_info&); 487 488 __si_class_type_info& 489 operator=(const __si_class_type_info&); 490 491 // Implementation defined member functions. 492 virtual bool 493 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, 494 const __class_type_info* __dst_type, const void* __obj_ptr, 495 const __class_type_info* __src_type, const void* __src_ptr, 496 __dyncast_result& __result) const; 497 498 virtual __sub_kind 499 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 500 const __class_type_info* __src_type, 501 const void* __sub_ptr) const; 502 503 virtual bool 504 __do_upcast(const __class_type_info*__dst, const void*__obj, 505 __upcast_result& __restrict __result) const; 506 }; 507 508 // Type information for a class with multiple and/or virtual bases. 509 class __vmi_class_type_info : public __class_type_info 510 { 511 public: 512 unsigned int __flags; // Details about the class hierarchy. 513 unsigned int __base_count; // Number of direct bases. 514 515 // The array of bases uses the trailing array struct hack so this 516 // class is not constructable with a normal constructor. It is 517 // internally generated by the compiler. 518 __base_class_type_info __base_info[1]; // Array of bases. 519 520 explicit 521 __vmi_class_type_info(const char* __n, int ___flags) 522 : __class_type_info(__n), __flags(___flags), __base_count(0) { } 523 524 virtual 525 ~__vmi_class_type_info(); 526 527 // Implementation defined types. 528 enum __flags_masks 529 { 530 __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base. 531 __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance. 532 __flags_unknown_mask = 0x10 533 }; 534 535 protected: 536 // Implementation defined member functions. 537 virtual bool 538 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, 539 const __class_type_info* __dst_type, const void* __obj_ptr, 540 const __class_type_info* __src_type, const void* __src_ptr, 541 __dyncast_result& __result) const; 542 543 virtual __sub_kind 544 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, 545 const __class_type_info* __src_type, 546 const void* __src_ptr) const; 547 548 virtual bool 549 __do_upcast(const __class_type_info* __dst, const void* __obj, 550 __upcast_result& __restrict __result) const; 551 }; 552 553 // Dynamic cast runtime. 554 // src2dst has the following possible values 555 // >-1: src_type is a unique public non-virtual base of dst_type 556 // dst_ptr + src2dst == src_ptr 557 // -1: unspecified relationship 558 // -2: src_type is not a public base of dst_type 559 // -3: src_type is a multiple public non-virtual base of dst_type 560 extern "C" void* 561 __dynamic_cast(const void* __src_ptr, // Starting object. 562 const __class_type_info* __src_type, // Static type of object. 563 const __class_type_info* __dst_type, // Desired target type. 564 ptrdiff_t __src2dst); // How src and dst are related. 565 566 567 // Returns the type_info for the currently handled exception [15.3/8], or 568 // null if there is none. 569 extern "C" std::type_info* 570 __cxa_current_exception_type(); 571 572 // A magic placeholder class that can be caught by reference 573 // to recognize foreign exceptions. 574 class __foreign_exception 575 { 576 virtual ~__foreign_exception() throw(); 577 virtual void __pure_dummy() = 0; // prevent catch by value 578 }; 579 580} // namespace __cxxabiv1 581 582/** @namespace abi 583 * @brief The cross-vendor C++ Application Binary Interface. A 584 * namespace alias to __cxxabiv1, but user programs should use the 585 * alias `abi'. 586 * 587 * A brief overview of an ABI is given in the libstdc++ FAQ, question 588 * 5.8 (you may have a copy of the FAQ locally, or you can view the online 589 * version at http://gcc.gnu.org/onlinedocs/libstdc++/faq/index.html#5_8). 590 * 591 * GCC subscribes to a cross-vendor ABI for C++, sometimes 592 * called the IA64 ABI because it happens to be the native ABI for that 593 * platform. It is summarized at http://www.codesourcery.com/cxx-abi/ 594 * along with the current specification. 595 * 596 * For users of GCC greater than or equal to 3.x, entry points are 597 * available in <cxxabi.h>, which notes, <em>"It is not normally 598 * necessary for user programs to include this header, or use the 599 * entry points directly. However, this header is available should 600 * that be needed."</em> 601*/ 602namespace abi = __cxxabiv1; 603 604#endif // __cplusplus 605 606#pragma GCC visibility pop 607 608#endif // __CXXABI_H 609