mingw/include/c++/3.4.2/cxxabi.h

   1 // new abi support -*- C++ -*-
   2
   3 // Copyright (C) 2000, 2002, 2003, 2004 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 2, 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 // You should have received a copy of the GNU General Public License
  18 // along with GCC; see the file COPYING.  If not, write to
  19 // the Free Software Foundation, 59 Temple Place - Suite 330,
  20 // Boston, MA 02111-1307, USA.
  21
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 // Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
  32
  33 /* This file declares the new abi entry points into the runtime. It is not
  34    normally necessary for user programs to include this header, or use the
  35    entry points directly. However, this header is available should that be
  36    needed.
  37
  38    Some of the entry points are intended for both C and C++, thus this header
  39    is includable from both C and C++. Though the C++ specific parts are not
  40    available in C, naturally enough.  */
  41
  42 #ifndef _CXXABI_H
  43 #define _CXXABI_H 1
  44
  45 #include <stddef.h>
  46
  47 #ifdef __cplusplus
  48 namespace __cxxabiv1
  49 {
  50   extern "C"
  51   {
  52 #endif
  53
  54   // Allocate array.
  55   void*
  56   __cxa_vec_new(size_t __element_count, size_t __element_size,
  57                 size_t __padding_size, void (*__constructor) (void*),
  58                 void (*__destructor) (void*));
  59
  60   void*
  61   __cxa_vec_new2(size_t __element_count, size_t __element_size,
  62                  size_t __padding_size, void (*__constructor) (void*),
  63                  void (*__destructor) (void*), void *(*__alloc) (size_t),
  64                  void (*__dealloc) (void*));
  65
  66   void*
  67   __cxa_vec_new3(size_t __element_count, size_t __element_size,
  68                  size_t __padding_size, void (*__constructor) (void*),
  69                  void (*__destructor) (void*), void *(*__alloc) (size_t),
  70                  void (*__dealloc) (void*, size_t));
  71
  72   // Construct array.
  73   void
  74   __cxa_vec_ctor(void* __array_address, size_t __element_count,
  75                  size_t __element_size, void (*__constructor) (void*),
  76                  void (*__destructor) (void*));
  77
  78   void
  79   __cxa_vec_cctor(void* dest_array, void* src_array, size_t element_count,
  80                   size_t element_size, void (*constructor) (void*, void*),
  81                   void (*destructor) (void*));
  82
  83   // Destruct array.
  84   void
  85   __cxa_vec_dtor(void* __array_address, size_t __element_count,
  86                  size_t __element_size, void (*__destructor) (void*));
  87
  88   void
  89   __cxa_vec_cleanup(void* __array_address, size_t __element_count,
  90                     size_t __element_size, void (*__destructor) (void*));
  91
  92   // Destruct and release array.
  93   void
  94   __cxa_vec_delete(void* __array_address, size_t __element_size,
  95                    size_t __padding_size, void (*__destructor) (void*));
  96
  97   void
  98   __cxa_vec_delete2(void* __array_address, size_t __element_size,
  99                     size_t __padding_size, void (*__destructor) (void*),
 100                     void (*__dealloc) (void*));
 101
 102   void
 103   __cxa_vec_delete3(void* __array_address, size_t __element_size,
 104                     size_t __padding_size, void (*__destructor) (void*),
 105                     void (*__dealloc) (void*, size_t));
 106
 107   // The ABI requires a 64-bit type.
 108   __extension__ typedef int __guard __attribute__((mode (__DI__)));
 109
 110   int
 111   __cxa_guard_acquire(__guard*);
 112
 113   void
 114   __cxa_guard_release(__guard*);
 115
 116   void
 117   __cxa_guard_abort(__guard*);
 118
 119   // Pure virtual functions.
 120   void
 121   __cxa_pure_virtual(void);
 122
 123   // Exception handling.
 124   void
 125   __cxa_bad_cast();
 126
 127   void
 128   __cxa_bad_typeid();
 129
 130   // DSO destruction.
 131   int
 132   __cxa_atexit(void (*)(void*), void*, void*);
 133
 134   int
 135   __cxa_finalize(void*);
 136
 137   // Demangling routines.
 138   char*
 139   __cxa_demangle(const char* __mangled_name, char* __output_buffer,
 140                  size_t* __length, int* __status);
 141 #ifdef __cplusplus
 142   }
 143 } // namespace __cxxabiv1
 144 #endif
 145
 146 #ifdef __cplusplus
 147
 148 #include <typeinfo>
 149
 150 namespace __cxxabiv1
 151 {
 152   // Type information for int, float etc.
 153   class __fundamental_type_info : public std::type_info
 154   {
 155   public:
 156     explicit
 157     __fundamental_type_info(const char* __n) : std::type_info(__n) { }
 158
 159     virtual
 160     ~__fundamental_type_info();
 161   };
 162
 163   // Type information for array objects.
 164   class __array_type_info : public std::type_info
 165   {
 166   public:
 167     explicit
 168     __array_type_info(const char* __n) : std::type_info(__n) { }
 169
 170     virtual
 171     ~__array_type_info();
 172   };
 173
 174   // Type information for functions (both member and non-member).
 175   class __function_type_info : public std::type_info
 176   {
 177   public:
 178     explicit
 179     __function_type_info(const char* __n) : std::type_info(__n) { }
 180
 181     virtual
 182     ~__function_type_info();
 183
 184   protected:
 185     // Implementation defined member function.
 186     virtual bool
 187     __is_function_p() const;
 188   };
 189
 190   // Type information for enumerations.
 191   class __enum_type_info : public std::type_info
 192   {
 193   public:
 194     explicit
 195     __enum_type_info(const char* __n) : std::type_info(__n) { }
 196
 197     virtual
 198     ~__enum_type_info();
 199   };
 200
 201   // Common type information for simple pointers and pointers to member.
 202   class __pbase_type_info : public std::type_info
 203   {
 204   public:
 205     unsigned int                __flags; // Qualification of the target object.
 206     const std::type_info*       __pointee; // Type of pointed to object.
 207
 208     explicit
 209     __pbase_type_info(const char* __n, int __quals,
 210                       const std::type_info* __type)
 211     : std::type_info(__n), __flags(__quals), __pointee(__type)
 212     { }
 213
 214     virtual
 215     ~__pbase_type_info();
 216
 217     // Implementation defined type.
 218     enum __masks
 219       {
 220         __const_mask = 0x1,
 221         __volatile_mask = 0x2,
 222         __restrict_mask = 0x4,
 223         __incomplete_mask = 0x8,
 224         __incomplete_class_mask = 0x10
 225       };
 226
 227   protected:
 228     __pbase_type_info(const __pbase_type_info&);
 229
 230     __pbase_type_info&
 231     operator=(const __pbase_type_info&);
 232
 233     // Implementation defined member functions.
 234     virtual bool
 235     __do_catch(const std::type_info* __thr_type, void** __thr_obj,
 236                unsigned int __outer) const;
 237
 238     inline virtual bool
 239     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
 240                     unsigned __outer) const;
 241   };
 242
 243   // Type information for simple pointers.
 244   class __pointer_type_info : public __pbase_type_info
 245   {
 246   public:
 247     explicit
 248     __pointer_type_info(const char* __n, int __quals,
 249                         const std::type_info* __type)
 250     : __pbase_type_info (__n, __quals, __type) { }
 251
 252
 253     virtual
 254     ~__pointer_type_info();
 255
 256   protected:
 257     // Implementation defined member functions.
 258     virtual bool
 259     __is_pointer_p() const;
 260
 261     virtual bool
 262     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
 263                     unsigned __outer) const;
 264   };
 265
 266   class __class_type_info;
 267
 268   // Type information for a pointer to member variable.
 269   class __pointer_to_member_type_info : public __pbase_type_info
 270   {
 271   public:
 272     __class_type_info* __context;   // Class of the member.
 273
 274     explicit
 275     __pointer_to_member_type_info(const char* __n, int __quals,
 276                                   const std::type_info* __type,
 277                                   __class_type_info* __klass)
 278     : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
 279
 280     virtual
 281     ~__pointer_to_member_type_info();
 282
 283   protected:
 284     __pointer_to_member_type_info(const __pointer_to_member_type_info&);
 285
 286     __pointer_to_member_type_info&
 287     operator=(const __pointer_to_member_type_info&);
 288
 289     // Implementation defined member function.
 290     virtual bool
 291     __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
 292                     unsigned __outer) const;
 293   };
 294
 295   // Helper class for __vmi_class_type.
 296   class __base_class_type_info
 297   {
 298   public:
 299     const __class_type_info*    __base_type;  // Base class type.
 300     long                        __offset_flags;  // Offset and info.
 301
 302     enum __offset_flags_masks
 303       {
 304         __virtual_mask = 0x1,
 305         __public_mask = 0x2,
 306         __hwm_bit = 2,
 307         __offset_shift = 8          // Bits to shift offset.
 308       };
 309
 310     // Implementation defined member functions.
 311     bool
 312     __is_virtual_p() const
 313     { return __offset_flags & __virtual_mask; }
 314
 315     bool
 316     __is_public_p() const
 317     { return __offset_flags & __public_mask; }
 318
 319     ptrdiff_t
 320     __offset() const
 321     {
 322       // This shift, being of a signed type, is implementation
 323       // defined. GCC implements such shifts as arithmetic, which is
 324       // what we want.
 325       return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
 326     }
 327   };
 328
 329   // Type information for a class.
 330   class __class_type_info : public std::type_info
 331   {
 332   public:
 333     explicit
 334     __class_type_info (const char *__n) : type_info(__n) { }
 335
 336     virtual
 337     ~__class_type_info ();
 338
 339     // Implementation defined types.
 340     // The type sub_kind tells us about how a base object is contained
 341     // within a derived object. We often do this lazily, hence the
 342     // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
 343     // not publicly contained.
 344     enum __sub_kind
 345       {
 346         // We have no idea.
 347         __unknown = 0,
 348
 349         // Not contained within us (in some circumstances this might
 350         // mean not contained publicly)
 351         __not_contained,
 352
 353         // Contained ambiguously.
 354         __contained_ambig,
 355
 356         // Via a virtual path.
 357         __contained_virtual_mask = __base_class_type_info::__virtual_mask,
 358
 359         // Via a public path.
 360         __contained_public_mask = __base_class_type_info::__public_mask,
 361
 362         // Contained within us.
 363         __contained_mask = 1 << __base_class_type_info::__hwm_bit,
 364
 365         __contained_private = __contained_mask,
 366         __contained_public = __contained_mask | __contained_public_mask
 367       };
 368
 369     struct __upcast_result;
 370     struct __dyncast_result;
 371
 372   protected:
 373     // Implementation defined member functions.
 374     virtual bool
 375     __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
 376
 377     virtual bool
 378     __do_catch(const type_info* __thr_type, void** __thr_obj,
 379                unsigned __outer) const;
 380
 381   public:
 382     // Helper for upcast. See if DST is us, or one of our bases.
 383     // Return false if not found, true if found.
 384     virtual bool
 385     __do_upcast(const __class_type_info* __dst, const void* __obj,
 386                 __upcast_result& __restrict __result) const;
 387
 388     // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
 389     // within OBJ_PTR. OBJ_PTR points to a base object of our type,
 390     // which is the destination type. SRC2DST indicates how SRC
 391     // objects might be contained within this type.  If SRC_PTR is one
 392     // of our SRC_TYPE bases, indicate the virtuality. Returns
 393     // not_contained for non containment or private containment.
 394     inline __sub_kind
 395     __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
 396                       const __class_type_info* __src_type,
 397                       const void* __src_ptr) const;
 398
 399     // Helper for dynamic cast. ACCESS_PATH gives the access from the
 400     // most derived object to this base. DST_TYPE indicates the
 401     // desired type we want. OBJ_PTR points to a base of our type
 402     // within the complete object. SRC_TYPE indicates the static type
 403     // started from and SRC_PTR points to that base within the most
 404     // derived object. Fill in RESULT with what we find. Return true
 405     // if we have located an ambiguous match.
 406     virtual bool
 407     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
 408                  const __class_type_info* __dst_type, const void* __obj_ptr,
 409                  const __class_type_info* __src_type, const void* __src_ptr,
 410                  __dyncast_result& __result) const;
 411
 412     // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
 413     // bases are inherited by the type started from -- which is not
 414     // necessarily the current type. The current type will be a base
 415     // of the destination type.  OBJ_PTR points to the current base.
 416     virtual __sub_kind
 417     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
 418                          const __class_type_info* __src_type,
 419                          const void* __src_ptr) const;
 420   };
 421
 422   // Type information for a class with a single non-virtual base.
 423   class __si_class_type_info : public __class_type_info
 424   {
 425   public:
 426     const __class_type_info* __base_type;
 427
 428     explicit
 429     __si_class_type_info(const char *__n, const __class_type_info *__base)
 430     : __class_type_info(__n), __base_type(__base) { }
 431
 432     virtual
 433     ~__si_class_type_info();
 434
 435   protected:
 436     __si_class_type_info(const __si_class_type_info&);
 437
 438     __si_class_type_info&
 439     operator=(const __si_class_type_info&);
 440
 441     // Implementation defined member functions.
 442     virtual bool
 443     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
 444                  const __class_type_info* __dst_type, const void* __obj_ptr,
 445                  const __class_type_info* __src_type, const void* __src_ptr,
 446                  __dyncast_result& __result) const;
 447
 448     virtual __sub_kind
 449     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
 450                          const __class_type_info* __src_type,
 451                          const void* __sub_ptr) const;
 452
 453     virtual bool
 454     __do_upcast(const __class_type_info*__dst, const void*__obj,
 455                 __upcast_result& __restrict __result) const;
 456   };
 457
 458   // Type information for a class with multiple and/or virtual bases.
 459   class __vmi_class_type_info : public __class_type_info
 460   {
 461   public:
 462     unsigned int                __flags;  // Details about the class hierarchy.
 463     unsigned int                __base_count;  // Dumber of direct bases.
 464
 465     // The array of bases uses the trailing array struct hack so this
 466     // class is not constructable with a normal constructor. It is
 467     // internally generated by the compiler.
 468     __base_class_type_info      __base_info[1];  // Array of bases.
 469
 470     explicit
 471     __vmi_class_type_info(const char* __n, int ___flags)
 472     : __class_type_info(__n), __flags(___flags), __base_count(0) { }
 473
 474     virtual
 475     ~__vmi_class_type_info();
 476
 477     // Implementation defined types.
 478     enum __flags_masks
 479       {
 480         __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
 481         __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
 482         __flags_unknown_mask = 0x10
 483       };
 484
 485   protected:
 486     // Implementation defined member functions.
 487     virtual bool
 488     __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
 489                  const __class_type_info* __dst_type, const void* __obj_ptr,
 490                  const __class_type_info* __src_type, const void* __src_ptr,
 491                  __dyncast_result& __result) const;
 492
 493     virtual __sub_kind
 494     __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
 495                          const __class_type_info* __src_type,
 496                          const void* __src_ptr) const;
 497
 498     virtual bool
 499     __do_upcast(const __class_type_info* __dst, const void* __obj,
 500                 __upcast_result& __restrict __result) const;
 501   };
 502
 503   // Dynamic cast runtime.
 504   // src2dst has the following possible values
 505   //  >-1: src_type is a unique public non-virtual base of dst_type
 506   //       dst_ptr + src2dst == src_ptr
 507   //   -1: unspecified relationship
 508   //   -2: src_type is not a public base of dst_type
 509   //   -3: src_type is a multiple public non-virtual base of dst_type
 510   extern "C" void*
 511   __dynamic_cast(const void* __src_ptr, // Starting object.
 512                  const __class_type_info* __src_type, // Static type of object.
 513                  const __class_type_info* __dst_type, // Desired target type.
 514                  ptrdiff_t __src2dst); // How src and dst are related.
 515
 516
 517   // Returns the type_info for the currently handled exception [15.3/8], or
 518   // null if there is none.
 519   extern "C" std::type_info*
 520   __cxa_current_exception_type();
 521 } // namespace __cxxabiv1
 522
 523 // User programs should use the alias `abi'.
 524 namespace abi = __cxxabiv1;
 525
 526 #endif // __cplusplus
 527
 528 #endif // __CXXABI_H