Implement LLDBParser::enumerateClassParents

Author: ttreyer

oi/type_graph/LLDBParser.cpp

@@ -19,6 +19,44 @@
 #include <lldb/API/LLDB.h>
 #include <cassert>
 
+namespace std {
+/* We use the address of the name string for hashing and equality.
+ * This relies on string de-duplication, two objects with the same name
+ * might have different addresses, but their de-duplicated name will
+ * have the same address.
+ *
+ * TODO: Is this correct? How does -fsimple-template-names impact this?
+ *       Is there a better way to do this?
+ */
+size_t hash<lldb::SBType>::operator()(const lldb::SBType& key) const {
+  auto *name = const_cast<lldb::SBType&>(key).GetName();
+  auto Hasher = std::hash<const char*>();
+  { /* Debugging
+    auto &keyAsSP = reinterpret_cast<const lldb::TypeImplSP&>(key);
+    fprintf(stderr, "LLDBType::hash(key@0x%08zx = (0x%08zx, %s)) = 0x%08zx\n",
+      (uintptr_t)keyAsSP.get(), (uintptr_t)name, name, Hasher(name));
+    // Debugging */
+  }
+  return Hasher(name);
+}
+
+bool equal_to<lldb::SBType>::operator()(const lldb::SBType& lhs, const lldb::SBType& rhs) const {
+  auto* lhsName = const_cast<lldb::SBType&>(lhs).GetName();
+  auto* rhsName = const_cast<lldb::SBType&>(rhs).GetName();
+  auto EqualTo = std::equal_to<const char*>();
+  { /* Debugging
+    auto &lhsAsSP = reinterpret_cast<const lldb::TypeImplSP&>(lhs);
+    auto &rhsAsSP = reinterpret_cast<const lldb::TypeImplSP&>(rhs);
+    fprintf(stderr, "LLDBType::equal_to(lhs@0x%08zx = (0x%08zx, %s), rhs@0x%08zx = (0x%08zx, %s)) = %d\n",
+      (uintptr_t)lhsAsSP.get(), (uintptr_t)lhsName, lhsName,
+      (uintptr_t)rhsAsSP.get(), (uintptr_t)rhsName, rhsName,
+      EqualTo(lhsName, rhsName));
+    // Debugging */
+  }
+  return EqualTo(lhsName, rhsName);
+}
+}  // namespace std
+
 namespace oi::detail::type_graph {
 
 Type& LLDBParser::parse(lldb::SBType& root) {
@@ -119,12 +157,25 @@ Class& LLDBParser::enumerateClass(lldb::SBType& type) {
 
   auto &c = makeType<Class>(type, kind, displayName, name, size, virtuality);
 
+  enumerateClassParents(type, c.parents);
   enumerateClassMembers(type, c.members);
   enumerateClassFunctions(type, c.functions);
 
   return c;
 }
 
+void LLDBParser::enumerateClassParents(lldb::SBType& type, std::vector<Parent>& parents) {
+  assert(parents.empty());
+  parents.reserve(type.GetNumberOfDirectBaseClasses());
+
+  for (uint32_t i = 0; i < type.GetNumberOfDirectBaseClasses(); i++) {
+    auto base = type.GetDirectBaseClassAtIndex(i);
+    auto baseType = base.GetType();
+
+    parents.emplace_back(enumerateType(baseType), base.GetOffsetInBits());
+  }
+}
+
 void LLDBParser::enumerateClassMembers(lldb::SBType& type, std::vector<Member>& members) {
   assert(members.empty());
   members.reserve(type.GetNumberOfFields());

oi/type_graph/LLDBParser.h

@@ -21,23 +21,17 @@
 #include <lldb/API/SBType.h>
 
 namespace std {
+/* lldb::SBType doesn't provide a hash and equality operators.
+ * So we define our own specialization of them here.
+ */
 template <>
 struct hash<lldb::SBType> {
-  size_t operator()(const lldb::SBType& key) const {
-    auto &keyAsSP = reinterpret_cast<const lldb::TypeImplSP&>(key);
-    auto SPHasher = std::hash<lldb::TypeImplSP>();
-    return SPHasher(keyAsSP);
-  }
+  size_t operator()(const lldb::SBType& type) const;
 };
 
 template <>
 struct equal_to<lldb::SBType> {
-  bool operator()(const lldb::SBType& lhs, const lldb::SBType& rhs) const {
-    auto &lhsAsSP = reinterpret_cast<const lldb::TypeImplSP&>(lhs);
-    auto &rhsAsSP = reinterpret_cast<const lldb::TypeImplSP&>(rhs);
-    auto SPEqualTo = std::equal_to<lldb::TypeImplSP>();
-    return SPEqualTo(lhsAsSP, rhsAsSP);
-  }
+  bool operator()(const lldb::SBType& lhs, const lldb::SBType& rhs) const;
 };
 }  // namespace std
 
@@ -67,6 +61,7 @@ class LLDBParser {
   Primitive::Kind primitiveIntKind(lldb::SBType& type, bool is_signed);
   Primitive::Kind primitiveFloatKind(lldb::SBType& type);
 
+  void enumerateClassParents(lldb::SBType& type, std::vector<Parent>& parents);
   void enumerateClassMembers(lldb::SBType& type, std::vector<Member>& members);
   void enumerateClassFunctions(lldb::SBType &type, std::vector<Function>& functions);
 

test/test_lldb_parser.cpp

@@ -169,9 +169,9 @@ TEST_F(LLDBParserTest, SimpleUnion) {
 TEST_F(LLDBParserTest, Inheritance) {
   test("oid_test_case_inheritance_access_public", R"(
 [4] Pointer
-[0]   Class: Public (size: 8)
+[0]   Class: ns_inheritance_access::Public (size: 8)
         Parent (offset: 0)
-[1]       Class: Base (size: 4)
+[1]       Class: ns_inheritance_access::Base (size: 4)
             Member: base_int (offset: 0)
 [3]           Typedef: int32_t
 [2]             Typedef: __int32_t
@@ -184,25 +184,25 @@ TEST_F(LLDBParserTest, Inheritance) {
 TEST_F(LLDBParserTest, InheritanceMultiple) {
   test("oid_test_case_inheritance_multiple_a", R"(
 [6] Pointer
-[0]   Struct: Derived_2 (size: 24)
+[0]   Struct: ns_inheritance_multiple::Derived_2 (size: 24)
         Parent (offset: 0)
-[1]       Struct: Base_1 (size: 4)
+[1]       Struct: ns_inheritance_multiple::Base_1 (size: 4)
             Member: a (offset: 0)
               Primitive: int32_t
         Parent (offset: 4)
-[2]       Struct: Derived_1 (size: 12)
+[2]       Struct: ns_inheritance_multiple::Derived_1 (size: 12)
             Parent (offset: 0)
-[3]           Struct: Base_2 (size: 4)
+[3]           Struct: ns_inheritance_multiple::Base_2 (size: 4)
                 Member: b (offset: 0)
                   Primitive: int32_t
             Parent (offset: 4)
-[4]           Struct: Base_3 (size: 4)
+[4]           Struct: ns_inheritance_multiple::Base_3 (size: 4)
                 Member: c (offset: 0)
                   Primitive: int32_t
             Member: d (offset: 8)
               Primitive: int32_t
         Parent (offset: 16)
-[5]       Struct: Base_4 (size: 4)
+[5]       Struct: ns_inheritance_multiple::Base_4 (size: 4)
             Member: e (offset: 0)
               Primitive: int32_t
         Member: f (offset: 20)