Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 1 | //===------------------------ private_typeinfo.h --------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is dual licensed under the MIT and the University of Illinois Open |
| 6 | // Source Licenses. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #ifndef __PRIVATE_TYPEINFO_H_ |
| 11 | #define __PRIVATE_TYPEINFO_H_ |
| 12 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 13 | #include "__cxxabi_config.h" |
| 14 | |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 15 | #include <typeinfo> |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 16 | #include <cstddef> |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 17 | |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 18 | namespace __cxxabiv1 { |
Howard Hinnant | facfc46 | 2012-01-22 01:23:02 +0000 | [diff] [blame] | 19 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 20 | class _LIBCXXABI_TYPE_VIS __shim_type_info : public std::type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 21 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 22 | _LIBCXXABI_HIDDEN virtual ~__shim_type_info(); |
Howard Hinnant | facfc46 | 2012-01-22 01:23:02 +0000 | [diff] [blame] | 23 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 24 | _LIBCXXABI_HIDDEN virtual void noop1() const; |
| 25 | _LIBCXXABI_HIDDEN virtual void noop2() const; |
| 26 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *thrown_type, |
| 27 | void *&adjustedPtr) const = 0; |
Howard Hinnant | facfc46 | 2012-01-22 01:23:02 +0000 | [diff] [blame] | 28 | }; |
| 29 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 30 | class _LIBCXXABI_TYPE_VIS __fundamental_type_info : public __shim_type_info { |
Howard Hinnant | facfc46 | 2012-01-22 01:23:02 +0000 | [diff] [blame] | 31 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 32 | _LIBCXXABI_HIDDEN virtual ~__fundamental_type_info(); |
| 33 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 34 | void *&) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 35 | }; |
| 36 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 37 | class _LIBCXXABI_TYPE_VIS __array_type_info : public __shim_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 38 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 39 | _LIBCXXABI_HIDDEN virtual ~__array_type_info(); |
| 40 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 41 | void *&) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 42 | }; |
| 43 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 44 | class _LIBCXXABI_TYPE_VIS __function_type_info : public __shim_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 45 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 46 | _LIBCXXABI_HIDDEN virtual ~__function_type_info(); |
| 47 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 48 | void *&) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 49 | }; |
| 50 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 51 | class _LIBCXXABI_TYPE_VIS __enum_type_info : public __shim_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 52 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 53 | _LIBCXXABI_HIDDEN virtual ~__enum_type_info(); |
| 54 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 55 | void *&) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 56 | }; |
| 57 | |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 58 | enum |
| 59 | { |
| 60 | unknown = 0, |
| 61 | public_path, |
Howard Hinnant | 1309366 | 2012-01-16 00:13:46 +0000 | [diff] [blame] | 62 | not_public_path, |
| 63 | yes, |
| 64 | no |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 65 | }; |
| 66 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 67 | class _LIBCXXABI_TYPE_VIS __class_type_info; |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 68 | |
Shoaib Meenai | 54227ae | 2017-03-01 03:55:57 +0000 | [diff] [blame] | 69 | struct _LIBCXXABI_HIDDEN __dynamic_cast_info |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 70 | { |
Howard Hinnant | cc614df | 2012-01-16 17:06:51 +0000 | [diff] [blame] | 71 | // const data supplied to the search: |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 72 | |
Howard Hinnant | 326aca3 | 2012-09-28 22:43:50 +0000 | [diff] [blame] | 73 | const __class_type_info* dst_type; |
| 74 | const void* static_ptr; |
| 75 | const __class_type_info* static_type; |
| 76 | std::ptrdiff_t src2dst_offset; |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 77 | |
Howard Hinnant | cc614df | 2012-01-16 17:06:51 +0000 | [diff] [blame] | 78 | // Data that represents the answer: |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 79 | |
| 80 | // pointer to a dst_type which has (static_ptr, static_type) above it |
| 81 | const void* dst_ptr_leading_to_static_ptr; |
| 82 | // pointer to a dst_type which does not have (static_ptr, static_type) above it |
| 83 | const void* dst_ptr_not_leading_to_static_ptr; |
Howard Hinnant | cc614df | 2012-01-16 17:06:51 +0000 | [diff] [blame] | 84 | |
| 85 | // The following three paths are either unknown, public_path or not_public_path. |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 86 | // access of path from dst_ptr_leading_to_static_ptr to (static_ptr, static_type) |
| 87 | int path_dst_ptr_to_static_ptr; |
| 88 | // access of path from (dynamic_ptr, dynamic_type) to (static_ptr, static_type) |
| 89 | // when there is no dst_type along the path |
| 90 | int path_dynamic_ptr_to_static_ptr; |
| 91 | // access of path from (dynamic_ptr, dynamic_type) to dst_type |
| 92 | // (not used if there is a (static_ptr, static_type) above a dst_type). |
| 93 | int path_dynamic_ptr_to_dst_ptr; |
Howard Hinnant | cc614df | 2012-01-16 17:06:51 +0000 | [diff] [blame] | 94 | |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 95 | // Number of dst_types below (static_ptr, static_type) |
| 96 | int number_to_static_ptr; |
| 97 | // Number of dst_types not below (static_ptr, static_type) |
| 98 | int number_to_dst_ptr; |
Howard Hinnant | cc614df | 2012-01-16 17:06:51 +0000 | [diff] [blame] | 99 | |
| 100 | // Data that helps stop the search before the entire tree is searched: |
| 101 | |
| 102 | // is_dst_type_derived_from_static_type is either unknown, yes or no. |
Howard Hinnant | 1309366 | 2012-01-16 00:13:46 +0000 | [diff] [blame] | 103 | int is_dst_type_derived_from_static_type; |
| 104 | // Number of dst_type in tree. If 0, then that means unknown. |
| 105 | int number_of_dst_type; |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 106 | // communicates to a dst_type node that (static_ptr, static_type) was found |
| 107 | // above it. |
Howard Hinnant | 1309366 | 2012-01-16 00:13:46 +0000 | [diff] [blame] | 108 | bool found_our_static_ptr; |
| 109 | // communicates to a dst_type node that a static_type was found |
| 110 | // above it, but it wasn't (static_ptr, static_type) |
| 111 | bool found_any_static_type; |
| 112 | // Set whenever a search can be stopped |
| 113 | bool search_done; |
Howard Hinnant | f877d21 | 2012-01-11 23:49:18 +0000 | [diff] [blame] | 114 | }; |
| 115 | |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 116 | // Has no base class |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 117 | class _LIBCXXABI_TYPE_VIS __class_type_info : public __shim_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 118 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 119 | _LIBCXXABI_HIDDEN virtual ~__class_type_info(); |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 120 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 121 | _LIBCXXABI_HIDDEN void process_static_type_above_dst(__dynamic_cast_info *, |
| 122 | const void *, |
| 123 | const void *, int) const; |
| 124 | _LIBCXXABI_HIDDEN void process_static_type_below_dst(__dynamic_cast_info *, |
| 125 | const void *, int) const; |
| 126 | _LIBCXXABI_HIDDEN void process_found_base_class(__dynamic_cast_info *, void *, |
| 127 | int) const; |
| 128 | _LIBCXXABI_HIDDEN virtual void search_above_dst(__dynamic_cast_info *, |
| 129 | const void *, const void *, |
| 130 | int, bool) const; |
| 131 | _LIBCXXABI_HIDDEN virtual void |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 132 | search_below_dst(__dynamic_cast_info *, const void *, int, bool) const; |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 133 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 134 | void *&) const; |
| 135 | _LIBCXXABI_HIDDEN virtual void |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 136 | has_unambiguous_public_base(__dynamic_cast_info *, void *, int) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 137 | }; |
| 138 | |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 139 | // Has one non-virtual public base class at offset zero |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 140 | class _LIBCXXABI_TYPE_VIS __si_class_type_info : public __class_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 141 | public: |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 142 | const __class_type_info *__base_type; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 143 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 144 | _LIBCXXABI_HIDDEN virtual ~__si_class_type_info(); |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 145 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 146 | _LIBCXXABI_HIDDEN virtual void search_above_dst(__dynamic_cast_info *, |
| 147 | const void *, const void *, |
| 148 | int, bool) const; |
| 149 | _LIBCXXABI_HIDDEN virtual void |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 150 | search_below_dst(__dynamic_cast_info *, const void *, int, bool) const; |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 151 | _LIBCXXABI_HIDDEN virtual void |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 152 | has_unambiguous_public_base(__dynamic_cast_info *, void *, int) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 153 | }; |
| 154 | |
Shoaib Meenai | 54227ae | 2017-03-01 03:55:57 +0000 | [diff] [blame] | 155 | struct _LIBCXXABI_HIDDEN __base_class_type_info |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 156 | { |
| 157 | public: |
| 158 | const __class_type_info* __base_type; |
| 159 | long __offset_flags; |
| 160 | |
| 161 | enum __offset_flags_masks |
| 162 | { |
| 163 | __virtual_mask = 0x1, |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 164 | __public_mask = 0x2, // base is public |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 165 | __offset_shift = 8 |
| 166 | }; |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 167 | |
Howard Hinnant | 326aca3 | 2012-09-28 22:43:50 +0000 | [diff] [blame] | 168 | void search_above_dst(__dynamic_cast_info*, const void*, const void*, int, bool) const; |
| 169 | void search_below_dst(__dynamic_cast_info*, const void*, int, bool) const; |
Howard Hinnant | a1919d2 | 2012-01-23 18:39:47 +0000 | [diff] [blame] | 170 | void has_unambiguous_public_base(__dynamic_cast_info*, void*, int) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 171 | }; |
| 172 | |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 173 | // Has one or more base classes |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 174 | class _LIBCXXABI_TYPE_VIS __vmi_class_type_info : public __class_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 175 | public: |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 176 | unsigned int __flags; |
| 177 | unsigned int __base_count; |
| 178 | __base_class_type_info __base_info[1]; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 179 | |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 180 | enum __flags_masks { |
| 181 | __non_diamond_repeat_mask = 0x1, // has two or more distinct base class |
| 182 | // objects of the same type |
| 183 | __diamond_shaped_mask = 0x2 // has base class object with two or |
| 184 | // more derived objects |
| 185 | }; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 186 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 187 | _LIBCXXABI_HIDDEN virtual ~__vmi_class_type_info(); |
Howard Hinnant | 16650b5 | 2012-01-11 00:11:17 +0000 | [diff] [blame] | 188 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 189 | _LIBCXXABI_HIDDEN virtual void search_above_dst(__dynamic_cast_info *, |
| 190 | const void *, const void *, |
| 191 | int, bool) const; |
| 192 | _LIBCXXABI_HIDDEN virtual void |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 193 | search_below_dst(__dynamic_cast_info *, const void *, int, bool) const; |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 194 | _LIBCXXABI_HIDDEN virtual void |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 195 | has_unambiguous_public_base(__dynamic_cast_info *, void *, int) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 196 | }; |
| 197 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 198 | class _LIBCXXABI_TYPE_VIS __pbase_type_info : public __shim_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 199 | public: |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 200 | unsigned int __flags; |
| 201 | const __shim_type_info *__pointee; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 202 | |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 203 | enum __masks { |
| 204 | __const_mask = 0x1, |
| 205 | __volatile_mask = 0x2, |
| 206 | __restrict_mask = 0x4, |
| 207 | __incomplete_mask = 0x8, |
Richard Smith | f163620 | 2016-12-02 02:06:53 +0000 | [diff] [blame] | 208 | __incomplete_class_mask = 0x10, |
| 209 | __transaction_safe_mask = 0x20, |
| 210 | // This implements the following proposal from cxx-abi-dev (not yet part of |
| 211 | // the ABI document): |
| 212 | // |
| 213 | // http://sourcerytools.com/pipermail/cxx-abi-dev/2016-October/002986.html |
| 214 | // |
| 215 | // This is necessary for support of http://wg21.link/p0012, which permits |
| 216 | // throwing noexcept function and member function pointers and catching |
| 217 | // them as non-noexcept pointers. |
| 218 | __noexcept_mask = 0x40, |
| 219 | |
| 220 | // Flags that cannot be removed by a standard conversion. |
| 221 | __no_remove_flags_mask = __const_mask | __volatile_mask | __restrict_mask, |
| 222 | // Flags that cannot be added by a standard conversion. |
| 223 | __no_add_flags_mask = __transaction_safe_mask | __noexcept_mask |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 224 | }; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 225 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 226 | _LIBCXXABI_HIDDEN virtual ~__pbase_type_info(); |
| 227 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 228 | void *&) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 229 | }; |
| 230 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 231 | class _LIBCXXABI_TYPE_VIS __pointer_type_info : public __pbase_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 232 | public: |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 233 | _LIBCXXABI_HIDDEN virtual ~__pointer_type_info(); |
| 234 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 235 | void *&) const; |
| 236 | _LIBCXXABI_HIDDEN bool can_catch_nested(const __shim_type_info *) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 237 | }; |
| 238 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 239 | class _LIBCXXABI_TYPE_VIS __pointer_to_member_type_info |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 240 | : public __pbase_type_info { |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 241 | public: |
Saleem Abdulrasool | 77a304b | 2015-12-04 02:14:41 +0000 | [diff] [blame] | 242 | const __class_type_info *__context; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 243 | |
Saleem Abdulrasool | b4ec579 | 2015-12-04 02:14:58 +0000 | [diff] [blame] | 244 | _LIBCXXABI_HIDDEN virtual ~__pointer_to_member_type_info(); |
| 245 | _LIBCXXABI_HIDDEN virtual bool can_catch(const __shim_type_info *, |
| 246 | void *&) const; |
| 247 | _LIBCXXABI_HIDDEN bool can_catch_nested(const __shim_type_info *) const; |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 248 | }; |
| 249 | |
Howard Hinnant | 152beb7 | 2012-01-09 17:10:00 +0000 | [diff] [blame] | 250 | } // __cxxabiv1 |
| 251 | |
| 252 | #endif // __PRIVATE_TYPEINFO_H_ |