Add rtti_dump.h to make it easier to debug cast issues across library boundaries.

Usage example:

#include <rtti_dump.h>

NESTED_SETTINGS* settings = ...;
rtti_dump::dump_class_hierarchy(rtti_dump::runtime_typeid(settings));

From a110575fd3/samples/solib_rtti_dump/include/rtti_dump.h

include/rtti_dump.h

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This file is a standalone one-header-file library using only C++03.
+//
+// It assumes that the program is compiled for the "Itanium" C++ ABI
+// (http://itanium-cxx-abi.github.io/cxx-abi/), a common C++ ABI used on many
+// CPU architectures and operating systems.
+//
+
+#ifndef RTTI_DUMP
+#define RTTI_DUMP
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <set>
+#include <string>
+#include <typeinfo>
+
+#if defined(__ANDROID__) && !defined(RTTI_DUMP_USE_PRINTF)
+#include <android/log.h>
+#define RTTI_DUMP_LOG(fmt, ...) \
+    __android_log_print(ANDROID_LOG_INFO, "rtti_dump", fmt, ## __VA_ARGS__)
+#else
+#define RTTI_DUMP_LOG(fmt, ...) printf(fmt "\n", ## __VA_ARGS__)
+#endif
+
+// Avoid compiler warnings.
+#define RTTI_DUMP_UNUSED __attribute__((unused))
+
+// Use an anonymous namespace so this header file can be included at the top of
+// multiple C++ source files without breaking the One Definition Rule.
+namespace rtti_dump {
+namespace {
+
+// Returns the type of the current exception object or NULL if the thread is
+// not currently in a catch block.
+extern "C" const std::type_info *__cxa_current_exception_type();
+
+// Using run-time type information, returns an std::type_info* corresponding to
+// the most-derived class of a pointer to an object. The pointed-to type must
+// be a polymorphic class. (i.e. The class must have a virtual function or a
+// base class with a virtual function.)
+//
+// The function can return NULL if the object's vtable comes from an object
+// file compiled without -frtti.
+template <typename T>
+RTTI_DUMP_UNUSED const std::type_info *runtime_typeid(const volatile T *dynptr) {
+  T *dynptr_unqual = const_cast<T*>(dynptr);
+
+  // Use dynamic_cast<void*> to ensure that T is polymorphic. The result is
+  // discarded just in case the most-derived object vtable and the subobject
+  // vtable point to different typeinfo objects. (XXX: I *think* that's
+  // impossible, though.)
+  (void)sizeof(dynamic_cast<void*>(dynptr_unqual));
+
+  void *vptr = *reinterpret_cast<void**>(dynptr_unqual);
+  void *typeid_void = reinterpret_cast<void**>(vptr)[-1];
+  return reinterpret_cast<const std::type_info*>(typeid_void);
+}
+
+// Returns the name of the DSO or binary containing the given address.
+RTTI_DUMP_UNUSED std::string dladdr_fname(const void *ptr) {
+  Dl_info info = { 0 };
+  if (!dladdr(const_cast<void*>(ptr), &info)) {
+    char buf[64];
+    snprintf(buf, sizeof(buf), "[error: dladdr failed - %d]", errno);
+    return buf;
+  } else {
+    return std::string(info.dli_fname);
+  }
+}
+
+// Dump the address of the std::type_info object, its name, and the shared
+// object where the type_info object is defined.
+RTTI_DUMP_UNUSED
+void dump_type(const std::type_info *type, const char *label="dump_type", int indent=0) {
+  const std::string prefix = label + std::string(": ") + std::string(indent, ' ');
+  if (type == NULL) {
+    RTTI_DUMP_LOG("%sERROR: dump_type called with type==NULL!", prefix.c_str());
+  } else {
+    struct type_info {
+      virtual ~type_info() {}
+      const char *type_name;
+    };
+    assert(sizeof(type_info) == sizeof(std::type_info));
+    const char *const name = type->name();
+    const char *const raw_name = reinterpret_cast<const type_info*>(type)->type_name;
+    if (name == raw_name) {
+      RTTI_DUMP_LOG("%stype %s:", prefix.c_str(), name);
+    } else if (raw_name + 1 == name) {
+      RTTI_DUMP_LOG("%stype %s (raw name == '%s' @ %p):", prefix.c_str(), name, raw_name, raw_name);
+    } else {
+      RTTI_DUMP_LOG("%stype %s (raw name == %p):", prefix.c_str(), name, raw_name);
+    }
+    RTTI_DUMP_LOG("%s    type_info obj:  %p (in %s)",
+                  prefix.c_str(), type, dladdr_fname(type).c_str());
+    RTTI_DUMP_LOG("%s    type_info name: %p (in %s)",
+                  prefix.c_str(), name, dladdr_fname(name).c_str());
+  }
+}
+
+// Call from a catch block to dump the type of the current exception.
+RTTI_DUMP_UNUSED
+void dump_current_exception(const char *label="dump_current_exception") {
+  const std::type_info *type = __cxa_current_exception_type();
+  if (type != NULL) {
+    dump_type(type, label);
+  } else {
+    RTTI_DUMP_LOG("%s: ERROR: dump_current_exception called outside a catch block!", label);
+  }
+}
+
+namespace hierarchy_dumper_internals {
+
+  // std::type_info has virtual member functions, so the most-derived type of
+  // a pointer to a std::type_info object can be determined at run-time by
+  // looking for the std::type_info's own std::type_info. We rely upon this
+  // property to walk a class's RTTI graph at run-time.
+
+  struct __class_type_info : std::type_info {};
+
+  struct __si_class_type_info : __class_type_info {
+    const __class_type_info *__base_type;
+  };
+
+  struct __base_class_type_info {
+    const __class_type_info* __base_type;
+    long __offset_flags;
+  };
+
+  struct __vmi_class_type_info : __class_type_info {
+    unsigned int __flags;
+    unsigned int __base_count;
+    __base_class_type_info __base_info[1];
+  };
+
+  class Dumper {
+    const char *label_;
+    std::set<const std::type_info*> seen_;
+  public:
+    Dumper(const char *label) : label_(label) {}
+    void dump_type(const std::type_info *info, int indent);
+  };
+
+  const int kIndent = 4;
+
+  void Dumper::dump_type(const std::type_info *info, int indent) {
+    ::rtti_dump::dump_type(info, label_, indent * kIndent);
+
+    if (info == NULL) {
+      return;
+    }
+
+    const std::type_info *info_type = runtime_typeid(info);
+    __base_class_type_info lone_base = { 0 };
+    const __base_class_type_info *base_table = NULL;
+    unsigned int base_count = 0;
+
+    // Determine type equality using a string comparison, because this dumping
+    // system doesn't trust std::type_info::operator== to work with multiple
+    // shared objects.
+
+    const int sub_indent_sp = (indent + 1) * kIndent;
+
+    if (info_type == NULL) {
+      // I don't think info_type can ever be NULL here.
+      RTTI_DUMP_LOG("%s: %*sERROR: runtime_typeid(info) was NULL!", label_, sub_indent_sp, "");
+    } else if (!strcmp(info_type->name(), "N10__cxxabiv120__si_class_type_infoE")) {
+      const __si_class_type_info &infox =
+          *reinterpret_cast<const __si_class_type_info*>(info);
+      lone_base.__base_type = infox.__base_type;
+      base_count = 1;
+      base_table = &lone_base;
+    } else if (!strcmp(info_type->name(), "N10__cxxabiv121__vmi_class_type_infoE")) {
+      const __vmi_class_type_info &infox =
+          *reinterpret_cast<const __vmi_class_type_info*>(info);
+      base_count = infox.__base_count;
+      base_table = infox.__base_info;
+    }
+
+    if (base_count > 0) {
+      if (seen_.find(info) != seen_.end()) {
+        RTTI_DUMP_LOG("%s: %*sbase classes: ...elided...", label_, sub_indent_sp, "");
+      } else {
+        RTTI_DUMP_LOG("%s: %*sbase classes:", label_, sub_indent_sp, "");
+        seen_.insert(info);
+        for (unsigned int i = 0; i < base_count; ++i) {
+          dump_type(base_table[i].__base_type, indent + 2);
+        }
+      }
+    }
+  }
+} // namespace hierarchy_dumper_internals
+
+// Dump the std::type_info object, and if it represents a class with base
+// classes, then dumps the class hierarchy.
+RTTI_DUMP_UNUSED
+void dump_class_hierarchy(const std::type_info *info, const char *label="dump_class_hierarchy") {
+  hierarchy_dumper_internals::Dumper dumper(label);
+  dumper.dump_type(info, 0);
+}
+
+} // anonymous namespace
+} // namespace rtti_dump
+
+#endif // RTTI_DUMP