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
00042 #ifndef _CXXABI_H
00043 #define _CXXABI_H 1
00044
00045 #pragma GCC system_header
00046
00047 #pragma GCC visibility push(default)
00048
00049 #include <stddef.h>
00050 #include <bits/c++config.h>
00051 #include <bits/cxxabi_tweaks.h>
00052 #include <bits/cxxabi_forced.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,
00089 size_t __element_count, 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, size_t __s,
00100 __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW;
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*) _GLIBCXX_NOTHROW;
00122
00123 void
00124 __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW;
00125
00126
00127 void
00128 __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
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*) _GLIBCXX_NOTHROW;
00140
00141 int
00142 __cxa_finalize(void*);
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185 char*
00186 __cxa_demangle(const char* __mangled_name, char* __output_buffer,
00187 size_t* __length, int* __status);
00188 #ifdef __cplusplus
00189 }
00190 }
00191 #endif
00192
00193 #ifdef __cplusplus
00194
00195 #include <typeinfo>
00196
00197 namespace __cxxabiv1
00198 {
00199
00200 class __fundamental_type_info : public std::type_info
00201 {
00202 public:
00203 explicit
00204 __fundamental_type_info(const char* __n) : std::type_info(__n) { }
00205
00206 virtual
00207 ~__fundamental_type_info();
00208 };
00209
00210
00211 class __array_type_info : public std::type_info
00212 {
00213 public:
00214 explicit
00215 __array_type_info(const char* __n) : std::type_info(__n) { }
00216
00217 virtual
00218 ~__array_type_info();
00219 };
00220
00221
00222 class __function_type_info : public std::type_info
00223 {
00224 public:
00225 explicit
00226 __function_type_info(const char* __n) : std::type_info(__n) { }
00227
00228 virtual
00229 ~__function_type_info();
00230
00231 protected:
00232
00233 virtual bool
00234 __is_function_p() const;
00235 };
00236
00237
00238 class __enum_type_info : public std::type_info
00239 {
00240 public:
00241 explicit
00242 __enum_type_info(const char* __n) : std::type_info(__n) { }
00243
00244 virtual
00245 ~__enum_type_info();
00246 };
00247
00248
00249 class __pbase_type_info : public std::type_info
00250 {
00251 public:
00252 unsigned int __flags;
00253 const std::type_info* __pointee;
00254
00255 explicit
00256 __pbase_type_info(const char* __n, int __quals,
00257 const std::type_info* __type)
00258 : std::type_info(__n), __flags(__quals), __pointee(__type)
00259 { }
00260
00261 virtual
00262 ~__pbase_type_info();
00263
00264
00265 enum __masks
00266 {
00267 __const_mask = 0x1,
00268 __volatile_mask = 0x2,
00269 __restrict_mask = 0x4,
00270 __incomplete_mask = 0x8,
00271 __incomplete_class_mask = 0x10
00272 };
00273
00274 protected:
00275 __pbase_type_info(const __pbase_type_info&);
00276
00277 __pbase_type_info&
00278 operator=(const __pbase_type_info&);
00279
00280
00281 virtual bool
00282 __do_catch(const std::type_info* __thr_type, void** __thr_obj,
00283 unsigned int __outer) const;
00284
00285 inline virtual bool
00286 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00287 unsigned __outer) const;
00288 };
00289
00290
00291 class __pointer_type_info : public __pbase_type_info
00292 {
00293 public:
00294 explicit
00295 __pointer_type_info(const char* __n, int __quals,
00296 const std::type_info* __type)
00297 : __pbase_type_info (__n, __quals, __type) { }
00298
00299
00300 virtual
00301 ~__pointer_type_info();
00302
00303 protected:
00304
00305 virtual bool
00306 __is_pointer_p() const;
00307
00308 virtual bool
00309 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00310 unsigned __outer) const;
00311 };
00312
00313 class __class_type_info;
00314
00315
00316 class __pointer_to_member_type_info : public __pbase_type_info
00317 {
00318 public:
00319 __class_type_info* __context;
00320
00321 explicit
00322 __pointer_to_member_type_info(const char* __n, int __quals,
00323 const std::type_info* __type,
00324 __class_type_info* __klass)
00325 : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
00326
00327 virtual
00328 ~__pointer_to_member_type_info();
00329
00330 protected:
00331 __pointer_to_member_type_info(const __pointer_to_member_type_info&);
00332
00333 __pointer_to_member_type_info&
00334 operator=(const __pointer_to_member_type_info&);
00335
00336
00337 virtual bool
00338 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00339 unsigned __outer) const;
00340 };
00341
00342
00343 class __base_class_type_info
00344 {
00345 public:
00346 const __class_type_info* __base_type;
00347 long __offset_flags;
00348
00349 enum __offset_flags_masks
00350 {
00351 __virtual_mask = 0x1,
00352 __public_mask = 0x2,
00353 __hwm_bit = 2,
00354 __offset_shift = 8
00355 };
00356
00357
00358 bool
00359 __is_virtual_p() const
00360 { return __offset_flags & __virtual_mask; }
00361
00362 bool
00363 __is_public_p() const
00364 { return __offset_flags & __public_mask; }
00365
00366 ptrdiff_t
00367 __offset() const
00368 {
00369
00370
00371
00372 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
00373 }
00374 };
00375
00376
00377 class __class_type_info : public std::type_info
00378 {
00379 public:
00380 explicit
00381 __class_type_info (const char *__n) : type_info(__n) { }
00382
00383 virtual
00384 ~__class_type_info ();
00385
00386
00387
00388
00389
00390
00391 enum __sub_kind
00392 {
00393
00394 __unknown = 0,
00395
00396
00397
00398 __not_contained,
00399
00400
00401 __contained_ambig,
00402
00403
00404 __contained_virtual_mask = __base_class_type_info::__virtual_mask,
00405
00406
00407 __contained_public_mask = __base_class_type_info::__public_mask,
00408
00409
00410 __contained_mask = 1 << __base_class_type_info::__hwm_bit,
00411
00412 __contained_private = __contained_mask,
00413 __contained_public = __contained_mask | __contained_public_mask
00414 };
00415
00416 struct __upcast_result;
00417 struct __dyncast_result;
00418
00419 protected:
00420
00421 virtual bool
00422 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
00423
00424 virtual bool
00425 __do_catch(const type_info* __thr_type, void** __thr_obj,
00426 unsigned __outer) const;
00427
00428 public:
00429
00430
00431 virtual bool
00432 __do_upcast(const __class_type_info* __dst, const void* __obj,
00433 __upcast_result& __restrict __result) const;
00434
00435
00436
00437
00438
00439
00440
00441 inline __sub_kind
00442 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00443 const __class_type_info* __src_type,
00444 const void* __src_ptr) const;
00445
00446
00447
00448
00449
00450
00451
00452
00453 virtual bool
00454 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00455 const __class_type_info* __dst_type, const void* __obj_ptr,
00456 const __class_type_info* __src_type, const void* __src_ptr,
00457 __dyncast_result& __result) const;
00458
00459
00460
00461
00462
00463 virtual __sub_kind
00464 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00465 const __class_type_info* __src_type,
00466 const void* __src_ptr) const;
00467 };
00468
00469
00470 class __si_class_type_info : public __class_type_info
00471 {
00472 public:
00473 const __class_type_info* __base_type;
00474
00475 explicit
00476 __si_class_type_info(const char *__n, const __class_type_info *__base)
00477 : __class_type_info(__n), __base_type(__base) { }
00478
00479 virtual
00480 ~__si_class_type_info();
00481
00482 protected:
00483 __si_class_type_info(const __si_class_type_info&);
00484
00485 __si_class_type_info&
00486 operator=(const __si_class_type_info&);
00487
00488
00489 virtual bool
00490 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00491 const __class_type_info* __dst_type, const void* __obj_ptr,
00492 const __class_type_info* __src_type, const void* __src_ptr,
00493 __dyncast_result& __result) const;
00494
00495 virtual __sub_kind
00496 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00497 const __class_type_info* __src_type,
00498 const void* __sub_ptr) const;
00499
00500 virtual bool
00501 __do_upcast(const __class_type_info*__dst, const void*__obj,
00502 __upcast_result& __restrict __result) const;
00503 };
00504
00505
00506 class __vmi_class_type_info : public __class_type_info
00507 {
00508 public:
00509 unsigned int __flags;
00510 unsigned int __base_count;
00511
00512
00513
00514
00515 __base_class_type_info __base_info[1];
00516
00517 explicit
00518 __vmi_class_type_info(const char* __n, int ___flags)
00519 : __class_type_info(__n), __flags(___flags), __base_count(0) { }
00520
00521 virtual
00522 ~__vmi_class_type_info();
00523
00524
00525 enum __flags_masks
00526 {
00527 __non_diamond_repeat_mask = 0x1,
00528 __diamond_shaped_mask = 0x2,
00529 __flags_unknown_mask = 0x10
00530 };
00531
00532 protected:
00533
00534 virtual bool
00535 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00536 const __class_type_info* __dst_type, const void* __obj_ptr,
00537 const __class_type_info* __src_type, const void* __src_ptr,
00538 __dyncast_result& __result) const;
00539
00540 virtual __sub_kind
00541 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00542 const __class_type_info* __src_type,
00543 const void* __src_ptr) const;
00544
00545 virtual bool
00546 __do_upcast(const __class_type_info* __dst, const void* __obj,
00547 __upcast_result& __restrict __result) const;
00548 };
00549
00550
00551
00552
00553
00554
00555
00556
00557 extern "C" void*
00558 __dynamic_cast(const void* __src_ptr,
00559 const __class_type_info* __src_type,
00560 const __class_type_info* __dst_type,
00561 ptrdiff_t __src2dst);
00562
00563
00564
00565
00566 extern "C" std::type_info*
00567 __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__));
00568
00569
00570
00571 class __foreign_exception
00572 {
00573 virtual ~__foreign_exception() _GLIBCXX_NOTHROW;
00574 virtual void __pure_dummy() = 0;
00575 };
00576
00577 }
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599 namespace abi = __cxxabiv1;
00600
00601 namespace __gnu_cxx
00602 {
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615 class recursive_init_error: public std::exception
00616 {
00617 public:
00618 recursive_init_error() throw() { }
00619 virtual ~recursive_init_error() throw ();
00620 };
00621 }
00622 #endif // __cplusplus
00623
00624 #pragma GCC visibility pop
00625
00626 #endif // __CXXABI_H