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