Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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