summaryrefslogtreecommitdiff
path: root/libstdc++-v3/libsupc++/tinfo.h
diff options
context:
space:
mode:
Diffstat (limited to 'libstdc++-v3/libsupc++/tinfo.h')
-rw-r--r--libstdc++-v3/libsupc++/tinfo.h183
1 files changed, 183 insertions, 0 deletions
diff --git a/libstdc++-v3/libsupc++/tinfo.h b/libstdc++-v3/libsupc++/tinfo.h
new file mode 100644
index 000000000..b3e22232f
--- /dev/null
+++ b/libstdc++-v3/libsupc++/tinfo.h
@@ -0,0 +1,183 @@
+// RTTI support internals for -*- C++ -*-
+// Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2004, 2009
+// Free Software Foundation
+
+// This file is part of GCC.
+//
+// GCC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// GCC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+#include "typeinfo"
+#include <cstddef>
+
+// Class declarations shared between the typeinfo implementation files.
+
+#include <cxxabi.h>
+
+namespace __cxxabiv1 {
+
+inline bool __pbase_type_info::
+__pointer_catch (const __pbase_type_info *thrown_type,
+ void **thr_obj,
+ unsigned outer) const
+{
+ return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
+}
+
+namespace {
+
+using namespace std;
+using namespace abi;
+
+// Initial part of a vtable, this structure is used with offsetof, so we don't
+// have to keep alignments consistent manually.
+struct vtable_prefix
+{
+ // Offset to most derived object.
+ ptrdiff_t whole_object;
+
+ // Additional padding if necessary.
+#ifdef _GLIBCXX_VTABLE_PADDING
+ ptrdiff_t padding1;
+#endif
+
+ // Pointer to most derived type_info.
+ const __class_type_info *whole_type;
+
+ // Additional padding if necessary.
+#ifdef _GLIBCXX_VTABLE_PADDING
+ ptrdiff_t padding2;
+#endif
+
+ // What a class's vptr points to.
+ const void *origin;
+};
+
+template <typename T>
+inline const T *
+adjust_pointer (const void *base, ptrdiff_t offset)
+{
+ return reinterpret_cast <const T *>
+ (reinterpret_cast <const char *> (base) + offset);
+}
+
+// ADDR is a pointer to an object. Convert it to a pointer to a base,
+// using OFFSET. IS_VIRTUAL is true, if we are getting a virtual base.
+inline void const *
+convert_to_base (void const *addr, bool is_virtual, ptrdiff_t offset)
+{
+ if (is_virtual)
+ {
+ const void *vtable = *static_cast <const void *const *> (addr);
+
+ offset = *adjust_pointer<ptrdiff_t> (vtable, offset);
+ }
+
+ return adjust_pointer<void> (addr, offset);
+}
+
+// some predicate functions for __class_type_info::__sub_kind
+inline bool contained_p (__class_type_info::__sub_kind access_path)
+{
+ return access_path >= __class_type_info::__contained_mask;
+}
+inline bool public_p (__class_type_info::__sub_kind access_path)
+{
+ return access_path & __class_type_info::__contained_public_mask;
+}
+inline bool virtual_p (__class_type_info::__sub_kind access_path)
+{
+ return (access_path & __class_type_info::__contained_virtual_mask);
+}
+inline bool contained_public_p (__class_type_info::__sub_kind access_path)
+{
+ return ((access_path & __class_type_info::__contained_public)
+ == __class_type_info::__contained_public);
+}
+inline bool contained_nonpublic_p (__class_type_info::__sub_kind access_path)
+{
+ return ((access_path & __class_type_info::__contained_public)
+ == __class_type_info::__contained_mask);
+}
+inline bool contained_nonvirtual_p (__class_type_info::__sub_kind access_path)
+{
+ return ((access_path & (__class_type_info::__contained_mask
+ | __class_type_info::__contained_virtual_mask))
+ == __class_type_info::__contained_mask);
+}
+
+static const __class_type_info *const nonvirtual_base_type =
+ static_cast <const __class_type_info *> (0) + 1;
+
+} // namespace
+
+// __upcast_result is used to hold information during traversal of a class
+// hierarchy when catch matching.
+struct __class_type_info::__upcast_result
+{
+ const void *dst_ptr; // pointer to caught object
+ __sub_kind part2dst; // path from current base to target
+ int src_details; // hints about the source type hierarchy
+ const __class_type_info *base_type; // where we found the target,
+ // if in vbase the __class_type_info of vbase
+ // if a non-virtual base then 1
+ // else NULL
+ __upcast_result (int d)
+ :dst_ptr (NULL), part2dst (__unknown), src_details (d), base_type (NULL)
+ {}
+};
+
+// __dyncast_result is used to hold information during traversal of a class
+// hierarchy when dynamic casting.
+struct __class_type_info::__dyncast_result
+{
+ const void *dst_ptr; // pointer to target object or NULL
+ __sub_kind whole2dst; // path from most derived object to target
+ __sub_kind whole2src; // path from most derived object to sub object
+ __sub_kind dst2src; // path from target to sub object
+ int whole_details; // details of the whole class hierarchy
+
+ __dyncast_result (int details_ = __vmi_class_type_info::__flags_unknown_mask)
+ :dst_ptr (NULL), whole2dst (__unknown),
+ whole2src (__unknown), dst2src (__unknown),
+ whole_details (details_)
+ {}
+
+protected:
+ __dyncast_result(const __dyncast_result&);
+
+ __dyncast_result&
+ operator=(const __dyncast_result&);
+};
+
+inline __class_type_info::__sub_kind __class_type_info::
+__find_public_src (ptrdiff_t src2dst,
+ const void *obj_ptr,
+ const __class_type_info *src_type,
+ const void *src_ptr) const
+{
+ if (src2dst >= 0)
+ return adjust_pointer <void> (obj_ptr, src2dst) == src_ptr
+ ? __contained_public : __not_contained;
+ if (src2dst == -2)
+ return __not_contained;
+ return __do_find_public_src (src2dst, obj_ptr, src_type, src_ptr);
+}
+
+}