libstdc++
cxxabi.h
Go to the documentation of this file.
1 // ABI Support -*- C++ -*-
2 
3 // Copyright (C) 2000-2025 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>
55 
56 #ifdef __cplusplus
57 namespace __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 
218 namespace __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 */
689 namespace abi = __cxxabiv1;
690 
691 namespace __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  */
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
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
constexpr _Iterator __base(_Iterator __it)
Exception thrown by __cxa_guard_acquire.
Definition: cxxabi.h:707
Part of RTTI.
Definition: typeinfo:94
Base class for all library exceptions.
Definition: exception.h:62