00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00046 #ifndef _CXXABI_H
00047 #define _CXXABI_H 1
00048
00049 #pragma GCC visibility push(default)
00050
00051 #include <stddef.h>
00052 #include <bits/cxxabi_tweaks.h>
00053
00054 #ifdef __cplusplus
00055 namespace __cxxabiv1
00056 {
00057 extern "C"
00058 {
00059 #endif
00060
00061 typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
00062
00063
00064 void*
00065 __cxa_vec_new(size_t __element_count, size_t __element_size,
00066 size_t __padding_size, __cxa_cdtor_type constructor,
00067 __cxa_cdtor_type destructor);
00068
00069 void*
00070 __cxa_vec_new2(size_t __element_count, size_t __element_size,
00071 size_t __padding_size, __cxa_cdtor_type constructor,
00072 __cxa_cdtor_type destructor, void *(*__alloc) (size_t),
00073 void (*__dealloc) (void*));
00074
00075 void*
00076 __cxa_vec_new3(size_t __element_count, size_t __element_size,
00077 size_t __padding_size, __cxa_cdtor_type constructor,
00078 __cxa_cdtor_type destructor, void *(*__alloc) (size_t),
00079 void (*__dealloc) (void*, size_t));
00080
00081
00082 __cxa_vec_ctor_return_type
00083 __cxa_vec_ctor(void* __array_address, size_t __element_count,
00084 size_t __element_size, __cxa_cdtor_type constructor,
00085 __cxa_cdtor_type destructor);
00086
00087 __cxa_vec_ctor_return_type
00088 __cxa_vec_cctor(void* dest_array, void* src_array, size_t element_count,
00089 size_t element_size,
00090 __cxa_cdtor_return_type (*constructor) (void*, void*),
00091 __cxa_cdtor_type destructor);
00092
00093
00094 void
00095 __cxa_vec_dtor(void* __array_address, size_t __element_count,
00096 size_t __element_size, __cxa_cdtor_type destructor);
00097
00098 void
00099 __cxa_vec_cleanup(void* __array_address, size_t __element_count,
00100 size_t __element_size, __cxa_cdtor_type destructor);
00101
00102
00103 void
00104 __cxa_vec_delete(void* __array_address, size_t __element_size,
00105 size_t __padding_size, __cxa_cdtor_type destructor);
00106
00107 void
00108 __cxa_vec_delete2(void* __array_address, size_t __element_size,
00109 size_t __padding_size, __cxa_cdtor_type destructor,
00110 void (*__dealloc) (void*));
00111
00112 void
00113 __cxa_vec_delete3(void* __array_address, size_t __element_size,
00114 size_t __padding_size, __cxa_cdtor_type destructor,
00115 void (*__dealloc) (void*, size_t));
00116
00117 int
00118 __cxa_guard_acquire(__guard*);
00119
00120 void
00121 __cxa_guard_release(__guard*);
00122
00123 void
00124 __cxa_guard_abort(__guard*);
00125
00126
00127 void
00128 __cxa_pure_virtual(void);
00129
00130
00131 void
00132 __cxa_bad_cast();
00133
00134 void
00135 __cxa_bad_typeid();
00136
00137
00138 int
00139 __cxa_atexit(void (*)(void*), void*, void*);
00140
00141 int
00142 __cxa_finalize(void*);
00143
00144
00145 char*
00146 __cxa_demangle(const char* __mangled_name, char* __output_buffer,
00147 size_t* __length, int* __status);
00148 #ifdef __cplusplus
00149 }
00150 }
00151 #endif
00152
00153 #ifdef __cplusplus
00154
00155 #include <typeinfo>
00156
00157 namespace __cxxabiv1
00158 {
00159
00160 class __fundamental_type_info : public std::type_info
00161 {
00162 public:
00163 explicit
00164 __fundamental_type_info(const char* __n) : std::type_info(__n) { }
00165
00166 virtual
00167 ~__fundamental_type_info();
00168 };
00169
00170
00171 class __array_type_info : public std::type_info
00172 {
00173 public:
00174 explicit
00175 __array_type_info(const char* __n) : std::type_info(__n) { }
00176
00177 virtual
00178 ~__array_type_info();
00179 };
00180
00181
00182 class __function_type_info : public std::type_info
00183 {
00184 public:
00185 explicit
00186 __function_type_info(const char* __n) : std::type_info(__n) { }
00187
00188 virtual
00189 ~__function_type_info();
00190
00191 protected:
00192
00193 virtual bool
00194 __is_function_p() const;
00195 };
00196
00197
00198 class __enum_type_info : public std::type_info
00199 {
00200 public:
00201 explicit
00202 __enum_type_info(const char* __n) : std::type_info(__n) { }
00203
00204 virtual
00205 ~__enum_type_info();
00206 };
00207
00208
00209 class __pbase_type_info : public std::type_info
00210 {
00211 public:
00212 unsigned int __flags;
00213 const std::type_info* __pointee;
00214
00215 explicit
00216 __pbase_type_info(const char* __n, int __quals,
00217 const std::type_info* __type)
00218 : std::type_info(__n), __flags(__quals), __pointee(__type)
00219 { }
00220
00221 virtual
00222 ~__pbase_type_info();
00223
00224
00225 enum __masks
00226 {
00227 __const_mask = 0x1,
00228 __volatile_mask = 0x2,
00229 __restrict_mask = 0x4,
00230 __incomplete_mask = 0x8,
00231 __incomplete_class_mask = 0x10
00232 };
00233
00234 protected:
00235 __pbase_type_info(const __pbase_type_info&);
00236
00237 __pbase_type_info&
00238 operator=(const __pbase_type_info&);
00239
00240
00241 virtual bool
00242 __do_catch(const std::type_info* __thr_type, void** __thr_obj,
00243 unsigned int __outer) const;
00244
00245 inline virtual bool
00246 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00247 unsigned __outer) const;
00248 };
00249
00250
00251 class __pointer_type_info : public __pbase_type_info
00252 {
00253 public:
00254 explicit
00255 __pointer_type_info(const char* __n, int __quals,
00256 const std::type_info* __type)
00257 : __pbase_type_info (__n, __quals, __type) { }
00258
00259
00260 virtual
00261 ~__pointer_type_info();
00262
00263 protected:
00264
00265 virtual bool
00266 __is_pointer_p() const;
00267
00268 virtual bool
00269 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00270 unsigned __outer) const;
00271 };
00272
00273 class __class_type_info;
00274
00275
00276 class __pointer_to_member_type_info : public __pbase_type_info
00277 {
00278 public:
00279 __class_type_info* __context;
00280
00281 explicit
00282 __pointer_to_member_type_info(const char* __n, int __quals,
00283 const std::type_info* __type,
00284 __class_type_info* __klass)
00285 : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
00286
00287 virtual
00288 ~__pointer_to_member_type_info();
00289
00290 protected:
00291 __pointer_to_member_type_info(const __pointer_to_member_type_info&);
00292
00293 __pointer_to_member_type_info&
00294 operator=(const __pointer_to_member_type_info&);
00295
00296
00297 virtual bool
00298 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00299 unsigned __outer) const;
00300 };
00301
00302
00303 class __base_class_type_info
00304 {
00305 public:
00306 const __class_type_info* __base_type;
00307 long __offset_flags;
00308
00309 enum __offset_flags_masks
00310 {
00311 __virtual_mask = 0x1,
00312 __public_mask = 0x2,
00313 __hwm_bit = 2,
00314 __offset_shift = 8
00315 };
00316
00317
00318 bool
00319 __is_virtual_p() const
00320 { return __offset_flags & __virtual_mask; }
00321
00322 bool
00323 __is_public_p() const
00324 { return __offset_flags & __public_mask; }
00325
00326 ptrdiff_t
00327 __offset() const
00328 {
00329
00330
00331
00332 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
00333 }
00334 };
00335
00336
00337 class __class_type_info : public std::type_info
00338 {
00339 public:
00340 explicit
00341 __class_type_info (const char *__n) : type_info(__n) { }
00342
00343 virtual
00344 ~__class_type_info ();
00345
00346
00347
00348
00349
00350
00351 enum __sub_kind
00352 {
00353
00354 __unknown = 0,
00355
00356
00357
00358 __not_contained,
00359
00360
00361 __contained_ambig,
00362
00363
00364 __contained_virtual_mask = __base_class_type_info::__virtual_mask,
00365
00366
00367 __contained_public_mask = __base_class_type_info::__public_mask,
00368
00369
00370 __contained_mask = 1 << __base_class_type_info::__hwm_bit,
00371
00372 __contained_private = __contained_mask,
00373 __contained_public = __contained_mask | __contained_public_mask
00374 };
00375
00376 struct __upcast_result;
00377 struct __dyncast_result;
00378
00379 protected:
00380
00381 virtual bool
00382 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
00383
00384 virtual bool
00385 __do_catch(const type_info* __thr_type, void** __thr_obj,
00386 unsigned __outer) const;
00387
00388 public:
00389
00390
00391 virtual bool
00392 __do_upcast(const __class_type_info* __dst, const void* __obj,
00393 __upcast_result& __restrict __result) const;
00394
00395
00396
00397
00398
00399
00400
00401 inline __sub_kind
00402 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00403 const __class_type_info* __src_type,
00404 const void* __src_ptr) const;
00405
00406
00407
00408
00409
00410
00411
00412
00413 virtual bool
00414 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00415 const __class_type_info* __dst_type, const void* __obj_ptr,
00416 const __class_type_info* __src_type, const void* __src_ptr,
00417 __dyncast_result& __result) const;
00418
00419
00420
00421
00422
00423 virtual __sub_kind
00424 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00425 const __class_type_info* __src_type,
00426 const void* __src_ptr) const;
00427 };
00428
00429
00430 class __si_class_type_info : public __class_type_info
00431 {
00432 public:
00433 const __class_type_info* __base_type;
00434
00435 explicit
00436 __si_class_type_info(const char *__n, const __class_type_info *__base)
00437 : __class_type_info(__n), __base_type(__base) { }
00438
00439 virtual
00440 ~__si_class_type_info();
00441
00442 protected:
00443 __si_class_type_info(const __si_class_type_info&);
00444
00445 __si_class_type_info&
00446 operator=(const __si_class_type_info&);
00447
00448
00449 virtual bool
00450 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00451 const __class_type_info* __dst_type, const void* __obj_ptr,
00452 const __class_type_info* __src_type, const void* __src_ptr,
00453 __dyncast_result& __result) const;
00454
00455 virtual __sub_kind
00456 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00457 const __class_type_info* __src_type,
00458 const void* __sub_ptr) const;
00459
00460 virtual bool
00461 __do_upcast(const __class_type_info*__dst, const void*__obj,
00462 __upcast_result& __restrict __result) const;
00463 };
00464
00465
00466 class __vmi_class_type_info : public __class_type_info
00467 {
00468 public:
00469 unsigned int __flags;
00470 unsigned int __base_count;
00471
00472
00473
00474
00475 __base_class_type_info __base_info[1];
00476
00477 explicit
00478 __vmi_class_type_info(const char* __n, int ___flags)
00479 : __class_type_info(__n), __flags(___flags), __base_count(0) { }
00480
00481 virtual
00482 ~__vmi_class_type_info();
00483
00484
00485 enum __flags_masks
00486 {
00487 __non_diamond_repeat_mask = 0x1,
00488 __diamond_shaped_mask = 0x2,
00489 __flags_unknown_mask = 0x10
00490 };
00491
00492 protected:
00493
00494 virtual bool
00495 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00496 const __class_type_info* __dst_type, const void* __obj_ptr,
00497 const __class_type_info* __src_type, const void* __src_ptr,
00498 __dyncast_result& __result) const;
00499
00500 virtual __sub_kind
00501 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00502 const __class_type_info* __src_type,
00503 const void* __src_ptr) const;
00504
00505 virtual bool
00506 __do_upcast(const __class_type_info* __dst, const void* __obj,
00507 __upcast_result& __restrict __result) const;
00508 };
00509
00510
00511
00512
00513
00514
00515
00516
00517 extern "C" void*
00518 __dynamic_cast(const void* __src_ptr,
00519 const __class_type_info* __src_type,
00520 const __class_type_info* __dst_type,
00521 ptrdiff_t __src2dst);
00522
00523
00524
00525
00526 extern "C" std::type_info*
00527 __cxa_current_exception_type();
00528 }
00529
00530
00531 namespace abi = __cxxabiv1;
00532
00533 #endif // __cplusplus
00534
00535 #pragma GCC visibility pop
00536
00537 #endif // __CXXABI_H