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>
61 typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(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);
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*));
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));
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);
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);
95 __cxa_vec_dtor(void* __array_address, size_t __element_count,
96 size_t __element_size, __cxa_cdtor_type __destructor);
99 __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
100 __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW;
102 // Destruct and release array.
104 __cxa_vec_delete(void* __array_address, size_t __element_size,
105 size_t __padding_size, __cxa_cdtor_type __destructor);
108 __cxa_vec_delete2(void* __array_address, size_t __element_size,
109 size_t __padding_size, __cxa_cdtor_type __destructor,
110 void (*__dealloc) (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));
118 __cxa_guard_acquire(__guard*);
121 __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW;
124 __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW;
128 __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW;
131 __cxa_finalize(void*);
133 // Pure virtual functions.
135 __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
138 __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
140 // Exception handling auxillary.
142 __cxa_bad_cast() __attribute__((__noreturn__));
145 __cxa_bad_typeid() __attribute__((__noreturn__));
149 * @brief Demangling routine.
150 * ABI-mandated entry point in the C++ runtime library for demangling.
152 * @param __mangled_name A NUL-terminated character string
153 * containing the name to be demangled.
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.
162 * @param __length If @a __length is non-NULL, the length of the
163 * buffer containing the demangled name is placed in @a *__length.
165 * @param __status @a *__status is set to one of the following values:
166 * 0: The demangling operation succeeded.
167 * -1: A memory allocation failure 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.
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.
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.
179 * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html
180 * for other examples of use.
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.
189 __cxa_demangle(const char* __mangled_name, char* __output_buffer,
190 size_t* __length, int* __status);
194 } // namespace __cxxabiv1
203 // Type information for int, float etc.
204 class __fundamental_type_info : public std::type_info
208 __fundamental_type_info(const char* __n) : std::type_info(__n) { }
211 ~__fundamental_type_info();
214 // Type information for array objects.
215 class __array_type_info : public std::type_info
219 __array_type_info(const char* __n) : std::type_info(__n) { }
222 ~__array_type_info();
225 // Type information for functions (both member and non-member).
226 class __function_type_info : public std::type_info
230 __function_type_info(const char* __n) : std::type_info(__n) { }
233 ~__function_type_info();
236 // Implementation defined member function.
238 __is_function_p() const;
241 // Type information for enumerations.
242 class __enum_type_info : public std::type_info
246 __enum_type_info(const char* __n) : std::type_info(__n) { }
252 // Common type information for simple pointers and pointers to member.
253 class __pbase_type_info : public std::type_info
256 unsigned int __flags; // Qualification of the target object.
257 const std::type_info* __pointee; // Type of pointed to object.
260 __pbase_type_info(const char* __n, int __quals,
261 const std::type_info* __type)
262 : std::type_info(__n), __flags(__quals), __pointee(__type)
266 ~__pbase_type_info();
268 // Implementation defined type.
272 __volatile_mask = 0x2,
273 __restrict_mask = 0x4,
274 __incomplete_mask = 0x8,
275 __incomplete_class_mask = 0x10
279 __pbase_type_info(const __pbase_type_info&);
282 operator=(const __pbase_type_info&);
284 // Implementation defined member functions.
286 __do_catch(const std::type_info* __thr_type, void** __thr_obj,
287 unsigned int __outer) const;
290 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
291 unsigned __outer) const;
294 // Type information for simple pointers.
295 class __pointer_type_info : public __pbase_type_info
299 __pointer_type_info(const char* __n, int __quals,
300 const std::type_info* __type)
301 : __pbase_type_info (__n, __quals, __type) { }
305 ~__pointer_type_info();
308 // Implementation defined member functions.
310 __is_pointer_p() const;
313 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
314 unsigned __outer) const;
317 class __class_type_info;
319 // Type information for a pointer to member variable.
320 class __pointer_to_member_type_info : public __pbase_type_info
323 __class_type_info* __context; // Class of the member.
326 __pointer_to_member_type_info(const char* __n, int __quals,
327 const std::type_info* __type,
328 __class_type_info* __klass)
329 : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
332 ~__pointer_to_member_type_info();
335 __pointer_to_member_type_info(const __pointer_to_member_type_info&);
337 __pointer_to_member_type_info&
338 operator=(const __pointer_to_member_type_info&);
340 // Implementation defined member function.
342 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
343 unsigned __outer) const;
346 // Helper class for __vmi_class_type.
347 class __base_class_type_info
350 const __class_type_info* __base_type; // Base class type.
351 long __offset_flags; // Offset and info.
353 enum __offset_flags_masks
355 __virtual_mask = 0x1,
358 __offset_shift = 8 // Bits to shift offset.
361 // Implementation defined member functions.
363 __is_virtual_p() const
364 { return __offset_flags & __virtual_mask; }
367 __is_public_p() const
368 { return __offset_flags & __public_mask; }
373 // This shift, being of a signed type, is implementation
374 // defined. GCC implements such shifts as arithmetic, which is
376 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
380 // Type information for a class.
381 class __class_type_info : public std::type_info
385 __class_type_info (const char *__n) : type_info(__n) { }
388 ~__class_type_info ();
390 // Implementation defined types.
391 // The type sub_kind tells us about how a base object is contained
392 // within a derived object. We often do this lazily, hence the
393 // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
394 // not publicly contained.
400 // Not contained within us (in some circumstances this might
401 // mean not contained publicly)
404 // Contained ambiguously.
407 // Via a virtual path.
408 __contained_virtual_mask = __base_class_type_info::__virtual_mask,
410 // Via a public path.
411 __contained_public_mask = __base_class_type_info::__public_mask,
413 // Contained within us.
414 __contained_mask = 1 << __base_class_type_info::__hwm_bit,
416 __contained_private = __contained_mask,
417 __contained_public = __contained_mask | __contained_public_mask
420 struct __upcast_result;
421 struct __dyncast_result;
424 // Implementation defined member functions.
426 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
429 __do_catch(const type_info* __thr_type, void** __thr_obj,
430 unsigned __outer) const;
433 // Helper for upcast. See if DST is us, or one of our bases.
434 // Return false if not found, true if found.
436 __do_upcast(const __class_type_info* __dst, const void* __obj,
437 __upcast_result& __restrict __result) const;
439 // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
440 // within OBJ_PTR. OBJ_PTR points to a base object of our type,
441 // which is the destination type. SRC2DST indicates how SRC
442 // objects might be contained within this type. If SRC_PTR is one
443 // of our SRC_TYPE bases, indicate the virtuality. Returns
444 // not_contained for non containment or private containment.
446 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
447 const __class_type_info* __src_type,
448 const void* __src_ptr) const;
450 // Helper for dynamic cast. ACCESS_PATH gives the access from the
451 // most derived object to this base. DST_TYPE indicates the
452 // desired type we want. OBJ_PTR points to a base of our type
453 // within the complete object. SRC_TYPE indicates the static type
454 // started from and SRC_PTR points to that base within the most
455 // derived object. Fill in RESULT with what we find. Return true
456 // if we have located an ambiguous match.
458 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
459 const __class_type_info* __dst_type, const void* __obj_ptr,
460 const __class_type_info* __src_type, const void* __src_ptr,
461 __dyncast_result& __result) const;
463 // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
464 // bases are inherited by the type started from -- which is not
465 // necessarily the current type. The current type will be a base
466 // of the destination type. OBJ_PTR points to the current base.
468 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
469 const __class_type_info* __src_type,
470 const void* __src_ptr) const;
473 // Type information for a class with a single non-virtual base.
474 class __si_class_type_info : public __class_type_info
477 const __class_type_info* __base_type;
480 __si_class_type_info(const char *__n, const __class_type_info *__base)
481 : __class_type_info(__n), __base_type(__base) { }
484 ~__si_class_type_info();
487 __si_class_type_info(const __si_class_type_info&);
489 __si_class_type_info&
490 operator=(const __si_class_type_info&);
492 // Implementation defined member functions.
494 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
495 const __class_type_info* __dst_type, const void* __obj_ptr,
496 const __class_type_info* __src_type, const void* __src_ptr,
497 __dyncast_result& __result) const;
500 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
501 const __class_type_info* __src_type,
502 const void* __sub_ptr) const;
505 __do_upcast(const __class_type_info*__dst, const void*__obj,
506 __upcast_result& __restrict __result) const;
509 // Type information for a class with multiple and/or virtual bases.
510 class __vmi_class_type_info : public __class_type_info
513 unsigned int __flags; // Details about the class hierarchy.
514 unsigned int __base_count; // Number of direct bases.
516 // The array of bases uses the trailing array struct hack so this
517 // class is not constructable with a normal constructor. It is
518 // internally generated by the compiler.
519 __base_class_type_info __base_info[1]; // Array of bases.
522 __vmi_class_type_info(const char* __n, int ___flags)
523 : __class_type_info(__n), __flags(___flags), __base_count(0) { }
526 ~__vmi_class_type_info();
528 // Implementation defined types.
531 __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
532 __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
533 __flags_unknown_mask = 0x10
537 // Implementation defined member functions.
539 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
540 const __class_type_info* __dst_type, const void* __obj_ptr,
541 const __class_type_info* __src_type, const void* __src_ptr,
542 __dyncast_result& __result) const;
545 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
546 const __class_type_info* __src_type,
547 const void* __src_ptr) const;
550 __do_upcast(const __class_type_info* __dst, const void* __obj,
551 __upcast_result& __restrict __result) const;
554 // Exception handling forward declarations.
555 struct __cxa_exception;
556 struct __cxa_refcounted_exception;
557 struct __cxa_dependent_exception;
558 struct __cxa_eh_globals;
562 // Dynamic cast runtime.
564 // src2dst has the following possible values
565 // >-1: src_type is a unique public non-virtual base of dst_type
566 // dst_ptr + src2dst == src_ptr
567 // -1: unspecified relationship
568 // -2: src_type is not a public base of dst_type
569 // -3: src_type is a multiple public non-virtual base of dst_type
571 __dynamic_cast(const void* __src_ptr, // Starting object.
572 const __class_type_info* __src_type, // Static type of object.
573 const __class_type_info* __dst_type, // Desired target type.
574 ptrdiff_t __src2dst); // How src and dst are related.
577 // Exception handling runtime.
579 // The __cxa_eh_globals for the current thread can be obtained by using
580 // either of the following functions. The "fast" version assumes at least
581 // one prior call of __cxa_get_globals has been made from the current
582 // thread, so no initialization is necessary.
584 __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__));
587 __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__));
589 // Allocate memory for the primary exception plus the thrown object.
591 __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW;
593 // Free the space allocated for the primary exception.
595 __cxa_free_exception(void*) _GLIBCXX_NOTHROW;
597 // Throw the exception.
599 __cxa_throw(void*, std::type_info*, void (*) (void *))
600 __attribute__((__noreturn__));
602 // Used to implement exception handlers.
604 __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__));
607 __cxa_begin_catch(void*) _GLIBCXX_NOTHROW;
613 __cxa_rethrow() __attribute__((__noreturn__));
615 // Returns the type_info for the currently handled exception [15.3/8], or
616 // null if there is none.
618 __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__));
622 // Allocate memory for a dependent exception.
623 __cxa_dependent_exception*
624 __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW;
626 // Free the space allocated for the dependent exception.
628 __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW;
632 // A magic placeholder class that can be caught by reference
633 // to recognize foreign exceptions.
634 class __foreign_exception
636 virtual ~__foreign_exception() throw();
637 virtual void __pure_dummy() = 0; // prevent catch by value
640 } // namespace __cxxabiv1
643 * @brief The cross-vendor C++ Application Binary Interface. A
644 * namespace alias to __cxxabiv1, but user programs should use the
647 * A brief overview of an ABI is given in the libstdc++ FAQ, question
648 * 5.8 (you may have a copy of the FAQ locally, or you can view the online
649 * version at http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#5_8 ).
651 * GCC subscribes to a cross-vendor ABI for C++, sometimes
652 * called the IA64 ABI because it happens to be the native ABI for that
653 * platform. It is summarized at http://www.codesourcery.com/cxx-abi/
654 * along with the current specification.
656 * For users of GCC greater than or equal to 3.x, entry points are
657 * available in <cxxabi.h>, which notes, <em>'It is not normally
658 * necessary for user programs to include this header, or use the
659 * entry points directly. However, this header is available should
660 * that be needed.'</em>
662 namespace abi = __cxxabiv1;
667 * @brief Exception thrown by __cxa_guard_acquire.
668 * @ingroup exceptions
670 * 6.7[stmt.dcl]/4: If control re-enters the declaration (recursively)
671 * while the object is being initialized, the behavior is undefined.
673 * Since we already have a library function to handle locking, we might
674 * as well check for this situation and throw an exception.
675 * We use the second byte of the guard variable to remember that we're
676 * in the middle of an initialization.
678 class recursive_init_error: public std::exception
681 recursive_init_error() throw() { }
682 virtual ~recursive_init_error() throw ();
685 #endif // __cplusplus
687 #pragma GCC visibility pop