diff options
Diffstat (limited to 'src/dynamic_cast.cc')
-rw-r--r-- | src/dynamic_cast.cc | 356 |
1 files changed, 356 insertions, 0 deletions
diff --git a/src/dynamic_cast.cc b/src/dynamic_cast.cc new file mode 100644 index 0000000..4487fff --- /dev/null +++ b/src/dynamic_cast.cc @@ -0,0 +1,356 @@ +// 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 |