OSDN Git Service

c28217659461c704539f36f37fea380ac3372131
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / libsupc++ / tinfo.cc
1 // Methods for type_info for -*- C++ -*- Run Time Type Identification.
2 // Copyright (C) 1994, 1996, 1998, 1999, 2000, 2001, 2002, 2003
3 // Free Software Foundation
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 2, 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 // You should have received a copy of the GNU General Public License
18 // along with GCC; see the file COPYING.  If not, write to
19 // the Free Software Foundation, 59 Temple Place - Suite 330,
20 // Boston, MA 02111-1307, USA. 
21
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 #include <bits/c++config.h>
32 #include <cstddef>
33 #include "tinfo.h"
34 #include "new"                  // for placement new
35
36 // This file contains the minimal working set necessary to link with code
37 // that uses virtual functions and -frtti but does not actually use RTTI
38 // functionality.
39
40 std::type_info::
41 ~type_info ()
42 { }
43
44 std::bad_cast::~bad_cast() throw() { }
45 std::bad_typeid::~bad_typeid() throw() { }
46
47 #if !__GXX_MERGED_TYPEINFO_NAMES
48
49 // We can't rely on common symbols being shared between shared objects.
50 bool std::type_info::
51 operator== (const std::type_info& arg) const
52 {
53   return (&arg == this) || (__builtin_strcmp (name (), arg.name ()) == 0);
54 }
55
56 #endif
57
58 namespace std {
59
60 // return true if this is a type_info for a pointer type
61 bool type_info::
62 __is_pointer_p () const
63 {
64   return false;
65 }
66
67 // return true if this is a type_info for a function type
68 bool type_info::
69 __is_function_p () const
70 {
71   return false;
72 }
73
74 // try and catch a thrown object.
75 bool type_info::
76 __do_catch (const type_info *thr_type, void **, unsigned) const
77 {
78   return *this == *thr_type;
79 }
80
81 // upcast from this type to the target. __class_type_info will override
82 bool type_info::
83 __do_upcast (const abi::__class_type_info *, void **) const
84 {
85   return false;
86 }
87
88 }
89
90 namespace {
91
92 using namespace std;
93 using namespace abi;
94
95 // Initial part of a vtable, this structure is used with offsetof, so we don't
96 // have to keep alignments consistent manually.
97 struct vtable_prefix 
98 {
99   // Offset to most derived object.
100   ptrdiff_t whole_object;
101
102   // Additional padding if necessary.
103 #ifdef _GLIBCXX_VTABLE_PADDING
104   ptrdiff_t padding1;               
105 #endif
106
107   // Pointer to most derived type_info.
108   const __class_type_info *whole_type;  
109
110   // Additional padding if necessary.
111 #ifdef _GLIBCXX_VTABLE_PADDING
112   ptrdiff_t padding2;               
113 #endif
114
115   // What a class's vptr points to.
116   const void *origin;               
117 };
118
119 template <typename T>
120 inline const T *
121 adjust_pointer (const void *base, ptrdiff_t offset)
122 {
123   return reinterpret_cast <const T *>
124     (reinterpret_cast <const char *> (base) + offset);
125 }
126
127 // ADDR is a pointer to an object.  Convert it to a pointer to a base,
128 // using OFFSET. IS_VIRTUAL is true, if we are getting a virtual base.
129 inline void const *
130 convert_to_base (void const *addr, bool is_virtual, ptrdiff_t offset)
131 {
132   if (is_virtual)
133     {
134       const void *vtable = *static_cast <const void *const *> (addr);
135       
136       offset = *adjust_pointer<ptrdiff_t> (vtable, offset);
137     }
138
139   return adjust_pointer<void> (addr, offset);
140 }
141
142 // some predicate functions for __class_type_info::__sub_kind
143 inline bool contained_p (__class_type_info::__sub_kind access_path)
144 {
145   return access_path >= __class_type_info::__contained_mask;
146 }
147 inline bool public_p (__class_type_info::__sub_kind access_path)
148 {
149   return access_path & __class_type_info::__contained_public_mask;
150 }
151 inline bool virtual_p (__class_type_info::__sub_kind access_path)
152 {
153   return (access_path & __class_type_info::__contained_virtual_mask);
154 }
155 inline bool contained_public_p (__class_type_info::__sub_kind access_path)
156 {
157   return ((access_path & __class_type_info::__contained_public)
158           == __class_type_info::__contained_public);
159 }
160 inline bool contained_nonpublic_p (__class_type_info::__sub_kind access_path)
161 {
162   return ((access_path & __class_type_info::__contained_public)
163           == __class_type_info::__contained_mask);
164 }
165 inline bool contained_nonvirtual_p (__class_type_info::__sub_kind access_path)
166 {
167   return ((access_path & (__class_type_info::__contained_mask
168                           | __class_type_info::__contained_virtual_mask))
169           == __class_type_info::__contained_mask);
170 }
171
172 static const __class_type_info *const nonvirtual_base_type =
173     static_cast <const __class_type_info *> (0) + 1;
174
175 } // namespace
176
177 namespace __cxxabiv1
178 {
179
180 __class_type_info::
181 ~__class_type_info ()
182 {}
183
184 __si_class_type_info::
185 ~__si_class_type_info ()
186 {}
187
188 __vmi_class_type_info::
189 ~__vmi_class_type_info ()
190 {}
191
192 // __upcast_result is used to hold information during traversal of a class
193 // hierarchy when catch matching.
194 struct __class_type_info::__upcast_result
195 {
196   const void *dst_ptr;        // pointer to caught object
197   __sub_kind part2dst;        // path from current base to target
198   int src_details;            // hints about the source type hierarchy
199   const __class_type_info *base_type; // where we found the target,
200                               // if in vbase the __class_type_info of vbase
201                               // if a non-virtual base then 1
202                               // else NULL
203   public:
204   __upcast_result (int d)
205     :dst_ptr (NULL), part2dst (__unknown), src_details (d), base_type (NULL)
206     {}
207 };
208
209 // __dyncast_result is used to hold information during traversal of a class
210 // hierarchy when dynamic casting.
211 struct __class_type_info::__dyncast_result
212 {
213   const void *dst_ptr;        // pointer to target object or NULL
214   __sub_kind whole2dst;       // path from most derived object to target
215   __sub_kind whole2src;       // path from most derived object to sub object
216   __sub_kind dst2src;         // path from target to sub object
217   int whole_details;          // details of the whole class hierarchy
218   
219   public:
220   __dyncast_result (int details_ = __vmi_class_type_info::__flags_unknown_mask)
221     :dst_ptr (NULL), whole2dst (__unknown),
222      whole2src (__unknown), dst2src (__unknown),
223      whole_details (details_)
224     {}
225 };
226
227 bool __class_type_info::
228 __do_catch (const type_info *thr_type,
229             void **thr_obj,
230             unsigned outer) const
231 {
232   if (*this == *thr_type)
233     return true;
234   if (outer >= 4)
235     // Neither `A' nor `A *'.
236     return false;
237   return thr_type->__do_upcast (this, thr_obj);
238 }
239
240 bool __class_type_info::
241 __do_upcast (const __class_type_info *dst_type,
242              void **obj_ptr) const
243 {
244   __upcast_result result (__vmi_class_type_info::__flags_unknown_mask);
245   
246   __do_upcast (dst_type, *obj_ptr, result);
247   if (!contained_public_p (result.part2dst))
248     return false;
249   *obj_ptr = const_cast <void *> (result.dst_ptr);
250   return true;
251 }
252
253 inline __class_type_info::__sub_kind __class_type_info::
254 __find_public_src (ptrdiff_t src2dst,
255                    const void *obj_ptr,
256                    const __class_type_info *src_type,
257                    const void *src_ptr) const
258 {
259   if (src2dst >= 0)
260     return adjust_pointer <void> (obj_ptr, src2dst) == src_ptr
261             ? __contained_public : __not_contained;
262   if (src2dst == -2)
263     return __not_contained;
264   return __do_find_public_src (src2dst, obj_ptr, src_type, src_ptr);
265 }
266
267 __class_type_info::__sub_kind __class_type_info::
268 __do_find_public_src (ptrdiff_t,
269                       const void *obj_ptr,
270                       const __class_type_info *,
271                       const void *src_ptr) const
272 {
273   if (src_ptr == obj_ptr)
274     // Must be our type, as the pointers match.
275     return __contained_public;
276   return __not_contained;
277 }
278
279 __class_type_info::__sub_kind __si_class_type_info::
280 __do_find_public_src (ptrdiff_t src2dst,
281                       const void *obj_ptr,
282                       const __class_type_info *src_type,
283                       const void *src_ptr) const
284 {
285   if (src_ptr == obj_ptr && *this == *src_type)
286     return __contained_public;
287   return __base_type->__do_find_public_src (src2dst, obj_ptr, src_type, src_ptr);
288 }
289
290 __class_type_info::__sub_kind __vmi_class_type_info::
291 __do_find_public_src (ptrdiff_t src2dst,
292                       const void *obj_ptr,
293                       const __class_type_info *src_type,
294                       const void *src_ptr) const
295 {
296   if (obj_ptr == src_ptr && *this == *src_type)
297     return __contained_public;
298   
299   for (std::size_t i = __base_count; i--;)
300     {
301       if (!__base_info[i].__is_public_p ())
302         continue; // Not public, can't be here.
303       
304       const void *base = obj_ptr;
305       ptrdiff_t offset = __base_info[i].__offset ();
306       bool is_virtual = __base_info[i].__is_virtual_p ();
307       
308       if (is_virtual)
309         {
310           if (src2dst == -3)
311             continue; // Not a virtual base, so can't be here.
312         }
313       base = convert_to_base (base, is_virtual, offset);
314       
315       __sub_kind base_kind = __base_info[i].__base_type->__do_find_public_src
316                               (src2dst, base, src_type, src_ptr);
317       if (contained_p (base_kind))
318         {
319           if (is_virtual)
320             base_kind = __sub_kind (base_kind | __contained_virtual_mask);
321           return base_kind;
322         }
323     }
324   
325   return __not_contained;
326 }
327
328 bool __class_type_info::
329 __do_dyncast (ptrdiff_t,
330               __sub_kind access_path,
331               const __class_type_info *dst_type,
332               const void *obj_ptr,
333               const __class_type_info *src_type,
334               const void *src_ptr,
335               __dyncast_result &__restrict result) const
336 {
337   if (obj_ptr == src_ptr && *this == *src_type)
338     {
339       // The src object we started from. Indicate how we are accessible from
340       // the most derived object.
341       result.whole2src = access_path;
342       return false;
343     }
344   if (*this == *dst_type)
345     {
346       result.dst_ptr = obj_ptr;
347       result.whole2dst = access_path;
348       result.dst2src = __not_contained;
349       return false;
350     }
351   return false;
352 }
353
354 bool __si_class_type_info::
355 __do_dyncast (ptrdiff_t src2dst,
356               __sub_kind access_path,
357               const __class_type_info *dst_type,
358               const void *obj_ptr,
359               const __class_type_info *src_type,
360               const void *src_ptr,
361               __dyncast_result &__restrict result) const
362 {
363   if (*this == *dst_type)
364     {
365       result.dst_ptr = obj_ptr;
366       result.whole2dst = access_path;
367       if (src2dst >= 0)
368         result.dst2src = adjust_pointer <void> (obj_ptr, src2dst) == src_ptr
369               ? __contained_public : __not_contained;
370       else if (src2dst == -2)
371         result.dst2src = __not_contained;
372       return false;
373     }
374   if (obj_ptr == src_ptr && *this == *src_type)
375     {
376       // The src object we started from. Indicate how we are accessible from
377       // the most derived object.
378       result.whole2src = access_path;
379       return false;
380     }
381   return __base_type->__do_dyncast (src2dst, access_path, dst_type, obj_ptr,
382                              src_type, src_ptr, result);
383 }
384
385 // This is a big hairy function. Although the run-time behaviour of
386 // dynamic_cast is simple to describe, it gives rise to some non-obvious
387 // behaviour. We also desire to determine as early as possible any definite
388 // answer we can get. Because it is unknown what the run-time ratio of
389 // succeeding to failing dynamic casts is, we do not know in which direction
390 // to bias any optimizations. To that end we make no particular effort towards
391 // early fail answers or early success answers. Instead we try to minimize
392 // work by filling in things lazily (when we know we need the information),
393 // and opportunisticly take early success or failure results.
394 bool __vmi_class_type_info::
395 __do_dyncast (ptrdiff_t src2dst,
396               __sub_kind access_path,
397               const __class_type_info *dst_type,
398               const void *obj_ptr,
399               const __class_type_info *src_type,
400               const void *src_ptr,
401               __dyncast_result &__restrict result) const
402 {
403   if (result.whole_details & __flags_unknown_mask)
404     result.whole_details = __flags;
405   
406   if (obj_ptr == src_ptr && *this == *src_type)
407     {
408       // The src object we started from. Indicate how we are accessible from
409       // the most derived object.
410       result.whole2src = access_path;
411       return false;
412     }
413   if (*this == *dst_type)
414     {
415       result.dst_ptr = obj_ptr;
416       result.whole2dst = access_path;
417       if (src2dst >= 0)
418         result.dst2src = adjust_pointer <void> (obj_ptr, src2dst) == src_ptr
419               ? __contained_public : __not_contained;
420       else if (src2dst == -2)
421         result.dst2src = __not_contained;
422       return false;
423     }
424
425   bool result_ambig = false;
426   for (std::size_t i = __base_count; i--;)
427     {
428       __dyncast_result result2 (result.whole_details);
429       void const *base = obj_ptr;
430       __sub_kind base_access = access_path;
431       ptrdiff_t offset = __base_info[i].__offset ();
432       bool is_virtual = __base_info[i].__is_virtual_p ();
433       
434       if (is_virtual)
435         base_access = __sub_kind (base_access | __contained_virtual_mask);
436       base = convert_to_base (base, is_virtual, offset);
437
438       if (!__base_info[i].__is_public_p ())
439         {
440           if (src2dst == -2 &&
441               !(result.whole_details
442                 & (__non_diamond_repeat_mask | __diamond_shaped_mask)))
443             // The hierarchy has no duplicate bases (which might ambiguate
444             // things) and where we started is not a public base of what we
445             // want (so it cannot be a downcast). There is nothing of interest
446             // hiding in a non-public base.
447             continue;
448           base_access = __sub_kind (base_access & ~__contained_public_mask);
449         }
450       
451       bool result2_ambig
452           = __base_info[i].__base_type->__do_dyncast (src2dst, base_access,
453                                              dst_type, base,
454                                              src_type, src_ptr, result2);
455       result.whole2src = __sub_kind (result.whole2src | result2.whole2src);
456       if (result2.dst2src == __contained_public
457           || result2.dst2src == __contained_ambig)
458         {
459           result.dst_ptr = result2.dst_ptr;
460           result.whole2dst = result2.whole2dst;
461           result.dst2src = result2.dst2src;
462           // Found a downcast which can't be bettered or an ambiguous downcast
463           // which can't be disambiguated
464           return result2_ambig;
465         }
466       
467       if (!result_ambig && !result.dst_ptr)
468         {
469           // Not found anything yet.
470           result.dst_ptr = result2.dst_ptr;
471           result.whole2dst = result2.whole2dst;
472           result_ambig = result2_ambig;
473           if (result.dst_ptr && result.whole2src != __unknown
474               && !(__flags & __non_diamond_repeat_mask))
475             // Found dst and src and we don't have repeated bases.
476             return result_ambig;
477         }
478       else if (result.dst_ptr && result.dst_ptr == result2.dst_ptr)
479         {
480           // Found at same address, must be via virtual.  Pick the most
481           // accessible path.
482           result.whole2dst =
483               __sub_kind (result.whole2dst | result2.whole2dst);
484         }
485       else if ((result.dst_ptr != 0 & result2.dst_ptr != 0)
486                || (result.dst_ptr != 0 & result2_ambig)
487                || (result2.dst_ptr != 0 & result_ambig))
488         {
489           // Found two different DST_TYPE bases, or a valid one and a set of
490           // ambiguous ones, must disambiguate. See whether SRC_PTR is
491           // contained publicly within one of the non-ambiguous choices. If it
492           // is in only one, then that's the choice. If it is in both, then
493           // we're ambiguous and fail. If it is in neither, we're ambiguous,
494           // but don't yet fail as we might later find a third base which does
495           // contain SRC_PTR.
496         
497           __sub_kind new_sub_kind = result2.dst2src;
498           __sub_kind old_sub_kind = result.dst2src;
499           
500           if (contained_p (result.whole2src)
501               && (!virtual_p (result.whole2src)
502                   || !(result.whole_details & __diamond_shaped_mask)))
503             {
504               // We already found SRC_PTR as a base of most derived, and
505               // either it was non-virtual, or the whole hierarchy is
506               // not-diamond shaped. Therefore if it is in either choice, it
507               // can only be in one of them, and we will already know.
508               if (old_sub_kind == __unknown)
509                 old_sub_kind = __not_contained;
510               if (new_sub_kind == __unknown)
511                 new_sub_kind = __not_contained;
512             }
513           else
514             {
515               if (old_sub_kind >= __not_contained)
516                 ;// already calculated
517               else if (contained_p (new_sub_kind)
518                        && (!virtual_p (new_sub_kind)
519                            || !(__flags & __diamond_shaped_mask)))
520                 // Already found inside the other choice, and it was
521                 // non-virtual or we are not diamond shaped.
522                 old_sub_kind = __not_contained;
523               else
524                 old_sub_kind = dst_type->__find_public_src
525                                 (src2dst, result.dst_ptr, src_type, src_ptr);
526           
527               if (new_sub_kind >= __not_contained)
528                 ;// already calculated
529               else if (contained_p (old_sub_kind)
530                        && (!virtual_p (old_sub_kind)
531                            || !(__flags & __diamond_shaped_mask)))
532                 // Already found inside the other choice, and it was
533                 // non-virtual or we are not diamond shaped.
534                 new_sub_kind = __not_contained;
535               else
536                 new_sub_kind = dst_type->__find_public_src
537                                 (src2dst, result2.dst_ptr, src_type, src_ptr);
538             }
539           
540           // Neither sub_kind can be contained_ambig -- we bail out early
541           // when we find those.
542           if (contained_p (__sub_kind (new_sub_kind ^ old_sub_kind)))
543             {
544               // Only on one choice, not ambiguous.
545               if (contained_p (new_sub_kind))
546                 {
547                   // Only in new.
548                   result.dst_ptr = result2.dst_ptr;
549                   result.whole2dst = result2.whole2dst;
550                   result_ambig = false;
551                   old_sub_kind = new_sub_kind;
552                 }
553               result.dst2src = old_sub_kind;
554               if (public_p (result.dst2src))
555                 return false; // Can't be an ambiguating downcast for later discovery.
556               if (!virtual_p (result.dst2src))
557                 return false; // Found non-virtually can't be bettered
558             }
559           else if (contained_p (__sub_kind (new_sub_kind & old_sub_kind)))
560             {
561               // In both.
562               result.dst_ptr = NULL;
563               result.dst2src = __contained_ambig;
564               return true;  // Fail.
565             }
566           else
567             {
568               // In neither publicly, ambiguous for the moment, but keep
569               // looking. It is possible that it was private in one or
570               // both and therefore we should fail, but that's just tough.
571               result.dst_ptr = NULL;
572               result.dst2src = __not_contained;
573               result_ambig = true;
574             }
575         }
576       
577       if (result.whole2src == __contained_private)
578         // We found SRC_PTR as a private non-virtual base, therefore all
579         // cross casts will fail. We have already found a down cast, if
580         // there is one.
581         return result_ambig;
582     }
583
584   return result_ambig;
585 }
586
587 bool __class_type_info::
588 __do_upcast (const __class_type_info *dst, const void *obj,
589              __upcast_result &__restrict result) const
590 {
591   if (*this == *dst)
592     {
593       result.dst_ptr = obj;
594       result.base_type = nonvirtual_base_type;
595       result.part2dst = __contained_public;
596       return true;
597     }
598   return false;
599 }
600
601 bool __si_class_type_info::
602 __do_upcast (const __class_type_info *dst, const void *obj_ptr,
603              __upcast_result &__restrict result) const
604 {
605   if (__class_type_info::__do_upcast (dst, obj_ptr, result))
606     return true;
607   
608   return __base_type->__do_upcast (dst, obj_ptr, result);
609 }
610
611 bool __vmi_class_type_info::
612 __do_upcast (const __class_type_info *dst, const void *obj_ptr,
613              __upcast_result &__restrict result) const
614 {
615   if (__class_type_info::__do_upcast (dst, obj_ptr, result))
616     return true;
617   
618   int src_details = result.src_details;
619   if (src_details & __flags_unknown_mask)
620     src_details = __flags;
621   
622   for (std::size_t i = __base_count; i--;)
623     {
624       __upcast_result result2 (src_details);
625       const void *base = obj_ptr;
626       ptrdiff_t offset = __base_info[i].__offset ();
627       bool is_virtual = __base_info[i].__is_virtual_p ();
628       bool is_public = __base_info[i].__is_public_p ();
629       
630       if (!is_public && !(src_details & __non_diamond_repeat_mask))
631         // original cannot have an ambiguous base, so skip private bases
632         continue;
633
634       if (base)
635         base = convert_to_base (base, is_virtual, offset);
636       
637       if (__base_info[i].__base_type->__do_upcast (dst, base, result2))
638         {
639           if (result2.base_type == nonvirtual_base_type && is_virtual)
640             result2.base_type = __base_info[i].__base_type;
641           if (contained_p (result2.part2dst) && !is_public)
642             result2.part2dst = __sub_kind (result2.part2dst & ~__contained_public_mask);
643           
644           if (!result.base_type)
645             {
646               result = result2;
647               if (!contained_p (result.part2dst))
648                 return true; // found ambiguously
649               
650               if (result.part2dst & __contained_public_mask)
651                 {
652                   if (!(__flags & __non_diamond_repeat_mask))
653                     return true;  // cannot have an ambiguous other base
654                 }
655               else
656                 {
657                   if (!virtual_p (result.part2dst))
658                     return true; // cannot have another path
659                   if (!(__flags & __diamond_shaped_mask))
660                     return true; // cannot have a more accessible path
661                 }
662             }
663           else if (result.dst_ptr != result2.dst_ptr)
664             {
665               // Found an ambiguity.
666               result.dst_ptr = NULL;
667               result.part2dst = __contained_ambig;
668               return true;
669             }
670           else if (result.dst_ptr)
671             {
672               // Ok, found real object via a virtual path.
673               result.part2dst
674                   = __sub_kind (result.part2dst | result2.part2dst);
675             }
676           else
677             {
678               // Dealing with a null pointer, need to check vbase
679               // containing each of the two choices.
680               if (result2.base_type == nonvirtual_base_type
681                   || result.base_type == nonvirtual_base_type
682                   || !(*result2.base_type == *result.base_type))
683                 {
684                   // Already ambiguous, not virtual or via different virtuals.
685                   // Cannot match.
686                   result.part2dst = __contained_ambig;
687                   return true;
688                 }
689               result.part2dst
690                   = __sub_kind (result.part2dst | result2.part2dst);
691             }
692         }
693     }
694   return result.part2dst != __unknown;
695 }
696
697 // this is the external interface to the dynamic cast machinery
698 extern "C" void *
699 __dynamic_cast (const void *src_ptr,    // object started from
700                 const __class_type_info *src_type, // type of the starting object
701                 const __class_type_info *dst_type, // desired target type
702                 ptrdiff_t src2dst) // how src and dst are related
703 {
704   const void *vtable = *static_cast <const void *const *> (src_ptr);
705   const vtable_prefix *prefix =
706       adjust_pointer <vtable_prefix> (vtable, 
707                                       -offsetof (vtable_prefix, origin));
708   const void *whole_ptr =
709       adjust_pointer <void> (src_ptr, prefix->whole_object);
710   const __class_type_info *whole_type = prefix->whole_type;
711   __class_type_info::__dyncast_result result;
712   
713   whole_type->__do_dyncast (src2dst, __class_type_info::__contained_public,
714                             dst_type, whole_ptr, src_type, src_ptr, result);
715   if (!result.dst_ptr)
716     return NULL;
717   if (contained_public_p (result.dst2src))
718     // Src is known to be a public base of dst.
719     return const_cast <void *> (result.dst_ptr);
720   if (contained_public_p (__class_type_info::__sub_kind (result.whole2src & result.whole2dst)))
721     // Both src and dst are known to be public bases of whole. Found a valid
722     // cross cast.
723     return const_cast <void *> (result.dst_ptr);
724   if (contained_nonvirtual_p (result.whole2src))
725     // Src is known to be a non-public nonvirtual base of whole, and not a
726     // base of dst. Found an invalid cross cast, which cannot also be a down
727     // cast
728     return NULL;
729   if (result.dst2src == __class_type_info::__unknown)
730     result.dst2src = dst_type->__find_public_src (src2dst, result.dst_ptr,
731                                                   src_type, src_ptr);
732   if (contained_public_p (result.dst2src))
733     // Found a valid down cast
734     return const_cast <void *> (result.dst_ptr);
735   // Must be an invalid down cast, or the cross cast wasn't bettered
736   return NULL;
737 }
738
739 } // namespace __cxxabiv1