1 //===----------------------- private_typeinfo.cpp -------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "private_typeinfo.h"
10
11 // The flag _LIBCXX_DYNAMIC_FALLBACK is used to make dynamic_cast more
12 // forgiving when type_info's mistakenly have hidden visibility and thus
13 // multiple type_infos can exist for a single type.
14 //
15 // When _LIBCXX_DYNAMIC_FALLBACK is defined, and only in the case where
16 // there is a detected inconsistency in the type_info hierarchy during a
17 // dynamic_cast, then the equality operation will fall back to using strcmp
18 // on type_info names to determine type_info equality.
19 //
20 // This change happens *only* under dynamic_cast, and only when
21 // dynamic_cast is faced with the choice: abort, or possibly give back the
22 // wrong answer. If when the dynamic_cast is done with this fallback
23 // algorithm and an inconsistency is still detected, dynamic_cast will call
24 // abort with an appropriate message.
25 //
26 // The current implementation of _LIBCXX_DYNAMIC_FALLBACK requires a
27 // printf-like function called syslog:
28 //
29 // void syslog(int facility_priority, const char* format, ...);
30 //
31 // If you want this functionality but your platform doesn't have syslog,
32 // just implement it in terms of fprintf(stderr, ...).
33 //
34 // _LIBCXX_DYNAMIC_FALLBACK is currently off by default.
35
36
37 #include <string.h>
38
39
40 #ifdef _LIBCXX_DYNAMIC_FALLBACK
41 #include "abort_message.h"
42 #include <sys/syslog.h>
43 #endif
44
45 // On Windows, typeids are different between DLLs and EXEs, so comparing
46 // type_info* will work for typeids from the same compiled file but fail
47 // for typeids from a DLL and an executable. Among other things, exceptions
48 // are not caught by handlers since can_catch() returns false.
49 //
50 // Defining _LIBCXX_DYNAMIC_FALLBACK does not help since can_catch() calls
51 // is_equal() with use_strcmp=false so the string names are not compared.
52
53 #ifdef _WIN32
54 #include <string.h>
55 #endif
56
57 static inline
58 bool
is_equal(const std::type_info * x,const std::type_info * y,bool use_strcmp)59 is_equal(const std::type_info* x, const std::type_info* y, bool use_strcmp)
60 {
61 #ifndef _WIN32
62 if (!use_strcmp)
63 return x == y;
64 return strcmp(x->name(), y->name()) == 0;
65 #else
66 (void) use_strcmp;
67 return (x == y) || (strcmp(x->name(), y->name()) == 0);
68 #endif
69 }
70
71 namespace __cxxabiv1
72 {
73
74 // __shim_type_info
75
~__shim_type_info()76 __shim_type_info::~__shim_type_info()
77 {
78 }
79
noop1() const80 void __shim_type_info::noop1() const {}
noop2() const81 void __shim_type_info::noop2() const {}
82
83 // __fundamental_type_info
84
85 // This miraculously (compiler magic) emits the type_info's for:
86 // 1. all of the fundamental types
87 // 2. pointers to all of the fundamental types
88 // 3. pointers to all of the const fundamental types
~__fundamental_type_info()89 __fundamental_type_info::~__fundamental_type_info()
90 {
91 }
92
93 // __array_type_info
94
~__array_type_info()95 __array_type_info::~__array_type_info()
96 {
97 }
98
99 // __function_type_info
100
~__function_type_info()101 __function_type_info::~__function_type_info()
102 {
103 }
104
105 // __enum_type_info
106
~__enum_type_info()107 __enum_type_info::~__enum_type_info()
108 {
109 }
110
111 // __class_type_info
112
~__class_type_info()113 __class_type_info::~__class_type_info()
114 {
115 }
116
117 // __si_class_type_info
118
~__si_class_type_info()119 __si_class_type_info::~__si_class_type_info()
120 {
121 }
122
123 // __vmi_class_type_info
124
~__vmi_class_type_info()125 __vmi_class_type_info::~__vmi_class_type_info()
126 {
127 }
128
129 // __pbase_type_info
130
~__pbase_type_info()131 __pbase_type_info::~__pbase_type_info()
132 {
133 }
134
135 // __pointer_type_info
136
~__pointer_type_info()137 __pointer_type_info::~__pointer_type_info()
138 {
139 }
140
141 // __pointer_to_member_type_info
142
~__pointer_to_member_type_info()143 __pointer_to_member_type_info::~__pointer_to_member_type_info()
144 {
145 }
146
147 // can_catch
148
149 // A handler is a match for an exception object of type E if
150 // 1. The handler is of type cv T or cv T& and E and T are the same type
151 // (ignoring the top-level cv-qualifiers), or
152 // 2. the handler is of type cv T or cv T& and T is an unambiguous public
153 // base class of E, or
154 // 3. the handler is of type cv1 T* cv2 and E is a pointer type that can be
155 // converted to the type of the handler by either or both of
156 // A. a standard pointer conversion (4.10) not involving conversions to
157 // pointers to private or protected or ambiguous classes
158 // B. a qualification conversion
159 // 4. the handler is a pointer or pointer to member type and E is
160 // std::nullptr_t.
161
162 // adjustedPtr:
163 //
164 // catch (A& a) : adjustedPtr == &a
165 // catch (A* a) : adjustedPtr == a
166 // catch (A** a) : adjustedPtr == a
167 //
168 // catch (D2& d2) : adjustedPtr == &d2 (d2 is base class of thrown object)
169 // catch (D2* d2) : adjustedPtr == d2
170 // catch (D2*& d2) : adjustedPtr == d2
171 //
172 // catch (...) : adjustedPtr == & of the exception
173 //
174 // If the thrown type is nullptr_t and the caught type is a pointer to
175 // member type, adjustedPtr points to a statically-allocated null pointer
176 // representation of that type.
177
178 // Handles bullet 1
179 bool
can_catch(const __shim_type_info * thrown_type,void * &) const180 __fundamental_type_info::can_catch(const __shim_type_info* thrown_type,
181 void*&) const
182 {
183 return is_equal(this, thrown_type, false);
184 }
185
186 bool
can_catch(const __shim_type_info *,void * &) const187 __array_type_info::can_catch(const __shim_type_info*, void*&) const
188 {
189 // We can get here if someone tries to catch an array by reference.
190 // However if someone tries to throw an array, it immediately gets
191 // converted to a pointer, which will not convert back to an array
192 // at the catch clause. So this can never catch anything.
193 return false;
194 }
195
196 bool
can_catch(const __shim_type_info *,void * &) const197 __function_type_info::can_catch(const __shim_type_info*, void*&) const
198 {
199 // We can get here if someone tries to catch a function by reference.
200 // However if someone tries to throw a function, it immediately gets
201 // converted to a pointer, which will not convert back to a function
202 // at the catch clause. So this can never catch anything.
203 return false;
204 }
205
206 // Handles bullet 1
207 bool
can_catch(const __shim_type_info * thrown_type,void * &) const208 __enum_type_info::can_catch(const __shim_type_info* thrown_type,
209 void*&) const
210 {
211 return is_equal(this, thrown_type, false);
212 }
213
214 #ifdef __clang__
215 #pragma clang diagnostic push
216 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
217 #endif
218
219 // Handles bullets 1 and 2
220 bool
can_catch(const __shim_type_info * thrown_type,void * & adjustedPtr) const221 __class_type_info::can_catch(const __shim_type_info* thrown_type,
222 void*& adjustedPtr) const
223 {
224 // bullet 1
225 if (is_equal(this, thrown_type, false))
226 return true;
227 const __class_type_info* thrown_class_type =
228 dynamic_cast<const __class_type_info*>(thrown_type);
229 if (thrown_class_type == 0)
230 return false;
231 // bullet 2
232 __dynamic_cast_info info = {thrown_class_type, 0, this, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
233 info.number_of_dst_type = 1;
234 thrown_class_type->has_unambiguous_public_base(&info, adjustedPtr, public_path);
235 if (info.path_dst_ptr_to_static_ptr == public_path)
236 {
237 adjustedPtr = const_cast<void*>(info.dst_ptr_leading_to_static_ptr);
238 return true;
239 }
240 return false;
241 }
242
243 #ifdef __clang__
244 #pragma clang diagnostic pop
245 #endif
246
247 void
process_found_base_class(__dynamic_cast_info * info,void * adjustedPtr,int path_below) const248 __class_type_info::process_found_base_class(__dynamic_cast_info* info,
249 void* adjustedPtr,
250 int path_below) const
251 {
252 if (info->dst_ptr_leading_to_static_ptr == 0)
253 {
254 // First time here
255 info->dst_ptr_leading_to_static_ptr = adjustedPtr;
256 info->path_dst_ptr_to_static_ptr = path_below;
257 info->number_to_static_ptr = 1;
258 }
259 else if (info->dst_ptr_leading_to_static_ptr == adjustedPtr)
260 {
261 // We've been here before. Update path to "most public"
262 if (info->path_dst_ptr_to_static_ptr == not_public_path)
263 info->path_dst_ptr_to_static_ptr = path_below;
264 }
265 else
266 {
267 // We've detected an ambiguous cast from (thrown_class_type, adjustedPtr)
268 // to a static_type
269 info->number_to_static_ptr += 1;
270 info->path_dst_ptr_to_static_ptr = not_public_path;
271 info->search_done = true;
272 }
273 }
274
275 void
has_unambiguous_public_base(__dynamic_cast_info * info,void * adjustedPtr,int path_below) const276 __class_type_info::has_unambiguous_public_base(__dynamic_cast_info* info,
277 void* adjustedPtr,
278 int path_below) const
279 {
280 if (is_equal(this, info->static_type, false))
281 process_found_base_class(info, adjustedPtr, path_below);
282 }
283
284 void
has_unambiguous_public_base(__dynamic_cast_info * info,void * adjustedPtr,int path_below) const285 __si_class_type_info::has_unambiguous_public_base(__dynamic_cast_info* info,
286 void* adjustedPtr,
287 int path_below) const
288 {
289 if (is_equal(this, info->static_type, false))
290 process_found_base_class(info, adjustedPtr, path_below);
291 else
292 __base_type->has_unambiguous_public_base(info, adjustedPtr, path_below);
293 }
294
295 void
has_unambiguous_public_base(__dynamic_cast_info * info,void * adjustedPtr,int path_below) const296 __base_class_type_info::has_unambiguous_public_base(__dynamic_cast_info* info,
297 void* adjustedPtr,
298 int path_below) const
299 {
300 ptrdiff_t offset_to_base = 0;
301 if (adjustedPtr != nullptr)
302 {
303 offset_to_base = __offset_flags >> __offset_shift;
304 if (__offset_flags & __virtual_mask)
305 {
306 const char* vtable = *static_cast<const char*const*>(adjustedPtr);
307 offset_to_base = *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
308 }
309 }
310 __base_type->has_unambiguous_public_base(
311 info,
312 static_cast<char*>(adjustedPtr) + offset_to_base,
313 (__offset_flags & __public_mask) ? path_below : not_public_path);
314 }
315
316 void
has_unambiguous_public_base(__dynamic_cast_info * info,void * adjustedPtr,int path_below) const317 __vmi_class_type_info::has_unambiguous_public_base(__dynamic_cast_info* info,
318 void* adjustedPtr,
319 int path_below) const
320 {
321 if (is_equal(this, info->static_type, false))
322 process_found_base_class(info, adjustedPtr, path_below);
323 else
324 {
325 typedef const __base_class_type_info* Iter;
326 const Iter e = __base_info + __base_count;
327 Iter p = __base_info;
328 p->has_unambiguous_public_base(info, adjustedPtr, path_below);
329 if (++p < e)
330 {
331 do
332 {
333 p->has_unambiguous_public_base(info, adjustedPtr, path_below);
334 if (info->search_done)
335 break;
336 } while (++p < e);
337 }
338 }
339 }
340
341 // Handles bullet 1 for both pointers and member pointers
342 bool
can_catch(const __shim_type_info * thrown_type,void * &) const343 __pbase_type_info::can_catch(const __shim_type_info* thrown_type,
344 void*&) const
345 {
346 bool use_strcmp = this->__flags & (__incomplete_class_mask |
347 __incomplete_mask);
348 if (!use_strcmp) {
349 const __pbase_type_info* thrown_pbase = dynamic_cast<const __pbase_type_info*>(
350 thrown_type);
351 if (!thrown_pbase) return false;
352 use_strcmp = thrown_pbase->__flags & (__incomplete_class_mask |
353 __incomplete_mask);
354 }
355 return is_equal(this, thrown_type, use_strcmp);
356 }
357
358 #ifdef __clang__
359 #pragma clang diagnostic push
360 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
361 #endif
362
363 // Handles bullets 1, 3 and 4
364 // NOTE: It might not be safe to adjust the pointer if it is not not a pointer
365 // type. Only adjust the pointer after we know it is safe to do so.
366 bool
can_catch(const __shim_type_info * thrown_type,void * & adjustedPtr) const367 __pointer_type_info::can_catch(const __shim_type_info* thrown_type,
368 void*& adjustedPtr) const
369 {
370 // bullet 4
371 if (is_equal(thrown_type, &typeid(std::nullptr_t), false)) {
372 adjustedPtr = nullptr;
373 return true;
374 }
375
376 // bullet 1
377 if (__pbase_type_info::can_catch(thrown_type, adjustedPtr)) {
378 if (adjustedPtr != NULL)
379 adjustedPtr = *static_cast<void**>(adjustedPtr);
380 return true;
381 }
382 // bullet 3
383 const __pointer_type_info* thrown_pointer_type =
384 dynamic_cast<const __pointer_type_info*>(thrown_type);
385 if (thrown_pointer_type == 0)
386 return false;
387 // Do the dereference adjustment
388 if (adjustedPtr != NULL)
389 adjustedPtr = *static_cast<void**>(adjustedPtr);
390 // bullet 3B and 3C
391 if (thrown_pointer_type->__flags & ~__flags & __no_remove_flags_mask)
392 return false;
393 if (__flags & ~thrown_pointer_type->__flags & __no_add_flags_mask)
394 return false;
395 if (is_equal(__pointee, thrown_pointer_type->__pointee, false))
396 return true;
397 // bullet 3A
398 if (is_equal(__pointee, &typeid(void), false)) {
399 // pointers to functions cannot be converted to void*.
400 // pointers to member functions are not handled here.
401 const __function_type_info* thrown_function =
402 dynamic_cast<const __function_type_info*>(thrown_pointer_type->__pointee);
403 return (thrown_function == nullptr);
404 }
405 // Handle pointer to pointer
406 const __pointer_type_info* nested_pointer_type =
407 dynamic_cast<const __pointer_type_info*>(__pointee);
408 if (nested_pointer_type) {
409 if (~__flags & __const_mask) return false;
410 return nested_pointer_type->can_catch_nested(thrown_pointer_type->__pointee);
411 }
412
413 // Handle pointer to pointer to member
414 const __pointer_to_member_type_info* member_ptr_type =
415 dynamic_cast<const __pointer_to_member_type_info*>(__pointee);
416 if (member_ptr_type) {
417 if (~__flags & __const_mask) return false;
418 return member_ptr_type->can_catch_nested(thrown_pointer_type->__pointee);
419 }
420
421 // Handle pointer to class type
422 const __class_type_info* catch_class_type =
423 dynamic_cast<const __class_type_info*>(__pointee);
424 if (catch_class_type == 0)
425 return false;
426 const __class_type_info* thrown_class_type =
427 dynamic_cast<const __class_type_info*>(thrown_pointer_type->__pointee);
428 if (thrown_class_type == 0)
429 return false;
430 __dynamic_cast_info info = {thrown_class_type, 0, catch_class_type, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
431 info.number_of_dst_type = 1;
432 thrown_class_type->has_unambiguous_public_base(&info, adjustedPtr, public_path);
433 if (info.path_dst_ptr_to_static_ptr == public_path)
434 {
435 if (adjustedPtr != NULL)
436 adjustedPtr = const_cast<void*>(info.dst_ptr_leading_to_static_ptr);
437 return true;
438 }
439 return false;
440 }
441
can_catch_nested(const __shim_type_info * thrown_type) const442 bool __pointer_type_info::can_catch_nested(
443 const __shim_type_info* thrown_type) const
444 {
445 const __pointer_type_info* thrown_pointer_type =
446 dynamic_cast<const __pointer_type_info*>(thrown_type);
447 if (thrown_pointer_type == 0)
448 return false;
449 // bullet 3B
450 if (thrown_pointer_type->__flags & ~__flags)
451 return false;
452 if (is_equal(__pointee, thrown_pointer_type->__pointee, false))
453 return true;
454 // If the pointed to types differ then the catch type must be const
455 // qualified.
456 if (~__flags & __const_mask)
457 return false;
458
459 // Handle pointer to pointer
460 const __pointer_type_info* nested_pointer_type =
461 dynamic_cast<const __pointer_type_info*>(__pointee);
462 if (nested_pointer_type) {
463 return nested_pointer_type->can_catch_nested(
464 thrown_pointer_type->__pointee);
465 }
466
467 // Handle pointer to pointer to member
468 const __pointer_to_member_type_info* member_ptr_type =
469 dynamic_cast<const __pointer_to_member_type_info*>(__pointee);
470 if (member_ptr_type) {
471 return member_ptr_type->can_catch_nested(thrown_pointer_type->__pointee);
472 }
473
474 return false;
475 }
476
can_catch(const __shim_type_info * thrown_type,void * & adjustedPtr) const477 bool __pointer_to_member_type_info::can_catch(
478 const __shim_type_info* thrown_type, void*& adjustedPtr) const {
479 // bullet 4
480 if (is_equal(thrown_type, &typeid(std::nullptr_t), false)) {
481 // We assume that the pointer to member representation is the same for
482 // all pointers to data members and for all pointers to member functions.
483 struct X {};
484 if (dynamic_cast<const __function_type_info*>(__pointee)) {
485 static int (X::*const null_ptr_rep)() = nullptr;
486 adjustedPtr = const_cast<int (X::**)()>(&null_ptr_rep);
487 } else {
488 static int X::*const null_ptr_rep = nullptr;
489 adjustedPtr = const_cast<int X::**>(&null_ptr_rep);
490 }
491 return true;
492 }
493
494 // bullet 1
495 if (__pbase_type_info::can_catch(thrown_type, adjustedPtr))
496 return true;
497
498 const __pointer_to_member_type_info* thrown_pointer_type =
499 dynamic_cast<const __pointer_to_member_type_info*>(thrown_type);
500 if (thrown_pointer_type == 0)
501 return false;
502 if (thrown_pointer_type->__flags & ~__flags & __no_remove_flags_mask)
503 return false;
504 if (__flags & ~thrown_pointer_type->__flags & __no_add_flags_mask)
505 return false;
506 if (!is_equal(__pointee, thrown_pointer_type->__pointee, false))
507 return false;
508 if (is_equal(__context, thrown_pointer_type->__context, false))
509 return true;
510
511 // [except.handle] does not allow the pointer-to-member conversions mentioned
512 // in [mem.conv] to take place. For this reason we don't check Derived->Base
513 // for Derived->Base conversions.
514
515 return false;
516 }
517
can_catch_nested(const __shim_type_info * thrown_type) const518 bool __pointer_to_member_type_info::can_catch_nested(
519 const __shim_type_info* thrown_type) const
520 {
521 const __pointer_to_member_type_info* thrown_member_ptr_type =
522 dynamic_cast<const __pointer_to_member_type_info*>(thrown_type);
523 if (thrown_member_ptr_type == 0)
524 return false;
525 if (~__flags & thrown_member_ptr_type->__flags)
526 return false;
527 if (!is_equal(__pointee, thrown_member_ptr_type->__pointee, false))
528 return false;
529 if (!is_equal(__context, thrown_member_ptr_type->__context, false))
530 return false;
531 return true;
532 }
533
534 #ifdef __clang__
535 #pragma clang diagnostic pop
536 #endif
537
538 #ifdef __clang__
539 #pragma clang diagnostic push
540 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
541 #endif
542
543 // __dynamic_cast
544
545 // static_ptr: pointer to an object of type static_type; nonnull, and since the
546 // object is polymorphic, *(void**)static_ptr is a virtual table pointer.
547 // static_ptr is &v in the expression dynamic_cast<T>(v).
548 // static_type: static type of the object pointed to by static_ptr.
549 // dst_type: destination type of the cast (the "T" in "dynamic_cast<T>(v)").
550 // src2dst_offset: a static hint about the location of the
551 // source subobject with respect to the complete object;
552 // special negative values are:
553 // -1: no hint
554 // -2: static_type is not a public base of dst_type
555 // -3: static_type is a multiple public base type but never a
556 // virtual base type
557 // otherwise, the static_type type is a unique public nonvirtual
558 // base type of dst_type at offset src2dst_offset from the
559 // origin of dst_type.
560 //
561 // (dynamic_ptr, dynamic_type) are the run time type of the complete object
562 // referred to by static_ptr and a pointer to it. These can be found from
563 // static_ptr for polymorphic types.
564 // static_type is guaranteed to be a polymorphic type.
565 //
566 // (dynamic_ptr, dynamic_type) is the root of a DAG that grows upward. Each
567 // node of the tree represents a base class/object of its parent (or parents) below.
568 // Each node is uniquely represented by a pointer to the object, and a pointer
569 // to a type_info - its type. Different nodes may have the same pointer and
570 // different nodes may have the same type. But only one node has a specific
571 // (pointer-value, type) pair. In C++ two objects of the same type can not
572 // share the same address.
573 //
574 // There are two flavors of nodes which have the type dst_type:
575 // 1. Those that are derived from (below) (static_ptr, static_type).
576 // 2. Those that are not derived from (below) (static_ptr, static_type).
577 //
578 // Invariants of the DAG:
579 //
580 // There is at least one path from the root (dynamic_ptr, dynamic_type) to
581 // the node (static_ptr, static_type). This path may or may not be public.
582 // There may be more than one such path (some public some not). Such a path may
583 // or may not go through a node having type dst_type.
584 //
585 // No node of type T appears above a node of the same type. That means that
586 // there is only one node with dynamic_type. And if dynamic_type == dst_type,
587 // then there is only one dst_type in the DAG.
588 //
589 // No node of type dst_type appears above a node of type static_type. Such
590 // DAG's are possible in C++, but the compiler computes those dynamic_casts at
591 // compile time, and only calls __dynamic_cast when dst_type lies below
592 // static_type in the DAG.
593 //
594 // dst_type != static_type: The compiler computes the dynamic_cast in this case too.
595 // dynamic_type != static_type: The compiler computes the dynamic_cast in this case too.
596 //
597 // Returns:
598 //
599 // If there is exactly one dst_type of flavor 1, and
600 // If there is a public path from that dst_type to (static_ptr, static_type), or
601 // If there are 0 dst_types of flavor 2, and there is a public path from
602 // (dynamic_ptr, dynamic_type) to (static_ptr, static_type) and a public
603 // path from (dynamic_ptr, dynamic_type) to the one dst_type, then return
604 // a pointer to that dst_type.
605 // Else if there are 0 dst_types of flavor 1 and exactly 1 dst_type of flavor 2, and
606 // if there is a public path from (dynamic_ptr, dynamic_type) to
607 // (static_ptr, static_type) and a public path from (dynamic_ptr, dynamic_type)
608 // to the one dst_type, then return a pointer to that one dst_type.
609 // Else return nullptr.
610 //
611 // If dynamic_type == dst_type, then the above algorithm collapses to the
612 // following cheaper algorithm:
613 //
614 // If there is a public path from (dynamic_ptr, dynamic_type) to
615 // (static_ptr, static_type), then return dynamic_ptr.
616 // Else return nullptr.
617
618 extern "C" _LIBCXXABI_FUNC_VIS void *
__dynamic_cast(const void * static_ptr,const __class_type_info * static_type,const __class_type_info * dst_type,std::ptrdiff_t src2dst_offset)619 __dynamic_cast(const void *static_ptr, const __class_type_info *static_type,
620 const __class_type_info *dst_type,
621 std::ptrdiff_t src2dst_offset) {
622 // Possible future optimization: Take advantage of src2dst_offset
623 // Currently clang always sets src2dst_offset to -1 (no hint).
624
625 // Get (dynamic_ptr, dynamic_type) from static_ptr
626 void **vtable = *static_cast<void ** const *>(static_ptr);
627 ptrdiff_t offset_to_derived = reinterpret_cast<ptrdiff_t>(vtable[-2]);
628 const void* dynamic_ptr = static_cast<const char*>(static_ptr) + offset_to_derived;
629 const __class_type_info* dynamic_type = static_cast<const __class_type_info*>(vtable[-1]);
630
631 // Initialize answer to nullptr. This will be changed from the search
632 // results if a non-null answer is found. Regardless, this is what will
633 // be returned.
634 const void* dst_ptr = 0;
635 // Initialize info struct for this search.
636 __dynamic_cast_info info = {dst_type, static_ptr, static_type, src2dst_offset, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
637
638 // Find out if we can use a giant short cut in the search
639 if (is_equal(dynamic_type, dst_type, false))
640 {
641 // Using giant short cut. Add that information to info.
642 info.number_of_dst_type = 1;
643 // Do the search
644 dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, false);
645 #ifdef _LIBCXX_DYNAMIC_FALLBACK
646 // The following if should always be false because we should definitely
647 // find (static_ptr, static_type), either on a public or private path
648 if (info.path_dst_ptr_to_static_ptr == unknown)
649 {
650 // We get here only if there is some kind of visibility problem
651 // in client code.
652 syslog(LOG_ERR, "dynamic_cast error 1: Both of the following type_info's "
653 "should have public visibility. At least one of them is hidden. %s"
654 ", %s.\n", static_type->name(), dynamic_type->name());
655 // Redo the search comparing type_info's using strcmp
656 info = {dst_type, static_ptr, static_type, src2dst_offset, 0};
657 info.number_of_dst_type = 1;
658 dynamic_type->search_above_dst(&info, dynamic_ptr, dynamic_ptr, public_path, true);
659 }
660 #endif // _LIBCXX_DYNAMIC_FALLBACK
661 // Query the search.
662 if (info.path_dst_ptr_to_static_ptr == public_path)
663 dst_ptr = dynamic_ptr;
664 }
665 else
666 {
667 // Not using giant short cut. Do the search
668 dynamic_type->search_below_dst(&info, dynamic_ptr, public_path, false);
669 #ifdef _LIBCXX_DYNAMIC_FALLBACK
670 // The following if should always be false because we should definitely
671 // find (static_ptr, static_type), either on a public or private path
672 if (info.path_dst_ptr_to_static_ptr == unknown &&
673 info.path_dynamic_ptr_to_static_ptr == unknown)
674 {
675 syslog(LOG_ERR, "dynamic_cast error 2: One or more of the following type_info's "
676 "has hidden visibility or is defined in more than one translation "
677 "unit. They should all have public visibility. "
678 "%s, %s, %s.\n", static_type->name(), dynamic_type->name(),
679 dst_type->name());
680 // Redo the search comparing type_info's using strcmp
681 info = {dst_type, static_ptr, static_type, src2dst_offset, 0};
682 dynamic_type->search_below_dst(&info, dynamic_ptr, public_path, true);
683 }
684 #endif // _LIBCXX_DYNAMIC_FALLBACK
685 // Query the search.
686 switch (info.number_to_static_ptr)
687 {
688 case 0:
689 if (info.number_to_dst_ptr == 1 &&
690 info.path_dynamic_ptr_to_static_ptr == public_path &&
691 info.path_dynamic_ptr_to_dst_ptr == public_path)
692 dst_ptr = info.dst_ptr_not_leading_to_static_ptr;
693 break;
694 case 1:
695 if (info.path_dst_ptr_to_static_ptr == public_path ||
696 (
697 info.number_to_dst_ptr == 0 &&
698 info.path_dynamic_ptr_to_static_ptr == public_path &&
699 info.path_dynamic_ptr_to_dst_ptr == public_path
700 )
701 )
702 dst_ptr = info.dst_ptr_leading_to_static_ptr;
703 break;
704 }
705 }
706 return const_cast<void*>(dst_ptr);
707 }
708
709 #ifdef __clang__
710 #pragma clang diagnostic pop
711 #endif
712
713 // Call this function when you hit a static_type which is a base (above) a dst_type.
714 // Let caller know you hit a static_type. But only start recording details if
715 // this is (static_ptr, static_type) -- the node we are casting from.
716 // If this is (static_ptr, static_type)
717 // Record the path (public or not) from the dst_type to here. There may be
718 // multiple paths from the same dst_type to here, record the "most public" one.
719 // Record the dst_ptr as pointing to (static_ptr, static_type).
720 // If more than one (dst_ptr, dst_type) points to (static_ptr, static_type),
721 // then mark this dyanmic_cast as ambiguous and stop the search.
722 void
process_static_type_above_dst(__dynamic_cast_info * info,const void * dst_ptr,const void * current_ptr,int path_below) const723 __class_type_info::process_static_type_above_dst(__dynamic_cast_info* info,
724 const void* dst_ptr,
725 const void* current_ptr,
726 int path_below) const
727 {
728 // Record that we found a static_type
729 info->found_any_static_type = true;
730 if (current_ptr == info->static_ptr)
731 {
732 // Record that we found (static_ptr, static_type)
733 info->found_our_static_ptr = true;
734 if (info->dst_ptr_leading_to_static_ptr == 0)
735 {
736 // First time here
737 info->dst_ptr_leading_to_static_ptr = dst_ptr;
738 info->path_dst_ptr_to_static_ptr = path_below;
739 info->number_to_static_ptr = 1;
740 // If there is only one dst_type in the entire tree and the path from
741 // there to here is public then we are done!
742 if (info->number_of_dst_type == 1 && info->path_dst_ptr_to_static_ptr == public_path)
743 info->search_done = true;
744 }
745 else if (info->dst_ptr_leading_to_static_ptr == dst_ptr)
746 {
747 // We've been here before. Update path to "most public"
748 if (info->path_dst_ptr_to_static_ptr == not_public_path)
749 info->path_dst_ptr_to_static_ptr = path_below;
750 // If there is only one dst_type in the entire tree and the path from
751 // there to here is public then we are done!
752 if (info->number_of_dst_type == 1 && info->path_dst_ptr_to_static_ptr == public_path)
753 info->search_done = true;
754 }
755 else
756 {
757 // We've detected an ambiguous cast from (static_ptr, static_type)
758 // to a dst_type
759 info->number_to_static_ptr += 1;
760 info->search_done = true;
761 }
762 }
763 }
764
765 // Call this function when you hit a static_type which is not a base (above) a dst_type.
766 // If this is (static_ptr, static_type)
767 // Record the path (public or not) from (dynamic_ptr, dynamic_type) to here. There may be
768 // multiple paths from (dynamic_ptr, dynamic_type) to here, record the "most public" one.
769 void
process_static_type_below_dst(__dynamic_cast_info * info,const void * current_ptr,int path_below) const770 __class_type_info::process_static_type_below_dst(__dynamic_cast_info* info,
771 const void* current_ptr,
772 int path_below) const
773 {
774 if (current_ptr == info->static_ptr)
775 {
776 // Record the most public path from (dynamic_ptr, dynamic_type) to
777 // (static_ptr, static_type)
778 if (info->path_dynamic_ptr_to_static_ptr != public_path)
779 info->path_dynamic_ptr_to_static_ptr = path_below;
780 }
781 }
782
783 // Call this function when searching below a dst_type node. This function searches
784 // for a path to (static_ptr, static_type) and for paths to one or more dst_type nodes.
785 // If it finds a static_type node, there is no need to further search base classes
786 // above.
787 // If it finds a dst_type node it should search base classes using search_above_dst
788 // to find out if this dst_type points to (static_ptr, static_type) or not.
789 // Either way, the dst_type is recorded as one of two "flavors": one that does
790 // or does not point to (static_ptr, static_type).
791 // If this is neither a static_type nor a dst_type node, continue searching
792 // base classes above.
793 // All the hoopla surrounding the search code is doing nothing but looking for
794 // excuses to stop the search prematurely (break out of the for-loop). That is,
795 // the algorithm below is simply an optimization of this:
796 // void
797 // __vmi_class_type_info::search_below_dst(__dynamic_cast_info* info,
798 // const void* current_ptr,
799 // int path_below) const
800 // {
801 // typedef const __base_class_type_info* Iter;
802 // if (this == info->static_type)
803 // process_static_type_below_dst(info, current_ptr, path_below);
804 // else if (this == info->dst_type)
805 // {
806 // // Record the most public access path that got us here
807 // if (info->path_dynamic_ptr_to_dst_ptr != public_path)
808 // info->path_dynamic_ptr_to_dst_ptr = path_below;
809 // bool does_dst_type_point_to_our_static_type = false;
810 // for (Iter p = __base_info, e= __base_info + __base_count; p < e; ++p)
811 // {
812 // p->search_above_dst(info, current_ptr, current_ptr, public_path);
813 // if (info->found_our_static_ptr)
814 // does_dst_type_point_to_our_static_type = true;
815 // // break out early here if you can detect it doesn't matter if you do
816 // }
817 // if (!does_dst_type_point_to_our_static_type)
818 // {
819 // // We found a dst_type that doesn't point to (static_ptr, static_type)
820 // // So record the address of this dst_ptr and increment the
821 // // count of the number of such dst_types found in the tree.
822 // info->dst_ptr_not_leading_to_static_ptr = current_ptr;
823 // info->number_to_dst_ptr += 1;
824 // }
825 // }
826 // else
827 // {
828 // // This is not a static_type and not a dst_type.
829 // for (Iter p = __base_info, e = __base_info + __base_count; p < e; ++p)
830 // {
831 // p->search_below_dst(info, current_ptr, public_path);
832 // // break out early here if you can detect it doesn't matter if you do
833 // }
834 // }
835 // }
836 void
search_below_dst(__dynamic_cast_info * info,const void * current_ptr,int path_below,bool use_strcmp) const837 __vmi_class_type_info::search_below_dst(__dynamic_cast_info* info,
838 const void* current_ptr,
839 int path_below,
840 bool use_strcmp) const
841 {
842 typedef const __base_class_type_info* Iter;
843 if (is_equal(this, info->static_type, use_strcmp))
844 process_static_type_below_dst(info, current_ptr, path_below);
845 else if (is_equal(this, info->dst_type, use_strcmp))
846 {
847 // We've been here before if we've recorded current_ptr in one of these
848 // two places:
849 if (current_ptr == info->dst_ptr_leading_to_static_ptr ||
850 current_ptr == info->dst_ptr_not_leading_to_static_ptr)
851 {
852 // We've seen this node before, and therefore have already searched
853 // its base classes above.
854 // Update path to here that is "most public".
855 if (path_below == public_path)
856 info->path_dynamic_ptr_to_dst_ptr = public_path;
857 }
858 else // We have haven't been here before
859 {
860 // Record the access path that got us here
861 // If there is more than one dst_type this path doesn't matter.
862 info->path_dynamic_ptr_to_dst_ptr = path_below;
863 bool does_dst_type_point_to_our_static_type = false;
864 // Only search above here if dst_type derives from static_type, or
865 // if it is unknown if dst_type derives from static_type.
866 if (info->is_dst_type_derived_from_static_type != no)
867 {
868 // Set up flags to record results from all base classes
869 bool is_dst_type_derived_from_static_type = false;
870
871 // We've found a dst_type with a potentially public path to here.
872 // We have to assume the path is public because it may become
873 // public later (if we get back to here with a public path).
874 // We can stop looking above if:
875 // 1. We've found a public path to (static_ptr, static_type).
876 // 2. We've found an ambiguous cast from (static_ptr, static_type) to a dst_type.
877 // This is detected at the (static_ptr, static_type).
878 // 3. We can prove that there is no public path to (static_ptr, static_type)
879 // above here.
880 const Iter e = __base_info + __base_count;
881 for (Iter p = __base_info; p < e; ++p)
882 {
883 // Zero out found flags
884 info->found_our_static_ptr = false;
885 info->found_any_static_type = false;
886 p->search_above_dst(info, current_ptr, current_ptr, public_path, use_strcmp);
887 if (info->search_done)
888 break;
889 if (info->found_any_static_type)
890 {
891 is_dst_type_derived_from_static_type = true;
892 if (info->found_our_static_ptr)
893 {
894 does_dst_type_point_to_our_static_type = true;
895 // If we found what we're looking for, stop looking above.
896 if (info->path_dst_ptr_to_static_ptr == public_path)
897 break;
898 // We found a private path to (static_ptr, static_type)
899 // If there is no diamond then there is only one path
900 // to (static_ptr, static_type) and we just found it.
901 if (!(__flags & __diamond_shaped_mask))
902 break;
903 }
904 else
905 {
906 // If we found a static_type that isn't the one we're looking
907 // for, and if there are no repeated types above here,
908 // then stop looking.
909 if (!(__flags & __non_diamond_repeat_mask))
910 break;
911 }
912 }
913 }
914 // If we found no static_type,s then dst_type doesn't derive
915 // from static_type, else it does. Record this result so that
916 // next time we hit a dst_type we will know not to search above
917 // it if it doesn't derive from static_type.
918 if (is_dst_type_derived_from_static_type)
919 info->is_dst_type_derived_from_static_type = yes;
920 else
921 info->is_dst_type_derived_from_static_type = no;
922 }
923 if (!does_dst_type_point_to_our_static_type)
924 {
925 // We found a dst_type that doesn't point to (static_ptr, static_type)
926 // So record the address of this dst_ptr and increment the
927 // count of the number of such dst_types found in the tree.
928 info->dst_ptr_not_leading_to_static_ptr = current_ptr;
929 info->number_to_dst_ptr += 1;
930 // If there exists another dst with a private path to
931 // (static_ptr, static_type), then the cast from
932 // (dynamic_ptr, dynamic_type) to dst_type is now ambiguous,
933 // so stop search.
934 if (info->number_to_static_ptr == 1 &&
935 info->path_dst_ptr_to_static_ptr == not_public_path)
936 info->search_done = true;
937 }
938 }
939 }
940 else
941 {
942 // This is not a static_type and not a dst_type.
943 const Iter e = __base_info + __base_count;
944 Iter p = __base_info;
945 p->search_below_dst(info, current_ptr, path_below, use_strcmp);
946 if (++p < e)
947 {
948 if ((__flags & __diamond_shaped_mask) || info->number_to_static_ptr == 1)
949 {
950 // If there are multiple paths to a base above from here, or if
951 // a dst_type pointing to (static_ptr, static_type) has been found,
952 // then there is no way to break out of this loop early unless
953 // something below detects the search is done.
954 do
955 {
956 if (info->search_done)
957 break;
958 p->search_below_dst(info, current_ptr, path_below, use_strcmp);
959 } while (++p < e);
960 }
961 else if (__flags & __non_diamond_repeat_mask)
962 {
963 // There are not multiple paths to any base class from here and a
964 // dst_type pointing to (static_ptr, static_type) has not yet been
965 // found.
966 do
967 {
968 if (info->search_done)
969 break;
970 // If we just found a dst_type with a public path to (static_ptr, static_type),
971 // then the only reason to continue the search is to make sure
972 // no other dst_type points to (static_ptr, static_type).
973 // If !diamond, then we don't need to search here.
974 if (info->number_to_static_ptr == 1 &&
975 info->path_dst_ptr_to_static_ptr == public_path)
976 break;
977 p->search_below_dst(info, current_ptr, path_below, use_strcmp);
978 } while (++p < e);
979 }
980 else
981 {
982 // There are no repeated types above this node.
983 // There are no nodes with multiple parents above this node.
984 // no dst_type has been found to (static_ptr, static_type)
985 do
986 {
987 if (info->search_done)
988 break;
989 // If we just found a dst_type with a public path to (static_ptr, static_type),
990 // then the only reason to continue the search is to make sure sure
991 // no other dst_type points to (static_ptr, static_type).
992 // If !diamond, then we don't need to search here.
993 // if we just found a dst_type with a private path to (static_ptr, static_type),
994 // then we're only looking for a public path to (static_ptr, static_type)
995 // and to check for other dst_types.
996 // If !diamond & !repeat, then there is not a pointer to (static_ptr, static_type)
997 // and not a dst_type under here.
998 if (info->number_to_static_ptr == 1)
999 break;
1000 p->search_below_dst(info, current_ptr, path_below, use_strcmp);
1001 } while (++p < e);
1002 }
1003 }
1004 }
1005 }
1006
1007 // This is the same algorithm as __vmi_class_type_info::search_below_dst but
1008 // simplified to the case that there is only a single base class.
1009 void
search_below_dst(__dynamic_cast_info * info,const void * current_ptr,int path_below,bool use_strcmp) const1010 __si_class_type_info::search_below_dst(__dynamic_cast_info* info,
1011 const void* current_ptr,
1012 int path_below,
1013 bool use_strcmp) const
1014 {
1015 if (is_equal(this, info->static_type, use_strcmp))
1016 process_static_type_below_dst(info, current_ptr, path_below);
1017 else if (is_equal(this, info->dst_type, use_strcmp))
1018 {
1019 // We've been here before if we've recorded current_ptr in one of these
1020 // two places:
1021 if (current_ptr == info->dst_ptr_leading_to_static_ptr ||
1022 current_ptr == info->dst_ptr_not_leading_to_static_ptr)
1023 {
1024 // We've seen this node before, and therefore have already searched
1025 // its base classes above.
1026 // Update path to here that is "most public".
1027 if (path_below == public_path)
1028 info->path_dynamic_ptr_to_dst_ptr = public_path;
1029 }
1030 else // We have haven't been here before
1031 {
1032 // Record the access path that got us here
1033 // If there is more than one dst_type this path doesn't matter.
1034 info->path_dynamic_ptr_to_dst_ptr = path_below;
1035 bool does_dst_type_point_to_our_static_type = false;
1036 // Only search above here if dst_type derives from static_type, or
1037 // if it is unknown if dst_type derives from static_type.
1038 if (info->is_dst_type_derived_from_static_type != no)
1039 {
1040 // Set up flags to record results from all base classes
1041 bool is_dst_type_derived_from_static_type = false;
1042 // Zero out found flags
1043 info->found_our_static_ptr = false;
1044 info->found_any_static_type = false;
1045 __base_type->search_above_dst(info, current_ptr, current_ptr, public_path, use_strcmp);
1046 if (info->found_any_static_type)
1047 {
1048 is_dst_type_derived_from_static_type = true;
1049 if (info->found_our_static_ptr)
1050 does_dst_type_point_to_our_static_type = true;
1051 }
1052 // If we found no static_type,s then dst_type doesn't derive
1053 // from static_type, else it does. Record this result so that
1054 // next time we hit a dst_type we will know not to search above
1055 // it if it doesn't derive from static_type.
1056 if (is_dst_type_derived_from_static_type)
1057 info->is_dst_type_derived_from_static_type = yes;
1058 else
1059 info->is_dst_type_derived_from_static_type = no;
1060 }
1061 if (!does_dst_type_point_to_our_static_type)
1062 {
1063 // We found a dst_type that doesn't point to (static_ptr, static_type)
1064 // So record the address of this dst_ptr and increment the
1065 // count of the number of such dst_types found in the tree.
1066 info->dst_ptr_not_leading_to_static_ptr = current_ptr;
1067 info->number_to_dst_ptr += 1;
1068 // If there exists another dst with a private path to
1069 // (static_ptr, static_type), then the cast from
1070 // (dynamic_ptr, dynamic_type) to dst_type is now ambiguous.
1071 if (info->number_to_static_ptr == 1 &&
1072 info->path_dst_ptr_to_static_ptr == not_public_path)
1073 info->search_done = true;
1074 }
1075 }
1076 }
1077 else
1078 {
1079 // This is not a static_type and not a dst_type
1080 __base_type->search_below_dst(info, current_ptr, path_below, use_strcmp);
1081 }
1082 }
1083
1084 // This is the same algorithm as __vmi_class_type_info::search_below_dst but
1085 // simplified to the case that there is no base class.
1086 void
search_below_dst(__dynamic_cast_info * info,const void * current_ptr,int path_below,bool use_strcmp) const1087 __class_type_info::search_below_dst(__dynamic_cast_info* info,
1088 const void* current_ptr,
1089 int path_below,
1090 bool use_strcmp) const
1091 {
1092 if (is_equal(this, info->static_type, use_strcmp))
1093 process_static_type_below_dst(info, current_ptr, path_below);
1094 else if (is_equal(this, info->dst_type, use_strcmp))
1095 {
1096 // We've been here before if we've recorded current_ptr in one of these
1097 // two places:
1098 if (current_ptr == info->dst_ptr_leading_to_static_ptr ||
1099 current_ptr == info->dst_ptr_not_leading_to_static_ptr)
1100 {
1101 // We've seen this node before, and therefore have already searched
1102 // its base classes above.
1103 // Update path to here that is "most public".
1104 if (path_below == public_path)
1105 info->path_dynamic_ptr_to_dst_ptr = public_path;
1106 }
1107 else // We have haven't been here before
1108 {
1109 // Record the access path that got us here
1110 // If there is more than one dst_type this path doesn't matter.
1111 info->path_dynamic_ptr_to_dst_ptr = path_below;
1112 // We found a dst_type that doesn't point to (static_ptr, static_type)
1113 // So record the address of this dst_ptr and increment the
1114 // count of the number of such dst_types found in the tree.
1115 info->dst_ptr_not_leading_to_static_ptr = current_ptr;
1116 info->number_to_dst_ptr += 1;
1117 // If there exists another dst with a private path to
1118 // (static_ptr, static_type), then the cast from
1119 // (dynamic_ptr, dynamic_type) to dst_type is now ambiguous.
1120 if (info->number_to_static_ptr == 1 &&
1121 info->path_dst_ptr_to_static_ptr == not_public_path)
1122 info->search_done = true;
1123 // We found that dst_type does not derive from static_type
1124 info->is_dst_type_derived_from_static_type = no;
1125 }
1126 }
1127 }
1128
1129 // Call this function when searching above a dst_type node. This function searches
1130 // for a public path to (static_ptr, static_type).
1131 // This function is guaranteed not to find a node of type dst_type.
1132 // Theoretically this is a very simple function which just stops if it finds a
1133 // static_type node: All the hoopla surrounding the search code is doing
1134 // nothing but looking for excuses to stop the search prematurely (break out of
1135 // the for-loop). That is, the algorithm below is simply an optimization of this:
1136 // void
1137 // __vmi_class_type_info::search_above_dst(__dynamic_cast_info* info,
1138 // const void* dst_ptr,
1139 // const void* current_ptr,
1140 // int path_below) const
1141 // {
1142 // if (this == info->static_type)
1143 // process_static_type_above_dst(info, dst_ptr, current_ptr, path_below);
1144 // else
1145 // {
1146 // typedef const __base_class_type_info* Iter;
1147 // // This is not a static_type and not a dst_type
1148 // for (Iter p = __base_info, e = __base_info + __base_count; p < e; ++p)
1149 // {
1150 // p->search_above_dst(info, dst_ptr, current_ptr, public_path);
1151 // // break out early here if you can detect it doesn't matter if you do
1152 // }
1153 // }
1154 // }
1155 void
search_above_dst(__dynamic_cast_info * info,const void * dst_ptr,const void * current_ptr,int path_below,bool use_strcmp) const1156 __vmi_class_type_info::search_above_dst(__dynamic_cast_info* info,
1157 const void* dst_ptr,
1158 const void* current_ptr,
1159 int path_below,
1160 bool use_strcmp) const
1161 {
1162 if (is_equal(this, info->static_type, use_strcmp))
1163 process_static_type_above_dst(info, dst_ptr, current_ptr, path_below);
1164 else
1165 {
1166 typedef const __base_class_type_info* Iter;
1167 // This is not a static_type and not a dst_type
1168 // Save flags so they can be restored when returning to nodes below.
1169 bool found_our_static_ptr = info->found_our_static_ptr;
1170 bool found_any_static_type = info->found_any_static_type;
1171 // We've found a dst_type below with a path to here. If the path
1172 // to here is not public, there may be another path to here that
1173 // is public. So we have to assume that the path to here is public.
1174 // We can stop looking above if:
1175 // 1. We've found a public path to (static_ptr, static_type).
1176 // 2. We've found an ambiguous cast from (static_ptr, static_type) to a dst_type.
1177 // This is detected at the (static_ptr, static_type).
1178 // 3. We can prove that there is no public path to (static_ptr, static_type)
1179 // above here.
1180 const Iter e = __base_info + __base_count;
1181 Iter p = __base_info;
1182 // Zero out found flags
1183 info->found_our_static_ptr = false;
1184 info->found_any_static_type = false;
1185 p->search_above_dst(info, dst_ptr, current_ptr, path_below, use_strcmp);
1186 found_our_static_ptr |= info->found_our_static_ptr;
1187 found_any_static_type |= info->found_any_static_type;
1188 if (++p < e)
1189 {
1190 do
1191 {
1192 if (info->search_done)
1193 break;
1194 if (info->found_our_static_ptr)
1195 {
1196 // If we found what we're looking for, stop looking above.
1197 if (info->path_dst_ptr_to_static_ptr == public_path)
1198 break;
1199 // We found a private path to (static_ptr, static_type)
1200 // If there is no diamond then there is only one path
1201 // to (static_ptr, static_type) from here and we just found it.
1202 if (!(__flags & __diamond_shaped_mask))
1203 break;
1204 }
1205 else if (info->found_any_static_type)
1206 {
1207 // If we found a static_type that isn't the one we're looking
1208 // for, and if there are no repeated types above here,
1209 // then stop looking.
1210 if (!(__flags & __non_diamond_repeat_mask))
1211 break;
1212 }
1213 // Zero out found flags
1214 info->found_our_static_ptr = false;
1215 info->found_any_static_type = false;
1216 p->search_above_dst(info, dst_ptr, current_ptr, path_below, use_strcmp);
1217 found_our_static_ptr |= info->found_our_static_ptr;
1218 found_any_static_type |= info->found_any_static_type;
1219 } while (++p < e);
1220 }
1221 // Restore flags
1222 info->found_our_static_ptr = found_our_static_ptr;
1223 info->found_any_static_type = found_any_static_type;
1224 }
1225 }
1226
1227 // This is the same algorithm as __vmi_class_type_info::search_above_dst but
1228 // simplified to the case that there is only a single base class.
1229 void
search_above_dst(__dynamic_cast_info * info,const void * dst_ptr,const void * current_ptr,int path_below,bool use_strcmp) const1230 __si_class_type_info::search_above_dst(__dynamic_cast_info* info,
1231 const void* dst_ptr,
1232 const void* current_ptr,
1233 int path_below,
1234 bool use_strcmp) const
1235 {
1236 if (is_equal(this, info->static_type, use_strcmp))
1237 process_static_type_above_dst(info, dst_ptr, current_ptr, path_below);
1238 else
1239 __base_type->search_above_dst(info, dst_ptr, current_ptr, path_below, use_strcmp);
1240 }
1241
1242 // This is the same algorithm as __vmi_class_type_info::search_above_dst but
1243 // simplified to the case that there is no base class.
1244 void
search_above_dst(__dynamic_cast_info * info,const void * dst_ptr,const void * current_ptr,int path_below,bool use_strcmp) const1245 __class_type_info::search_above_dst(__dynamic_cast_info* info,
1246 const void* dst_ptr,
1247 const void* current_ptr,
1248 int path_below,
1249 bool use_strcmp) const
1250 {
1251 if (is_equal(this, info->static_type, use_strcmp))
1252 process_static_type_above_dst(info, dst_ptr, current_ptr, path_below);
1253 }
1254
1255 // The search functions for __base_class_type_info are simply convenience
1256 // functions for adjusting the current_ptr and path_below as the search is
1257 // passed up to the base class node.
1258
1259 void
search_above_dst(__dynamic_cast_info * info,const void * dst_ptr,const void * current_ptr,int path_below,bool use_strcmp) const1260 __base_class_type_info::search_above_dst(__dynamic_cast_info* info,
1261 const void* dst_ptr,
1262 const void* current_ptr,
1263 int path_below,
1264 bool use_strcmp) const
1265 {
1266 ptrdiff_t offset_to_base = __offset_flags >> __offset_shift;
1267 if (__offset_flags & __virtual_mask)
1268 {
1269 const char* vtable = *static_cast<const char*const*>(current_ptr);
1270 offset_to_base = *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
1271 }
1272 __base_type->search_above_dst(info, dst_ptr,
1273 static_cast<const char*>(current_ptr) + offset_to_base,
1274 (__offset_flags & __public_mask) ?
1275 path_below :
1276 not_public_path,
1277 use_strcmp);
1278 }
1279
1280 void
search_below_dst(__dynamic_cast_info * info,const void * current_ptr,int path_below,bool use_strcmp) const1281 __base_class_type_info::search_below_dst(__dynamic_cast_info* info,
1282 const void* current_ptr,
1283 int path_below,
1284 bool use_strcmp) const
1285 {
1286 ptrdiff_t offset_to_base = __offset_flags >> __offset_shift;
1287 if (__offset_flags & __virtual_mask)
1288 {
1289 const char* vtable = *static_cast<const char*const*>(current_ptr);
1290 offset_to_base = *reinterpret_cast<const ptrdiff_t*>(vtable + offset_to_base);
1291 }
1292 __base_type->search_below_dst(info,
1293 static_cast<const char*>(current_ptr) + offset_to_base,
1294 (__offset_flags & __public_mask) ?
1295 path_below :
1296 not_public_path,
1297 use_strcmp);
1298 }
1299
1300 } // __cxxabiv1
1301