libstdc++: cxxabi.h Source File

libstdc++

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