1 // ABI Support -*- C++ -*-
3 // Copyright (C) 2000, 2002, 2003, 2004, 2006, 2007, 2009, 2010, 2011
4 // Free Software Foundation, Inc.
6 // This file is part of GCC.
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)
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.
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.
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/>.
27 // Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
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
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. */
39 * The header provides an interface to the C++ ABI.
45 #pragma GCC system_header
47 #pragma GCC visibility push(default)
50 #include <bits/c++config.h>
51 #include <bits/cxxabi_tweaks.h>
52 #include <bits/cxxabi_forced.h>
54 #ifndef _GLIBCXX_CDTOR_CALLABI
55 #define _GLIBCXX_CDTOR_CALLABI
65 typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(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);
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*));
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));
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);
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);
99 __cxa_vec_dtor(void* __array_address, size_t __element_count,
100 size_t __element_size, __cxa_cdtor_type __destructor);
103 __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
104 __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW;
106 // Destruct and release array.
108 __cxa_vec_delete(void* __array_address, size_t __element_size,
109 size_t __padding_size, __cxa_cdtor_type __destructor);
112 __cxa_vec_delete2(void* __array_address, size_t __element_size,
113 size_t __padding_size, __cxa_cdtor_type __destructor,
114 void (*__dealloc) (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));
122 __cxa_guard_acquire(__guard*);
125 __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW;
128 __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW;
132 __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW;
135 __cxa_finalize(void*);
137 // Pure virtual functions.
139 __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
142 __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
144 // Exception handling auxillary.
146 __cxa_bad_cast() __attribute__((__noreturn__));
149 __cxa_bad_typeid() __attribute__((__noreturn__));
153 * @brief Demangling routine.
154 * ABI-mandated entry point in the C++ runtime library for demangling.
156 * @param __mangled_name A NUL-terminated character string
157 * containing the name to be demangled.
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.
166 * @param __length If @a __length is non-NULL, the length of the
167 * buffer containing the demangled name is placed in @a *__length.
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.
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.
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.
183 * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html
184 * for other examples of use.
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.
193 __cxa_demangle(const char* __mangled_name, char* __output_buffer,
194 size_t* __length, int* __status);
198 } // namespace __cxxabiv1
207 // Type information for int, float etc.
208 class __fundamental_type_info : public std::type_info
212 __fundamental_type_info(const char* __n) : std::type_info(__n) { }
215 ~__fundamental_type_info();
218 // Type information for array objects.
219 class __array_type_info : public std::type_info
223 __array_type_info(const char* __n) : std::type_info(__n) { }
226 ~__array_type_info();
229 // Type information for functions (both member and non-member).
230 class __function_type_info : public std::type_info
234 __function_type_info(const char* __n) : std::type_info(__n) { }
237 ~__function_type_info();
240 // Implementation defined member function.
242 __is_function_p() const;
245 // Type information for enumerations.
246 class __enum_type_info : public std::type_info
250 __enum_type_info(const char* __n) : std::type_info(__n) { }
256 // Common type information for simple pointers and pointers to member.
257 class __pbase_type_info : public std::type_info
260 unsigned int __flags; // Qualification of the target object.
261 const std::type_info* __pointee; // Type of pointed to object.
264 __pbase_type_info(const char* __n, int __quals,
265 const std::type_info* __type)
266 : std::type_info(__n), __flags(__quals), __pointee(__type)
270 ~__pbase_type_info();
272 // Implementation defined type.
276 __volatile_mask = 0x2,
277 __restrict_mask = 0x4,
278 __incomplete_mask = 0x8,
279 __incomplete_class_mask = 0x10
283 __pbase_type_info(const __pbase_type_info&);
286 operator=(const __pbase_type_info&);
288 // Implementation defined member functions.
290 __do_catch(const std::type_info* __thr_type, void** __thr_obj,
291 unsigned int __outer) const;
294 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
295 unsigned __outer) const;
298 // Type information for simple pointers.
299 class __pointer_type_info : public __pbase_type_info
303 __pointer_type_info(const char* __n, int __quals,
304 const std::type_info* __type)
305 : __pbase_type_info (__n, __quals, __type) { }
309 ~__pointer_type_info();
312 // Implementation defined member functions.
314 __is_pointer_p() const;
317 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
318 unsigned __outer) const;
321 class __class_type_info;
323 // Type information for a pointer to member variable.
324 class __pointer_to_member_type_info : public __pbase_type_info
327 __class_type_info* __context; // Class of the member.
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) { }
336 ~__pointer_to_member_type_info();
339 __pointer_to_member_type_info(const __pointer_to_member_type_info&);
341 __pointer_to_member_type_info&
342 operator=(const __pointer_to_member_type_info&);
344 // Implementation defined member function.
346 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
347 unsigned __outer) const;
350 // Helper class for __vmi_class_type.
351 class __base_class_type_info
354 const __class_type_info* __base_type; // Base class type.
355 long __offset_flags; // Offset and info.
357 enum __offset_flags_masks
359 __virtual_mask = 0x1,
362 __offset_shift = 8 // Bits to shift offset.
365 // Implementation defined member functions.
367 __is_virtual_p() const
368 { return __offset_flags & __virtual_mask; }
371 __is_public_p() const
372 { return __offset_flags & __public_mask; }
377 // This shift, being of a signed type, is implementation
378 // defined. GCC implements such shifts as arithmetic, which is
380 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
384 // Type information for a class.
385 class __class_type_info : public std::type_info
389 __class_type_info (const char *__n) : type_info(__n) { }
392 ~__class_type_info ();
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.
404 // Not contained within us (in some circumstances this might
405 // mean not contained publicly)
408 // Contained ambiguously.
411 // Via a virtual path.
412 __contained_virtual_mask = __base_class_type_info::__virtual_mask,
414 // Via a public path.
415 __contained_public_mask = __base_class_type_info::__public_mask,
417 // Contained within us.
418 __contained_mask = 1 << __base_class_type_info::__hwm_bit,
420 __contained_private = __contained_mask,
421 __contained_public = __contained_mask | __contained_public_mask
424 struct __upcast_result;
425 struct __dyncast_result;
428 // Implementation defined member functions.
430 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
433 __do_catch(const type_info* __thr_type, void** __thr_obj,
434 unsigned __outer) const;
437 // Helper for upcast. See if DST is us, or one of our bases.
438 // Return false if not found, true if found.
440 __do_upcast(const __class_type_info* __dst, const void* __obj,
441 __upcast_result& __restrict __result) const;
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.
450 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
451 const __class_type_info* __src_type,
452 const void* __src_ptr) const;
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.
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;
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.
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;
477 // Type information for a class with a single non-virtual base.
478 class __si_class_type_info : public __class_type_info
481 const __class_type_info* __base_type;
484 __si_class_type_info(const char *__n, const __class_type_info *__base)
485 : __class_type_info(__n), __base_type(__base) { }
488 ~__si_class_type_info();
491 __si_class_type_info(const __si_class_type_info&);
493 __si_class_type_info&
494 operator=(const __si_class_type_info&);
496 // Implementation defined member functions.
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;
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;
509 __do_upcast(const __class_type_info*__dst, const void*__obj,
510 __upcast_result& __restrict __result) const;
513 // Type information for a class with multiple and/or virtual bases.
514 class __vmi_class_type_info : public __class_type_info
517 unsigned int __flags; // Details about the class hierarchy.
518 unsigned int __base_count; // Number of direct bases.
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.
526 __vmi_class_type_info(const char* __n, int ___flags)
527 : __class_type_info(__n), __flags(___flags), __base_count(0) { }
530 ~__vmi_class_type_info();
532 // Implementation defined types.
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
541 // Implementation defined member functions.
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;
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;
554 __do_upcast(const __class_type_info* __dst, const void* __obj,
555 __upcast_result& __restrict __result) const;
558 // Exception handling forward declarations.
559 struct __cxa_exception;
560 struct __cxa_refcounted_exception;
561 struct __cxa_dependent_exception;
562 struct __cxa_eh_globals;
566 // Dynamic cast runtime.
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
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.
581 // Exception handling runtime.
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.
588 __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__));
591 __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__));
593 // Allocate memory for the primary exception plus the thrown object.
595 __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW;
597 // Free the space allocated for the primary exception.
599 __cxa_free_exception(void*) _GLIBCXX_NOTHROW;
601 // Throw the exception.
603 __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *))
604 __attribute__((__noreturn__));
606 // Used to implement exception handlers.
608 __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__));
611 __cxa_begin_catch(void*) _GLIBCXX_NOTHROW;
617 __cxa_rethrow() __attribute__((__noreturn__));
619 // Returns the type_info for the currently handled exception [15.3/8], or
620 // null if there is none.
622 __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__));
626 // Allocate memory for a dependent exception.
627 __cxa_dependent_exception*
628 __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW;
630 // Free the space allocated for the dependent exception.
632 __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW;
636 // A magic placeholder class that can be caught by reference
637 // to recognize foreign exceptions.
638 class __foreign_exception
640 virtual ~__foreign_exception() throw();
641 virtual void __pure_dummy() = 0; // prevent catch by value
644 } // namespace __cxxabiv1
647 * @brief The cross-vendor C++ Application Binary Interface. A
648 * namespace alias to __cxxabiv1, but user programs should use the
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 ).
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.
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>
666 namespace abi = __cxxabiv1;
671 * @brief Exception thrown by __cxa_guard_acquire.
672 * @ingroup exceptions
674 * 6.7[stmt.dcl]/4: If control re-enters the declaration (recursively)
675 * while the object is being initialized, the behavior is undefined.
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.
682 class recursive_init_error: public std::exception
685 recursive_init_error() throw() { }
686 virtual ~recursive_init_error() throw ();
689 #endif // __cplusplus
691 #pragma GCC visibility pop