|
111
|
1 // ABI Support -*- C++ -*-
|
|
|
2
|
|
145
|
3 // Copyright (C) 2000-2020 Free Software Foundation, Inc.
|
|
111
|
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 3, 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 // Under Section 7 of GPL version 3, you are granted additional
|
|
|
18 // permissions described in the GCC Runtime Library Exception, version
|
|
|
19 // 3.1, as published by the Free Software Foundation.
|
|
|
20
|
|
|
21 // You should have received a copy of the GNU General Public License and
|
|
|
22 // a copy of the GCC Runtime Library Exception along with this program;
|
|
|
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
24 // <http://www.gnu.org/licenses/>.
|
|
|
25
|
|
|
26 // Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
|
|
|
27
|
|
|
28 /* This file declares the new abi entry points into the runtime. It is not
|
|
|
29 normally necessary for user programs to include this header, or use the
|
|
|
30 entry points directly. However, this header is available should that be
|
|
|
31 needed.
|
|
|
32
|
|
|
33 Some of the entry points are intended for both C and C++, thus this header
|
|
|
34 is includable from both C and C++. Though the C++ specific parts are not
|
|
|
35 available in C, naturally enough. */
|
|
|
36
|
|
|
37 /** @file cxxabi.h
|
|
|
38 * The header provides an interface to the C++ ABI.
|
|
|
39 */
|
|
|
40
|
|
|
41 #ifndef _CXXABI_H
|
|
|
42 #define _CXXABI_H 1
|
|
|
43
|
|
|
44 #pragma GCC system_header
|
|
|
45
|
|
|
46 #pragma GCC visibility push(default)
|
|
|
47
|
|
|
48 #include <stddef.h>
|
|
|
49 #include <bits/c++config.h>
|
|
|
50 #include <bits/cxxabi_tweaks.h>
|
|
|
51 #include <bits/cxxabi_forced.h>
|
|
|
52 #include <bits/cxxabi_init_exception.h>
|
|
|
53
|
|
|
54 #ifdef __cplusplus
|
|
|
55 namespace __cxxabiv1
|
|
|
56 {
|
|
|
57 extern "C"
|
|
|
58 {
|
|
|
59 #endif
|
|
|
60
|
|
|
61 typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
|
|
|
62
|
|
|
63 // Allocate array.
|
|
|
64 void*
|
|
|
65 __cxa_vec_new(size_t __element_count, size_t __element_size,
|
|
|
66 size_t __padding_size, __cxa_cdtor_type __constructor,
|
|
|
67 __cxa_cdtor_type __destructor);
|
|
|
68
|
|
|
69 void*
|
|
|
70 __cxa_vec_new2(size_t __element_count, size_t __element_size,
|
|
|
71 size_t __padding_size, __cxa_cdtor_type __constructor,
|
|
|
72 __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
|
|
|
73 void (*__dealloc) (void*));
|
|
|
74
|
|
|
75 void*
|
|
|
76 __cxa_vec_new3(size_t __element_count, size_t __element_size,
|
|
|
77 size_t __padding_size, __cxa_cdtor_type __constructor,
|
|
|
78 __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
|
|
|
79 void (*__dealloc) (void*, size_t));
|
|
|
80
|
|
|
81 // Construct array.
|
|
|
82 __cxa_vec_ctor_return_type
|
|
|
83 __cxa_vec_ctor(void* __array_address, size_t __element_count,
|
|
|
84 size_t __element_size, __cxa_cdtor_type __constructor,
|
|
|
85 __cxa_cdtor_type __destructor);
|
|
|
86
|
|
|
87 __cxa_vec_ctor_return_type
|
|
|
88 __cxa_vec_cctor(void* __dest_array, void* __src_array,
|
|
|
89 size_t __element_count, size_t __element_size,
|
|
|
90 __cxa_cdtor_return_type (*__constructor) (void*, void*),
|
|
|
91 __cxa_cdtor_type __destructor);
|
|
|
92
|
|
|
93 // Destruct array.
|
|
|
94 void
|
|
|
95 __cxa_vec_dtor(void* __array_address, size_t __element_count,
|
|
|
96 size_t __element_size, __cxa_cdtor_type __destructor);
|
|
|
97
|
|
|
98 void
|
|
|
99 __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
|
|
|
100 __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW;
|
|
|
101
|
|
|
102 // Destruct and release array.
|
|
|
103 void
|
|
|
104 __cxa_vec_delete(void* __array_address, size_t __element_size,
|
|
|
105 size_t __padding_size, __cxa_cdtor_type __destructor);
|
|
|
106
|
|
|
107 void
|
|
|
108 __cxa_vec_delete2(void* __array_address, size_t __element_size,
|
|
|
109 size_t __padding_size, __cxa_cdtor_type __destructor,
|
|
|
110 void (*__dealloc) (void*));
|
|
|
111
|
|
|
112 void
|
|
|
113 __cxa_vec_delete3(void* __array_address, size_t __element_size,
|
|
|
114 size_t __padding_size, __cxa_cdtor_type __destructor,
|
|
|
115 void (*__dealloc) (void*, size_t));
|
|
|
116
|
|
|
117 int
|
|
|
118 __cxa_guard_acquire(__guard*);
|
|
|
119
|
|
|
120 void
|
|
|
121 __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW;
|
|
|
122
|
|
|
123 void
|
|
|
124 __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW;
|
|
|
125
|
|
|
126 // DSO destruction.
|
|
|
127 int
|
|
|
128 __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW;
|
|
|
129
|
|
|
130 int
|
|
|
131 __cxa_finalize(void*);
|
|
|
132
|
|
|
133 // TLS destruction.
|
|
|
134 int
|
|
|
135 __cxa_thread_atexit(void (*)(void*), void*, void *) _GLIBCXX_NOTHROW;
|
|
|
136
|
|
|
137 // Pure virtual functions.
|
|
|
138 void
|
|
|
139 __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
|
|
|
140
|
|
|
141 void
|
|
|
142 __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
|
|
|
143
|
|
|
144 // Exception handling auxiliary.
|
|
|
145 void
|
|
|
146 __cxa_bad_cast() __attribute__((__noreturn__));
|
|
|
147
|
|
|
148 void
|
|
|
149 __cxa_bad_typeid() __attribute__((__noreturn__));
|
|
|
150
|
|
|
151 void
|
|
|
152 __cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
|
|
|
153
|
|
|
154 /**
|
|
|
155 * @brief Demangling routine.
|
|
|
156 * ABI-mandated entry point in the C++ runtime library for demangling.
|
|
|
157 *
|
|
|
158 * @param __mangled_name A NUL-terminated character string
|
|
|
159 * containing the name to be demangled.
|
|
|
160 *
|
|
|
161 * @param __output_buffer A region of memory, allocated with
|
|
|
162 * malloc, of @a *__length bytes, into which the demangled name is
|
|
|
163 * stored. If @a __output_buffer is not long enough, it is
|
|
|
164 * expanded using realloc. @a __output_buffer may instead be NULL;
|
|
|
165 * in that case, the demangled name is placed in a region of memory
|
|
|
166 * allocated with malloc.
|
|
|
167 *
|
|
131
|
168 * @param __length If @a __length is non-null, the length of the
|
|
111
|
169 * buffer containing the demangled name is placed in @a *__length.
|
|
|
170 *
|
|
131
|
171 * @param __status If @a __status is non-null, @a *__status is set to
|
|
|
172 * one of the following values:
|
|
111
|
173 * 0: The demangling operation succeeded.
|
|
|
174 * -1: A memory allocation failure occurred.
|
|
|
175 * -2: @a mangled_name is not a valid name under the C++ ABI mangling rules.
|
|
|
176 * -3: One of the arguments is invalid.
|
|
|
177 *
|
|
|
178 * @return A pointer to the start of the NUL-terminated demangled
|
|
|
179 * name, or NULL if the demangling fails. The caller is
|
|
|
180 * responsible for deallocating this memory using @c free.
|
|
|
181 *
|
|
|
182 * The demangling is performed using the C++ ABI mangling rules,
|
|
|
183 * with GNU extensions. For example, this function is used in
|
|
|
184 * __gnu_cxx::__verbose_terminate_handler.
|
|
|
185 *
|
|
|
186 * See https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html
|
|
|
187 * for other examples of use.
|
|
|
188 *
|
|
|
189 * @note The same demangling functionality is available via
|
|
|
190 * libiberty (@c <libiberty/demangle.h> and @c libiberty.a) in GCC
|
|
|
191 * 3.1 and later, but that requires explicit installation (@c
|
|
|
192 * --enable-install-libiberty) and uses a different API, although
|
|
|
193 * the ABI is unchanged.
|
|
|
194 */
|
|
|
195 char*
|
|
|
196 __cxa_demangle(const char* __mangled_name, char* __output_buffer,
|
|
|
197 size_t* __length, int* __status);
|
|
|
198
|
|
|
199 #ifdef __cplusplus
|
|
|
200 }
|
|
|
201 } // namespace __cxxabiv1
|
|
|
202 #endif
|
|
|
203
|
|
|
204 #ifdef __cplusplus
|
|
|
205
|
|
|
206 #include <typeinfo>
|
|
|
207
|
|
|
208 namespace __cxxabiv1
|
|
|
209 {
|
|
|
210 // Type information for int, float etc.
|
|
|
211 class __fundamental_type_info : public std::type_info
|
|
|
212 {
|
|
|
213 public:
|
|
|
214 explicit
|
|
|
215 __fundamental_type_info(const char* __n) : std::type_info(__n) { }
|
|
|
216
|
|
|
217 virtual
|
|
|
218 ~__fundamental_type_info();
|
|
|
219 };
|
|
|
220
|
|
|
221 // Type information for array objects.
|
|
|
222 class __array_type_info : public std::type_info
|
|
|
223 {
|
|
|
224 public:
|
|
|
225 explicit
|
|
|
226 __array_type_info(const char* __n) : std::type_info(__n) { }
|
|
|
227
|
|
|
228 virtual
|
|
|
229 ~__array_type_info();
|
|
|
230 };
|
|
|
231
|
|
|
232 // Type information for functions (both member and non-member).
|
|
|
233 class __function_type_info : public std::type_info
|
|
|
234 {
|
|
|
235 public:
|
|
|
236 explicit
|
|
|
237 __function_type_info(const char* __n) : std::type_info(__n) { }
|
|
|
238
|
|
|
239 virtual
|
|
|
240 ~__function_type_info();
|
|
|
241
|
|
|
242 protected:
|
|
|
243 // Implementation defined member function.
|
|
|
244 virtual bool
|
|
|
245 __is_function_p() const;
|
|
|
246 };
|
|
|
247
|
|
|
248 // Type information for enumerations.
|
|
|
249 class __enum_type_info : public std::type_info
|
|
|
250 {
|
|
|
251 public:
|
|
|
252 explicit
|
|
|
253 __enum_type_info(const char* __n) : std::type_info(__n) { }
|
|
|
254
|
|
|
255 virtual
|
|
|
256 ~__enum_type_info();
|
|
|
257 };
|
|
|
258
|
|
|
259 // Common type information for simple pointers and pointers to member.
|
|
|
260 class __pbase_type_info : public std::type_info
|
|
|
261 {
|
|
|
262 public:
|
|
|
263 unsigned int __flags; // Qualification of the target object.
|
|
|
264 const std::type_info* __pointee; // Type of pointed to object.
|
|
|
265
|
|
|
266 explicit
|
|
|
267 __pbase_type_info(const char* __n, int __quals,
|
|
|
268 const std::type_info* __type)
|
|
|
269 : std::type_info(__n), __flags(__quals), __pointee(__type)
|
|
|
270 { }
|
|
|
271
|
|
|
272 virtual
|
|
|
273 ~__pbase_type_info();
|
|
|
274
|
|
|
275 // Implementation defined type.
|
|
|
276 enum __masks
|
|
|
277 {
|
|
|
278 __const_mask = 0x1,
|
|
|
279 __volatile_mask = 0x2,
|
|
|
280 __restrict_mask = 0x4,
|
|
|
281 __incomplete_mask = 0x8,
|
|
|
282 __incomplete_class_mask = 0x10,
|
|
|
283 __transaction_safe_mask = 0x20,
|
|
|
284 __noexcept_mask = 0x40
|
|
|
285 };
|
|
|
286
|
|
|
287 protected:
|
|
|
288 __pbase_type_info(const __pbase_type_info&);
|
|
|
289
|
|
|
290 __pbase_type_info&
|
|
|
291 operator=(const __pbase_type_info&);
|
|
|
292
|
|
|
293 // Implementation defined member functions.
|
|
|
294 virtual bool
|
|
|
295 __do_catch(const std::type_info* __thr_type, void** __thr_obj,
|
|
|
296 unsigned int __outer) const;
|
|
|
297
|
|
|
298 inline virtual bool
|
|
|
299 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
|
|
|
300 unsigned __outer) const;
|
|
|
301 };
|
|
|
302
|
|
|
303 inline bool __pbase_type_info::
|
|
|
304 __pointer_catch (const __pbase_type_info *thrown_type,
|
|
|
305 void **thr_obj,
|
|
|
306 unsigned outer) const
|
|
|
307 {
|
|
|
308 return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
|
|
|
309 }
|
|
|
310
|
|
|
311 // Type information for simple pointers.
|
|
|
312 class __pointer_type_info : public __pbase_type_info
|
|
|
313 {
|
|
|
314 public:
|
|
|
315 explicit
|
|
|
316 __pointer_type_info(const char* __n, int __quals,
|
|
|
317 const std::type_info* __type)
|
|
|
318 : __pbase_type_info (__n, __quals, __type) { }
|
|
|
319
|
|
|
320
|
|
|
321 virtual
|
|
|
322 ~__pointer_type_info();
|
|
|
323
|
|
|
324 protected:
|
|
|
325 // Implementation defined member functions.
|
|
|
326 virtual bool
|
|
|
327 __is_pointer_p() const;
|
|
|
328
|
|
|
329 virtual bool
|
|
|
330 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
|
|
|
331 unsigned __outer) const;
|
|
|
332 };
|
|
|
333
|
|
|
334 class __class_type_info;
|
|
|
335
|
|
|
336 // Type information for a pointer to member variable.
|
|
|
337 class __pointer_to_member_type_info : public __pbase_type_info
|
|
|
338 {
|
|
|
339 public:
|
|
|
340 __class_type_info* __context; // Class of the member.
|
|
|
341
|
|
|
342 explicit
|
|
|
343 __pointer_to_member_type_info(const char* __n, int __quals,
|
|
|
344 const std::type_info* __type,
|
|
|
345 __class_type_info* __klass)
|
|
|
346 : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
|
|
|
347
|
|
|
348 virtual
|
|
|
349 ~__pointer_to_member_type_info();
|
|
|
350
|
|
|
351 protected:
|
|
|
352 __pointer_to_member_type_info(const __pointer_to_member_type_info&);
|
|
|
353
|
|
|
354 __pointer_to_member_type_info&
|
|
|
355 operator=(const __pointer_to_member_type_info&);
|
|
|
356
|
|
|
357 // Implementation defined member function.
|
|
|
358 virtual bool
|
|
|
359 __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
|
|
|
360 unsigned __outer) const;
|
|
|
361 };
|
|
|
362
|
|
|
363 // Helper class for __vmi_class_type.
|
|
|
364 class __base_class_type_info
|
|
|
365 {
|
|
|
366 public:
|
|
|
367 const __class_type_info* __base_type; // Base class type.
|
|
|
368 #ifdef _GLIBCXX_LLP64
|
|
|
369 long long __offset_flags; // Offset and info.
|
|
|
370 #else
|
|
|
371 long __offset_flags; // Offset and info.
|
|
|
372 #endif
|
|
|
373
|
|
|
374 enum __offset_flags_masks
|
|
|
375 {
|
|
|
376 __virtual_mask = 0x1,
|
|
|
377 __public_mask = 0x2,
|
|
|
378 __hwm_bit = 2,
|
|
|
379 __offset_shift = 8 // Bits to shift offset.
|
|
|
380 };
|
|
|
381
|
|
|
382 // Implementation defined member functions.
|
|
|
383 bool
|
|
|
384 __is_virtual_p() const
|
|
|
385 { return __offset_flags & __virtual_mask; }
|
|
|
386
|
|
|
387 bool
|
|
|
388 __is_public_p() const
|
|
|
389 { return __offset_flags & __public_mask; }
|
|
|
390
|
|
|
391 ptrdiff_t
|
|
|
392 __offset() const
|
|
|
393 {
|
|
|
394 // This shift, being of a signed type, is implementation
|
|
|
395 // defined. GCC implements such shifts as arithmetic, which is
|
|
|
396 // what we want.
|
|
|
397 return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
|
|
|
398 }
|
|
|
399 };
|
|
|
400
|
|
|
401 // Type information for a class.
|
|
|
402 class __class_type_info : public std::type_info
|
|
|
403 {
|
|
|
404 public:
|
|
|
405 explicit
|
|
|
406 __class_type_info (const char *__n) : type_info(__n) { }
|
|
|
407
|
|
|
408 virtual
|
|
|
409 ~__class_type_info ();
|
|
|
410
|
|
|
411 // Implementation defined types.
|
|
|
412 // The type sub_kind tells us about how a base object is contained
|
|
|
413 // within a derived object. We often do this lazily, hence the
|
|
|
414 // UNKNOWN value. At other times we may use NOT_CONTAINED to mean
|
|
|
415 // not publicly contained.
|
|
|
416 enum __sub_kind
|
|
|
417 {
|
|
|
418 // We have no idea.
|
|
|
419 __unknown = 0,
|
|
|
420
|
|
|
421 // Not contained within us (in some circumstances this might
|
|
|
422 // mean not contained publicly)
|
|
|
423 __not_contained,
|
|
|
424
|
|
|
425 // Contained ambiguously.
|
|
|
426 __contained_ambig,
|
|
|
427
|
|
|
428 // Via a virtual path.
|
|
|
429 __contained_virtual_mask = __base_class_type_info::__virtual_mask,
|
|
|
430
|
|
|
431 // Via a public path.
|
|
|
432 __contained_public_mask = __base_class_type_info::__public_mask,
|
|
|
433
|
|
|
434 // Contained within us.
|
|
|
435 __contained_mask = 1 << __base_class_type_info::__hwm_bit,
|
|
|
436
|
|
|
437 __contained_private = __contained_mask,
|
|
|
438 __contained_public = __contained_mask | __contained_public_mask
|
|
|
439 };
|
|
|
440
|
|
|
441 struct __upcast_result;
|
|
|
442 struct __dyncast_result;
|
|
|
443
|
|
|
444 protected:
|
|
|
445 // Implementation defined member functions.
|
|
|
446 virtual bool
|
|
|
447 __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
|
|
|
448
|
|
|
449 virtual bool
|
|
|
450 __do_catch(const type_info* __thr_type, void** __thr_obj,
|
|
|
451 unsigned __outer) const;
|
|
|
452
|
|
|
453 public:
|
|
|
454 // Helper for upcast. See if DST is us, or one of our bases.
|
|
|
455 // Return false if not found, true if found.
|
|
|
456 virtual bool
|
|
|
457 __do_upcast(const __class_type_info* __dst, const void* __obj,
|
|
|
458 __upcast_result& __restrict __result) const;
|
|
|
459
|
|
|
460 // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly
|
|
|
461 // within OBJ_PTR. OBJ_PTR points to a base object of our type,
|
|
|
462 // which is the destination type. SRC2DST indicates how SRC
|
|
|
463 // objects might be contained within this type. If SRC_PTR is one
|
|
|
464 // of our SRC_TYPE bases, indicate the virtuality. Returns
|
|
|
465 // not_contained for non containment or private containment.
|
|
|
466 inline __sub_kind
|
|
|
467 __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
|
|
|
468 const __class_type_info* __src_type,
|
|
|
469 const void* __src_ptr) const;
|
|
|
470
|
|
|
471 // Helper for dynamic cast. ACCESS_PATH gives the access from the
|
|
|
472 // most derived object to this base. DST_TYPE indicates the
|
|
|
473 // desired type we want. OBJ_PTR points to a base of our type
|
|
|
474 // within the complete object. SRC_TYPE indicates the static type
|
|
|
475 // started from and SRC_PTR points to that base within the most
|
|
|
476 // derived object. Fill in RESULT with what we find. Return true
|
|
|
477 // if we have located an ambiguous match.
|
|
|
478 virtual bool
|
|
|
479 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
|
|
|
480 const __class_type_info* __dst_type, const void* __obj_ptr,
|
|
|
481 const __class_type_info* __src_type, const void* __src_ptr,
|
|
|
482 __dyncast_result& __result) const;
|
|
|
483
|
|
|
484 // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE
|
|
|
485 // bases are inherited by the type started from -- which is not
|
|
|
486 // necessarily the current type. The current type will be a base
|
|
|
487 // of the destination type. OBJ_PTR points to the current base.
|
|
|
488 virtual __sub_kind
|
|
|
489 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
|
|
|
490 const __class_type_info* __src_type,
|
|
|
491 const void* __src_ptr) const;
|
|
|
492 };
|
|
|
493
|
|
|
494 // Type information for a class with a single non-virtual base.
|
|
|
495 class __si_class_type_info : public __class_type_info
|
|
|
496 {
|
|
|
497 public:
|
|
|
498 const __class_type_info* __base_type;
|
|
|
499
|
|
|
500 explicit
|
|
|
501 __si_class_type_info(const char *__n, const __class_type_info *__base)
|
|
|
502 : __class_type_info(__n), __base_type(__base) { }
|
|
|
503
|
|
|
504 virtual
|
|
|
505 ~__si_class_type_info();
|
|
|
506
|
|
|
507 protected:
|
|
|
508 __si_class_type_info(const __si_class_type_info&);
|
|
|
509
|
|
|
510 __si_class_type_info&
|
|
|
511 operator=(const __si_class_type_info&);
|
|
|
512
|
|
|
513 // Implementation defined member functions.
|
|
|
514 virtual bool
|
|
|
515 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
|
|
|
516 const __class_type_info* __dst_type, const void* __obj_ptr,
|
|
|
517 const __class_type_info* __src_type, const void* __src_ptr,
|
|
|
518 __dyncast_result& __result) const;
|
|
|
519
|
|
|
520 virtual __sub_kind
|
|
|
521 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
|
|
|
522 const __class_type_info* __src_type,
|
|
|
523 const void* __sub_ptr) const;
|
|
|
524
|
|
|
525 virtual bool
|
|
|
526 __do_upcast(const __class_type_info*__dst, const void*__obj,
|
|
|
527 __upcast_result& __restrict __result) const;
|
|
|
528 };
|
|
|
529
|
|
|
530 // Type information for a class with multiple and/or virtual bases.
|
|
|
531 class __vmi_class_type_info : public __class_type_info
|
|
|
532 {
|
|
|
533 public:
|
|
|
534 unsigned int __flags; // Details about the class hierarchy.
|
|
|
535 unsigned int __base_count; // Number of direct bases.
|
|
|
536
|
|
|
537 // The array of bases uses the trailing array struct hack so this
|
|
|
538 // class is not constructable with a normal constructor. It is
|
|
|
539 // internally generated by the compiler.
|
|
|
540 __base_class_type_info __base_info[1]; // Array of bases.
|
|
|
541
|
|
|
542 explicit
|
|
|
543 __vmi_class_type_info(const char* __n, int ___flags)
|
|
|
544 : __class_type_info(__n), __flags(___flags), __base_count(0) { }
|
|
|
545
|
|
|
546 virtual
|
|
|
547 ~__vmi_class_type_info();
|
|
|
548
|
|
|
549 // Implementation defined types.
|
|
|
550 enum __flags_masks
|
|
|
551 {
|
|
|
552 __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base.
|
|
|
553 __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance.
|
|
|
554 __flags_unknown_mask = 0x10
|
|
|
555 };
|
|
|
556
|
|
|
557 protected:
|
|
|
558 // Implementation defined member functions.
|
|
|
559 virtual bool
|
|
|
560 __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
|
|
|
561 const __class_type_info* __dst_type, const void* __obj_ptr,
|
|
|
562 const __class_type_info* __src_type, const void* __src_ptr,
|
|
|
563 __dyncast_result& __result) const;
|
|
|
564
|
|
|
565 virtual __sub_kind
|
|
|
566 __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
|
|
|
567 const __class_type_info* __src_type,
|
|
|
568 const void* __src_ptr) const;
|
|
|
569
|
|
|
570 virtual bool
|
|
|
571 __do_upcast(const __class_type_info* __dst, const void* __obj,
|
|
|
572 __upcast_result& __restrict __result) const;
|
|
|
573 };
|
|
|
574
|
|
|
575 // Exception handling forward declarations.
|
|
|
576 struct __cxa_exception;
|
|
|
577 struct __cxa_refcounted_exception;
|
|
|
578 struct __cxa_dependent_exception;
|
|
|
579 struct __cxa_eh_globals;
|
|
|
580
|
|
|
581 extern "C"
|
|
|
582 {
|
|
|
583 // Dynamic cast runtime.
|
|
|
584
|
|
|
585 // src2dst has the following possible values
|
|
|
586 // >-1: src_type is a unique public non-virtual base of dst_type
|
|
|
587 // dst_ptr + src2dst == src_ptr
|
|
|
588 // -1: unspecified relationship
|
|
|
589 // -2: src_type is not a public base of dst_type
|
|
|
590 // -3: src_type is a multiple public non-virtual base of dst_type
|
|
|
591 void*
|
|
|
592 __dynamic_cast(const void* __src_ptr, // Starting object.
|
|
|
593 const __class_type_info* __src_type, // Static type of object.
|
|
|
594 const __class_type_info* __dst_type, // Desired target type.
|
|
|
595 ptrdiff_t __src2dst); // How src and dst are related.
|
|
|
596
|
|
|
597
|
|
|
598 // Exception handling runtime.
|
|
|
599
|
|
|
600 // The __cxa_eh_globals for the current thread can be obtained by using
|
|
|
601 // either of the following functions. The "fast" version assumes at least
|
|
|
602 // one prior call of __cxa_get_globals has been made from the current
|
|
|
603 // thread, so no initialization is necessary.
|
|
|
604 __cxa_eh_globals*
|
|
|
605 __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__));
|
|
|
606
|
|
|
607 __cxa_eh_globals*
|
|
|
608 __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__));
|
|
|
609
|
|
|
610 // Free the space allocated for the primary exception.
|
|
|
611 void
|
|
|
612 __cxa_free_exception(void*) _GLIBCXX_NOTHROW;
|
|
|
613
|
|
|
614 // Throw the exception.
|
|
|
615 void
|
|
|
616 __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *))
|
|
|
617 __attribute__((__noreturn__));
|
|
|
618
|
|
|
619 // Used to implement exception handlers.
|
|
|
620 void*
|
|
|
621 __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__));
|
|
|
622
|
|
|
623 void*
|
|
|
624 __cxa_begin_catch(void*) _GLIBCXX_NOTHROW;
|
|
|
625
|
|
|
626 void
|
|
|
627 __cxa_end_catch();
|
|
|
628
|
|
|
629 void
|
|
|
630 __cxa_rethrow() __attribute__((__noreturn__));
|
|
|
631
|
|
|
632 // Returns the type_info for the currently handled exception [15.3/8], or
|
|
|
633 // null if there is none.
|
|
|
634 std::type_info*
|
|
|
635 __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__));
|
|
|
636
|
|
|
637 // GNU Extensions.
|
|
|
638
|
|
|
639 // Allocate memory for a dependent exception.
|
|
|
640 __cxa_dependent_exception*
|
|
|
641 __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW;
|
|
|
642
|
|
|
643 // Free the space allocated for the dependent exception.
|
|
|
644 void
|
|
|
645 __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW;
|
|
|
646
|
|
|
647 } // extern "C"
|
|
|
648
|
|
|
649 // A magic placeholder class that can be caught by reference
|
|
|
650 // to recognize foreign exceptions.
|
|
|
651 class __foreign_exception
|
|
|
652 {
|
|
|
653 virtual ~__foreign_exception() throw();
|
|
|
654 virtual void __pure_dummy() = 0; // prevent catch by value
|
|
|
655 };
|
|
|
656
|
|
|
657 } // namespace __cxxabiv1
|
|
|
658
|
|
|
659 /** @namespace abi
|
|
|
660 * @brief The cross-vendor C++ Application Binary Interface. A
|
|
|
661 * namespace alias to __cxxabiv1, but user programs should use the
|
|
|
662 * alias 'abi'.
|
|
|
663 *
|
|
|
664 * A brief overview of an ABI is given in the libstdc++ FAQ, question
|
|
|
665 * 5.8 (you may have a copy of the FAQ locally, or you can view the online
|
|
|
666 * version at http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#5_8 ).
|
|
|
667 *
|
|
|
668 * GCC subscribes to a cross-vendor ABI for C++, sometimes
|
|
|
669 * called the IA64 ABI because it happens to be the native ABI for that
|
|
|
670 * platform. It is summarized at http://www.codesourcery.com/cxx-abi/
|
|
|
671 * along with the current specification.
|
|
|
672 *
|
|
|
673 * For users of GCC greater than or equal to 3.x, entry points are
|
|
|
674 * available in <cxxabi.h>, which notes, <em>'It is not normally
|
|
|
675 * necessary for user programs to include this header, or use the
|
|
|
676 * entry points directly. However, this header is available should
|
|
|
677 * that be needed.'</em>
|
|
|
678 */
|
|
|
679 namespace abi = __cxxabiv1;
|
|
|
680
|
|
|
681 namespace __gnu_cxx
|
|
|
682 {
|
|
|
683 /**
|
|
|
684 * @brief Exception thrown by __cxa_guard_acquire.
|
|
|
685 * @ingroup exceptions
|
|
|
686 *
|
|
145
|
687 * C++ 2011 6.7 [stmt.dcl]/4: If control re-enters the declaration
|
|
|
688 * recursively while the variable is being initialized, the behavior
|
|
|
689 * is undefined.
|
|
111
|
690 *
|
|
|
691 * Since we already have a library function to handle locking, we might
|
|
|
692 * as well check for this situation and throw an exception.
|
|
|
693 * We use the second byte of the guard variable to remember that we're
|
|
|
694 * in the middle of an initialization.
|
|
|
695 */
|
|
|
696 class recursive_init_error: public std::exception
|
|
|
697 {
|
|
|
698 public:
|
|
145
|
699 recursive_init_error() _GLIBCXX_NOTHROW;
|
|
|
700 virtual ~recursive_init_error() _GLIBCXX_NOTHROW;
|
|
111
|
701 };
|
|
|
702 }
|
|
|
703 #endif // __cplusplus
|
|
|
704
|
|
|
705 #pragma GCC visibility pop
|
|
|
706
|
|
|
707 #endif // __CXXABI_H
|
