| // Copyright (C) 2011 The Android Open Source Project |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // 1. Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // 2. Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in the |
| // documentation and/or other materials provided with the distribution. |
| // 3. Neither the name of the project nor the names of its contributors |
| // may be used to endorse or promote products derived from this software |
| // without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND |
| // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| // ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| // SUCH DAMAGE. |
| // |
| // dynamic_cast.cc: RTTI support. |
| // |
| // References: |
| // Itanium C++ ABI at http://www.codesourcery.com/public/cxx-abi/abi.html |
| // IHI0041A C++ Application Binary Interface for the ARM architecture. |
| // |
| |
| #include <cxxabi.h> |
| |
| #include <cstddef> |
| #include <cassert> |
| |
| namespace |
| { |
| // Adjust a pointer by an offset. |
| |
| const void* |
| adjust_pointer(const void* p, std::ptrdiff_t off) |
| { |
| // FIXME: should we align pointer after adjustment? |
| const char *cp = reinterpret_cast<const char*>(p) + off; |
| return reinterpret_cast<const void*>(cp); |
| } |
| |
| // Return the vtable pointer of a polymorphic object pointed by p. |
| |
| inline const void* |
| get_vtable(const void* p) |
| { |
| return *reinterpret_cast<void*const*>(p); |
| } |
| |
| // Return a pointer to a __class_type_info in a vtable. |
| |
| inline const abi::__class_type_info* |
| get_class_type_info(const void* vtable) |
| { |
| const void* type_info_ptr = adjust_pointer(vtable, -sizeof(void*)); |
| return *reinterpret_cast<abi::__class_type_info*const*>(type_info_ptr); |
| } |
| |
| // Return offset to object in a vtable. |
| |
| inline std::ptrdiff_t |
| get_offset_to_top(const void* vtable) |
| { |
| const void* type_info_ptr_address = adjust_pointer(vtable, -sizeof(void*)); |
| const void* offset_to_top_address = |
| adjust_pointer(type_info_ptr_address, -sizeof(std::ptrdiff_t)); |
| return *reinterpret_cast<const std::ptrdiff_t*>(offset_to_top_address); |
| } |
| |
| // Return the virtual pointer to the most derived object of referred by a |
| // pointer p. |
| |
| const void* |
| get_most_derived_object(const void* p) |
| { |
| const void* vtable = get_vtable(p); |
| std::ptrdiff_t offset_to_top = get_offset_to_top(vtable); |
| return adjust_pointer(p, offset_to_top); |
| } |
| |
| // We assume that -1 cannot be a valid pointer to object. |
| const void * const ambiguous_object = |
| reinterpret_cast<const void*>(-1); |
| |
| // Return a pointer to the subobject described by base_info. |
| |
| const void* |
| get_subobject(const void* object, |
| const void* vtable, |
| const abi::__base_class_type_info* base_info) |
| { |
| long offset = base_info->offset(); |
| if (base_info->is_virtual()) |
| { |
| const std::ptrdiff_t* virtual_base_offset_address = |
| static_cast<const std::ptrdiff_t*> (adjust_pointer(vtable, offset)); |
| offset = *virtual_base_offset_address; |
| } |
| return adjust_pointer(object, offset); |
| } |
| |
| // Helper of __dyanmic_cast to walk the type tree of an object. |
| |
| const void * |
| walk_object(const void *object, |
| const abi::__class_type_info *type, |
| const void *match_object, |
| const abi::__class_type_info *match_type) |
| { |
| if (*type == *match_type) |
| return (match_object == NULL || object == match_object) ? object : NULL; |
| |
| switch(type->code()) |
| { |
| case abi::__class_type_info::CLASS_TYPE_INFO_CODE: |
| // This isn't not the class you're looking for. |
| return NULL; |
| |
| case abi::__class_type_info::SI_CLASS_TYPE_INFO_CODE: |
| // derived type has a single public base at offset 0. |
| { |
| const abi::__si_class_type_info* ti = |
| static_cast<const abi::__si_class_type_info*>(type); |
| return walk_object(object, ti->__base_type, match_object, |
| match_type); |
| } |
| |
| case abi::__class_type_info::VMI_CLASS_TYPE_INFO_CODE: |
| { |
| const void* vtable = get_vtable(object); |
| const abi::__vmi_class_type_info* ti = |
| static_cast<const abi::__vmi_class_type_info*>(type); |
| |
| // Look at all direct bases. |
| const void* result = NULL; |
| for (unsigned i = 0; i < ti->__base_count; ++i) |
| { |
| if (!ti->__base_info[i].is_public()) |
| continue; |
| |
| const void *subobject = |
| get_subobject(object, vtable, &ti->__base_info[i]); |
| const void* walk_subobject_result = |
| walk_object(subobject, ti->__base_info[i].__base_type, |
| match_object, match_type); |
| |
| if (walk_subobject_result == ambiguous_object) |
| return ambiguous_object; |
| else if (walk_subobject_result != NULL) |
| { |
| if (result == NULL) |
| { |
| result = walk_subobject_result; |
| } |
| else if (result != walk_subobject_result) |
| return ambiguous_object; |
| } |
| } |
| return result; |
| } |
| |
| default: |
| assert(0); |
| } |
| return NULL; |
| } |
| |
| // Bookkeeping structure for derived-to-base cast in the general case. |
| struct cast_context |
| { |
| public: |
| const void* object; |
| const abi::__class_type_info *src_type; |
| const abi::__class_type_info *dst_type; |
| std::ptrdiff_t src2dst_offset; |
| |
| const void* dst_object; |
| const void* result; |
| |
| cast_context(const void* obj, const abi::__class_type_info *src, |
| const abi::__class_type_info *dst, std::ptrdiff_t offset) |
| : object(obj), src_type(src), dst_type(dst), src2dst_offset(offset), |
| dst_object(NULL), result(NULL) |
| { } |
| }; |
| |
| // based-to-derive cast in the general case. |
| |
| void |
| base_to_derived_cast(const void *object, |
| const abi::__class_type_info *type, |
| cast_context* context) |
| { |
| const void* saved_dst_object = context->dst_object; |
| bool is_dst_type = *type == *context->dst_type; |
| if (is_dst_type) |
| context->dst_object = object; |
| |
| if (object == context->object |
| && context->dst_object != NULL |
| && *type == *context->src_type) |
| { |
| if (context->result == NULL) |
| context->result = context->dst_object; |
| else if (context->result != context->dst_object) |
| context->result = ambiguous_object; |
| context->dst_object = saved_dst_object; |
| return; |
| } |
| |
| switch(type->code()) |
| { |
| case abi::__class_type_info::CLASS_TYPE_INFO_CODE: |
| // This isn't not the class you're looking for. |
| break; |
| |
| case abi::__class_type_info::SI_CLASS_TYPE_INFO_CODE: |
| // derived type has a single public base at offset 0. |
| { |
| const abi::__si_class_type_info* ti = |
| static_cast<const abi::__si_class_type_info*>(type); |
| base_to_derived_cast(object, ti->__base_type, context); |
| break; |
| } |
| |
| case abi::__class_type_info::VMI_CLASS_TYPE_INFO_CODE: |
| { |
| const void* vtable = get_vtable(object); |
| const abi::__vmi_class_type_info* ti = |
| static_cast<const abi::__vmi_class_type_info*>(type); |
| |
| // Look at all direct bases. |
| for (unsigned i = 0; i < ti->__base_count; ++i) |
| { |
| if (!ti->__base_info[i].is_public()) |
| continue; |
| |
| const void *subobject = |
| get_subobject(object, vtable, &ti->__base_info[i]); |
| base_to_derived_cast(subobject, ti->__base_info[i].__base_type, |
| context); |
| |
| // FIXME: Use flags in base_info to optimize search. |
| if (context->result == ambiguous_object) |
| break; |
| } |
| break; |
| } |
| |
| default: |
| assert(0); |
| } |
| context->dst_object = saved_dst_object; |
| } |
| } // namespace |
| |
| namespace __cxxabiv1 |
| { |
| #define DYNAMIC_CAST_NO_HINT -1 |
| #define DYNAMIC_CAST_NOT_PUBLIC_BASE -2 |
| #define DYNAMIC_CAST_MULTIPLE_PUBLIC_NONVIRTUAL_BASE -3 |
| |
| /* v: source address to be adjusted; nonnull, and since the |
| * source object is polymorphic, *(void**)v is a virtual pointer. |
| * src: static type of the source object. |
| * dst: destination type (the "T" in "dynamic_cast<T>(v)"). |
| * src2dst_offset: a static hint about the location of the |
| * source subobject with respect to the complete object; |
| * special negative values are: |
| * -1: no hint |
| * -2: src is not a public base of dst |
| * -3: src is a multiple public base type but never a |
| * virtual base type |
| * otherwise, the src type is a unique public nonvirtual |
| * base type of dst at offset src2dst_offset from the |
| * origin of dst. |
| */ |
| extern "C" void* |
| __dynamic_cast (const void *v, |
| const abi::__class_type_info *src, |
| const abi::__class_type_info *dst, |
| std::ptrdiff_t src2dst_offset) |
| { |
| const void* most_derived_object = get_most_derived_object(v); |
| const void* vtable = get_vtable(most_derived_object); |
| const abi::__class_type_info* most_derived_class_type_info = |
| get_class_type_info(vtable); |
| |
| // If T is not a public base type of the most derived class referred |
| // by v, the cast always fails. |
| void* t_object = |
| const_cast<void*>(walk_object(most_derived_object, |
| most_derived_class_type_info, NULL, dst)); |
| if (t_object == NULL) |
| return NULL; |
| |
| // C++ ABI 2.9.7 The dynamic_cast Algorithm: |
| // |
| // If, in the most derived object pointed (referred) to by v, v points |
| // (refers) to a public base class subobject of a T object [note: this can |
| // be checked at compile time], and if only one object of type T is derived |
| // from the subobject pointed (referred) to by v, the result is a pointer |
| // (an lvalue referring) to that T object. |
| |
| // We knew that src is not a public base, so base-to-derived cast |
| // is not possible. This works even if there are multiple subobjects |
| // of type T in the most derived object. |
| if (src2dst_offset != DYNAMIC_CAST_NOT_PUBLIC_BASE) |
| { |
| // If it is known that v points to a public base class subobject |
| // of a T object, simply adjust the pointer by the offset. |
| if (t_object != ambiguous_object && src2dst_offset >= 0) |
| return const_cast<void*>(adjust_pointer(v, -src2dst_offset)); |
| |
| // If there is only one T type subobject, we only need to look at |
| // there. Otherwise, look for the subobject referred by v in the |
| // most derived object. |
| cast_context context(v, src, dst, src2dst_offset); |
| if (t_object != ambiguous_object) |
| base_to_derived_cast(t_object, dst, &context); |
| else |
| base_to_derived_cast(most_derived_object, |
| most_derived_class_type_info, &context); |
| |
| if (context.result != NULL && context.result != ambiguous_object) |
| return const_cast<void*>(context.result); |
| } |
| |
| // C++ ABI 2.9.7 The dynamic_cast Algorithm: |
| // |
| // Otherwise, if v points (refers) to a public base class subobject of the |
| // most derived object, and the type of the most derived object has an |
| // unambiguous public base class of type T, the result is a pointer (an |
| // lvalue referring) to the T subobject of the most derived object. |
| // Otherwise, the run-time check fails. |
| |
| // Check to see if T is a unambiguous public base class. |
| if (t_object == ambiguous_object) |
| return NULL; |
| |
| // See if v refers to a public base class subobject. |
| const void* v_object = |
| walk_object(most_derived_object, most_derived_class_type_info, v, src); |
| return v_object == v ? t_object : NULL; |
| } |
| } // namespace __cxxabiv1 |
