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 visibility push(default)
00046
00047 #include <stddef.h>
00048 #include <bits/cxxabi_tweaks.h>
00049 #include <cxxabi-forced.h>
00050
00051 #ifdef __cplusplus
00052 #define _GLIBCXX_NOTHROW throw()
00053 #else
00054 #define _GLIBCXX_NOTHROW __attribute__((nothrow))
00055 #endif
00056
00057 #ifdef __cplusplus
00058 namespace __cxxabiv1
00059 {
00060 extern "C"
00061 {
00062 #endif
00063
00064 typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
00065
00066
00067 void*
00068 __cxa_vec_new(size_t __element_count, size_t __element_size,
00069 size_t __padding_size, __cxa_cdtor_type constructor,
00070 __cxa_cdtor_type destructor);
00071
00072 void*
00073 __cxa_vec_new2(size_t __element_count, size_t __element_size,
00074 size_t __padding_size, __cxa_cdtor_type constructor,
00075 __cxa_cdtor_type destructor, void *(*__alloc) (size_t),
00076 void (*__dealloc) (void*));
00077
00078 void*
00079 __cxa_vec_new3(size_t __element_count, size_t __element_size,
00080 size_t __padding_size, __cxa_cdtor_type constructor,
00081 __cxa_cdtor_type destructor, void *(*__alloc) (size_t),
00082 void (*__dealloc) (void*, size_t));
00083
00084
00085 __cxa_vec_ctor_return_type
00086 __cxa_vec_ctor(void* __array_address, size_t __element_count,
00087 size_t __element_size, __cxa_cdtor_type constructor,
00088 __cxa_cdtor_type destructor);
00089
00090 __cxa_vec_ctor_return_type
00091 __cxa_vec_cctor(void* dest_array, void* src_array, size_t element_count,
00092 size_t element_size,
00093 __cxa_cdtor_return_type (*constructor) (void*, void*),
00094 __cxa_cdtor_type destructor);
00095
00096
00097 void
00098 __cxa_vec_dtor(void* __array_address, size_t __element_count,
00099 size_t __element_size, __cxa_cdtor_type destructor);
00100
00101 void
00102 __cxa_vec_cleanup(void* __array_address, size_t __element_count,
00103 size_t __element_size, __cxa_cdtor_type destructor);
00104
00105
00106 void
00107 __cxa_vec_delete(void* __array_address, size_t __element_size,
00108 size_t __padding_size, __cxa_cdtor_type destructor);
00109
00110 void
00111 __cxa_vec_delete2(void* __array_address, size_t __element_size,
00112 size_t __padding_size, __cxa_cdtor_type destructor,
00113 void (*__dealloc) (void*));
00114
00115 void
00116 __cxa_vec_delete3(void* __array_address, size_t __element_size,
00117 size_t __padding_size, __cxa_cdtor_type destructor,
00118 void (*__dealloc) (void*, size_t));
00119
00120 int
00121 __cxa_guard_acquire(__guard*);
00122
00123 void
00124 __cxa_guard_release(__guard*);
00125
00126 void
00127 __cxa_guard_abort(__guard*);
00128
00129
00130 void
00131 __cxa_pure_virtual(void);
00132
00133
00134 void
00135 __cxa_bad_cast();
00136
00137 void
00138 __cxa_bad_typeid();
00139
00140
00141 int
00142 __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW;
00143
00144 int
00145 __cxa_finalize(void*);
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
00186
00187
00188 char*
00189 __cxa_demangle(const char* __mangled_name, char* __output_buffer,
00190 size_t* __length, int* __status);
00191 #ifdef __cplusplus
00192 }
00193 }
00194 #endif
00195
00196 #ifdef __cplusplus
00197
00198 #include <typeinfo>
00199
00200 namespace __cxxabiv1
00201 {
00202
00203 class __fundamental_type_info : public std::type_info
00204 {
00205 public:
00206 explicit
00207 __fundamental_type_info(const char* __n) : std::type_info(__n) { }
00208
00209 virtual
00210 ~__fundamental_type_info();
00211 };
00212
00213
00214 class __array_type_info : public std::type_info
00215 {
00216 public:
00217 explicit
00218 __array_type_info(const char* __n) : std::type_info(__n) { }
00219
00220 virtual
00221 ~__array_type_info();
00222 };
00223
00224
00225 class __function_type_info : public std::type_info
00226 {
00227 public:
00228 explicit
00229 __function_type_info(const char* __n) : std::type_info(__n) { }
00230
00231 virtual
00232 ~__function_type_info();
00233
00234 protected:
00235
00236 virtual bool
00237 __is_function_p() const;
00238 };
00239
00240
00241 class __enum_type_info : public std::type_info
00242 {
00243 public:
00244 explicit
00245 __enum_type_info(const char* __n) : std::type_info(__n) { }
00246
00247 virtual
00248 ~__enum_type_info();
00249 };
00250
00251
00252 class __pbase_type_info : public std::type_info
00253 {
00254 public:
00255 unsigned int __flags;
00256 const std::type_info* __pointee;
00257
00258 explicit
00259 __pbase_type_info(const char* __n, int __quals,
00260 const std::type_info* __type)
00261 : std::type_info(__n), __flags(__quals), __pointee(__type)
00262 { }
00263
00264 virtual
00265 ~__pbase_type_info();
00266
00267
00268 enum __masks
00269 {
00270 __const_mask = 0x1,
00271 __volatile_mask = 0x2,
00272 __restrict_mask = 0x4,
00273 __incomplete_mask = 0x8,
00274 __incomplete_class_mask = 0x10
00275 };
00276
00277 protected:
00278 __pbase_type_info(const __pbase_type_info&);
00279
00280 __pbase_type_info&
00281 operator=(const __pbase_type_info&);
00282
00283
00284 virtual bool
00285 __do_catch(const std::type_info* __thr_type, void** __thr_obj,
00286 unsigned int __outer) const;
00287
00288 inline virtual bool
00289 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00290 unsigned __outer) const;
00291 };
00292
00293
00294 class __pointer_type_info : public __pbase_type_info
00295 {
00296 public:
00297 explicit
00298 __pointer_type_info(const char* __n, int __quals,
00299 const std::type_info* __type)
00300 : __pbase_type_info (__n, __quals, __type) { }
00301
00302
00303 virtual
00304 ~__pointer_type_info();
00305
00306 protected:
00307
00308 virtual bool
00309 __is_pointer_p() const;
00310
00311 virtual bool
00312 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00313 unsigned __outer) const;
00314 };
00315
00316 class __class_type_info;
00317
00318
00319 class __pointer_to_member_type_info : public __pbase_type_info
00320 {
00321 public:
00322 __class_type_info* __context;
00323
00324 explicit
00325 __pointer_to_member_type_info(const char* __n, int __quals,
00326 const std::type_info* __type,
00327 __class_type_info* __klass)
00328 : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
00329
00330 virtual
00331 ~__pointer_to_member_type_info();
00332
00333 protected:
00334 __pointer_to_member_type_info(const __pointer_to_member_type_info&);
00335
00336 __pointer_to_member_type_info&
00337 operator=(const __pointer_to_member_type_info&);
00338
00339
00340 virtual bool
00341 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
00342 unsigned __outer) const;
00343 };
00344
00345
00346 class __base_class_type_info
00347 {
00348 public:
00349 const __class_type_info* __base_type;
00350 long __offset_flags;
00351
00352 enum __offset_flags_masks
00353 {
00354 __virtual_mask = 0x1,
00355 __public_mask = 0x2,
00356 __hwm_bit = 2,
00357 __offset_shift = 8
00358 };
00359
00360
00361 bool
00362 __is_virtual_p() const
00363 { return __offset_flags & __virtual_mask; }
00364
00365 bool
00366 __is_public_p() const
00367 { return __offset_flags & __public_mask; }
00368
00369 ptrdiff_t
00370 __offset() const
00371 {
00372
00373
00374
00375 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
00376 }
00377 };
00378
00379
00380 class __class_type_info : public std::type_info
00381 {
00382 public:
00383 explicit
00384 __class_type_info (const char *__n) : type_info(__n) { }
00385
00386 virtual
00387 ~__class_type_info ();
00388
00389
00390
00391
00392
00393
00394 enum __sub_kind
00395 {
00396
00397 __unknown = 0,
00398
00399
00400
00401 __not_contained,
00402
00403
00404 __contained_ambig,
00405
00406
00407 __contained_virtual_mask = __base_class_type_info::__virtual_mask,
00408
00409
00410 __contained_public_mask = __base_class_type_info::__public_mask,
00411
00412
00413 __contained_mask = 1 << __base_class_type_info::__hwm_bit,
00414
00415 __contained_private = __contained_mask,
00416 __contained_public = __contained_mask | __contained_public_mask
00417 };
00418
00419 struct __upcast_result;
00420 struct __dyncast_result;
00421
00422 protected:
00423
00424 virtual bool
00425 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
00426
00427 virtual bool
00428 __do_catch(const type_info* __thr_type, void** __thr_obj,
00429 unsigned __outer) const;
00430
00431 public:
00432
00433
00434 virtual bool
00435 __do_upcast(const __class_type_info* __dst, const void* __obj,
00436 __upcast_result& __restrict __result) const;
00437
00438
00439
00440
00441
00442
00443
00444 inline __sub_kind
00445 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00446 const __class_type_info* __src_type,
00447 const void* __src_ptr) const;
00448
00449
00450
00451
00452
00453
00454
00455
00456 virtual bool
00457 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00458 const __class_type_info* __dst_type, const void* __obj_ptr,
00459 const __class_type_info* __src_type, const void* __src_ptr,
00460 __dyncast_result& __result) const;
00461
00462
00463
00464
00465
00466 virtual __sub_kind
00467 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00468 const __class_type_info* __src_type,
00469 const void* __src_ptr) const;
00470 };
00471
00472
00473 class __si_class_type_info : public __class_type_info
00474 {
00475 public:
00476 const __class_type_info* __base_type;
00477
00478 explicit
00479 __si_class_type_info(const char *__n, const __class_type_info *__base)
00480 : __class_type_info(__n), __base_type(__base) { }
00481
00482 virtual
00483 ~__si_class_type_info();
00484
00485 protected:
00486 __si_class_type_info(const __si_class_type_info&);
00487
00488 __si_class_type_info&
00489 operator=(const __si_class_type_info&);
00490
00491
00492 virtual bool
00493 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00494 const __class_type_info* __dst_type, const void* __obj_ptr,
00495 const __class_type_info* __src_type, const void* __src_ptr,
00496 __dyncast_result& __result) const;
00497
00498 virtual __sub_kind
00499 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00500 const __class_type_info* __src_type,
00501 const void* __sub_ptr) const;
00502
00503 virtual bool
00504 __do_upcast(const __class_type_info*__dst, const void*__obj,
00505 __upcast_result& __restrict __result) const;
00506 };
00507
00508
00509 class __vmi_class_type_info : public __class_type_info
00510 {
00511 public:
00512 unsigned int __flags;
00513 unsigned int __base_count;
00514
00515
00516
00517
00518 __base_class_type_info __base_info[1];
00519
00520 explicit
00521 __vmi_class_type_info(const char* __n, int ___flags)
00522 : __class_type_info(__n), __flags(___flags), __base_count(0) { }
00523
00524 virtual
00525 ~__vmi_class_type_info();
00526
00527
00528 enum __flags_masks
00529 {
00530 __non_diamond_repeat_mask = 0x1,
00531 __diamond_shaped_mask = 0x2,
00532 __flags_unknown_mask = 0x10
00533 };
00534
00535 protected:
00536
00537 virtual bool
00538 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
00539 const __class_type_info* __dst_type, const void* __obj_ptr,
00540 const __class_type_info* __src_type, const void* __src_ptr,
00541 __dyncast_result& __result) const;
00542
00543 virtual __sub_kind
00544 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
00545 const __class_type_info* __src_type,
00546 const void* __src_ptr) const;
00547
00548 virtual bool
00549 __do_upcast(const __class_type_info* __dst, const void* __obj,
00550 __upcast_result& __restrict __result) const;
00551 };
00552
00553
00554
00555
00556
00557
00558
00559
00560 extern "C" void*
00561 __dynamic_cast(const void* __src_ptr,
00562 const __class_type_info* __src_type,
00563 const __class_type_info* __dst_type,
00564 ptrdiff_t __src2dst);
00565
00566
00567
00568
00569 extern "C" std::type_info*
00570 __cxa_current_exception_type();
00571
00572
00573
00574 class __foreign_exception
00575 {
00576 virtual ~__foreign_exception() throw();
00577 virtual void __pure_dummy() = 0;
00578 };
00579
00580 }
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602 namespace abi = __cxxabiv1;
00603
00604 #endif // __cplusplus
00605
00606 #pragma GCC visibility pop
00607
00608 #endif // __CXXABI_H