[lldb] Fix CTF parsing of large structs

[JDevlieghere]

Summary

Fix CTF parsing of large structs. If the size of a struct exceeds a certain threshold, the offset is encoded using two 32-bit integers instead of one.

[bulbazord]

LGTM modulo spelling nit

lldb/source/Plugins/SymbolFile/CTF/SymbolFileCTF.h

257

lldb/test/API/macosx/ctf/test.c

54

barbie? 🤔

lldb/source/Plugins/SymbolFile/CTF/CTFTypes.h

struct CTFFunction : public CTFType {
 
   std::vector<uint32_t> args;
   bool variadic = false;
 };
 
 struct CTFRecord : public CTFType {
 public:
   struct Field {
-    Field(llvm::StringRef name, uint32_t type, uint16_t offset,
-          uint16_t padding)
-        : name(name), type(type), offset(offset), padding(padding) {}
+    Field(llvm::StringRef name, uint32_t type, uint64_t offset)
+        : name(name), type(type), offset(offset) {}
 
     llvm::StringRef name;
     uint32_t type;
-    uint16_t offset;
-    uint16_t padding;
+    uint64_t offset;
   };
 
   CTFRecord(Kind kind, lldb::user_id_t uid, llvm::StringRef name,
             uint32_t nfields, uint32_t size, std::vector<Field> fields)
       : CTFType(kind, uid, name), nfields(nfields), size(size), fields(fields) {
     assert(fields.size() == nfields);
   }
 

lldb/source/Plugins/SymbolFile/CTF/SymbolFileCTF.h

private:
 
   llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;
 
   std::vector<lldb::FunctionSP> m_functions;
   std::vector<lldb::VariableSP> m_variables;
 
   static constexpr uint16_t g_ctf_magic = 0xcff1;
   static constexpr uint8_t g_ctf_version = 4;
+  static constexpr uint32_t g_ctf_field_treshold = 8192;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H

lldb/source/Plugins/SymbolFile/CTF/SymbolFileCTF.cpp

return std::make_unique<CTFFunction>(uid, name, variable_length, type, args,
                                          variadic);
   }
   case TypeKind::eStruct:
   case TypeKind::eUnion: {
     std::vector<CTFRecord::Field> fields;
     for (uint32_t i = 0; i < variable_length; ++i) {
       const uint32_t field_name = m_data.GetU32(&offset);
       const uint32_t type = m_data.GetU32(&offset);
-      const uint16_t field_offset = m_data.GetU16(&offset);
-      const uint16_t padding = m_data.GetU16(&offset);
-      fields.emplace_back(ReadString(field_name), type, field_offset, padding);
+      uint64_t field_offset = 0;
+      if (size < g_ctf_field_treshold) {
+        field_offset = m_data.GetU32(&offset);
+      } else {
+        const uint32_t offset_hi = m_data.GetU32(&offset);
+        const uint32_t offset_lo = m_data.GetU32(&offset);
+        field_offset = (((uint64_t)offset_hi) << 32) | ((uint64_t)offset_lo);
+      }
+      fields.emplace_back(ReadString(field_name), type, field_offset);
     }
     return std::make_unique<CTFRecord>(static_cast<CTFType::Kind>(kind), uid,
                                        name, variable_length, size, fields);
   }
   case TypeKind::eForward:
     return std::make_unique<CTFForward>(uid, name);
   case TypeKind::eUnknown:
     return std::make_unique<CTFType>(static_cast<CTFType::Kind>(kind), uid,
size_t SymbolFileCTF::ParseObjects(CompileUnit &comp_unit) {
   uint32_t symbol_idx = 0;
   Declaration decl;
   while (object_offset < object_offset_end) {
     const uint32_t type_uid = m_data.GetU32(&object_offset);
 
     if (Symbol *symbol =
             symtab->FindSymbolWithType(eSymbolTypeData, Symtab::eDebugYes,
                                        Symtab::eVisibilityAny, symbol_idx)) {
-
       Variable::RangeList ranges;
       ranges.Append(symbol->GetFileAddress(), symbol->GetByteSize());
 
       auto type_sp = std::make_shared<SymbolFileType>(*this, type_uid);
 
       DWARFExpressionList location(
           module_sp, CreateDWARFExpression(module_sp, *symbol), nullptr);
 

lldb/test/API/macosx/ctf/Makefile

$(OBJCOPY) \
     -R __DWARF,__debug_abbrev \
     -R __DWARF,__debug_str \
     -R __DWARF,__apple_names \
     -R __DWARF,__apple_namespac \
     -R __DWARF,__apple_types \
     -R __DWARF,__apple_objc \
     a.ctf a.ctf
   rm -rf a.out.dSYM
+  rm -rf test.o

lldb/test/API/macosx/ctf/TestCTF.py

def test_compressed(self):
         self.build(dictionary={"COMPRESS_CTF": "YES"})
         self.do_test()
 
     def do_test(self):
         lldbutil.run_to_name_breakpoint(self, "printf")
 
         symbol_file = self.getBuildArtifact("a.ctf")
 
+        if self.TraceOn():
+            self.runCmd("log enable -v lldb symbol")
+
         self.runCmd("target symbols add {}".format(symbol_file))
         self.expect(
             "target variable foo",
             substrs=[
                 "(MyStructT) foo",
                 "i = 1",
                 "foo",
                 "'c'",
                 "[0] = 'c'",
                 "[1] = 'a'",
                 "[2] = 'b'",
                 "[3] = 'c'",
                 'u = (i = 1, s = "")',
                 "f = 0x0000000000000000",
             ],
         )
-
         self.expect("target variable foo.n.i", substrs=["(MyInt) foo.n.i = 1"])
         self.expect(
             "target variable foo.n.s", substrs=["(const char *) foo.n.s", '"foo"']
         )
         self.expect(
             "target variable foo.n.c", substrs=["(volatile char) foo.n.c = 'c'"]
         )
         self.expect(
def do_test(self):
             "target variable foo.n.u", substrs=['(MyUnionT) foo.n.u = (i = 1, s = "")']
         )
         self.expect(
             "target variable foo.f",
             substrs=["(void (*)(int)) foo.f = 0x0000000000000000"],
         )
 
         self.expect(" type lookup ForwardDecl", substrs=["struct ForwardDecl"])
+
+        self.expect(
+            "type lookup LargeStruct",
+            substrs=[
+                "struct LargeStruct",
+                "char buffer[9000]",
+                "int b ",
+            ],
+        )

lldb/test/API/macosx/ctf/test.c

typedef struct MyNestedStruct {
   MyUnionT u;
 } MyNestedStructT;
 
 typedef struct MyStruct {
   MyNestedStructT n;
   void (*f)(int);
 } MyStructT;
 
+struct LargeStruct {
+  char buffer[9000];
+  int b;
+};
+
 MyStructT foo;
 struct ForwardDecl *forward;
+struct LargeStruct bar;
 
 void populate(MyInt i) {
   foo.n.i = i;
   foo.n.s = "foo";
   foo.n.c = 'c';
   foo.n.a[0] = 'a';
   foo.n.a[1] = 'b';
   foo.n.a[2] = 'c';
   foo.n.a[3] = 'd';
   foo.n.e = eOne;
   foo.f = NULL;
   forward = NULL;
+  bar.b = i;
 }
 
 int main(int argc, char** argv) {
   populate(argc);
   printf("foo is at address: %p\n", (void*)&foo); // Break here
   return 0;
 }