[lldb] Support CTF forward declarations

[JDevlieghere]

Summary

Add support for CTF forward declarations.

[bulbazord]

Looks like a straightforward follow-up to D156447. One small nit but otherwise looks good.

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

530

It takes a StringRef directly, no need to yoink out the pointer and re-create it.

[JDevlieghere]

Address @bulbazord's feedback.

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

 };
 
 struct CTFUnion : public CTFRecord {
   CTFUnion(lldb::user_id_t uid, llvm::StringRef name, uint32_t nfields,
            uint32_t size, std::vector<Field> fields)
       : CTFRecord(eUnion, uid, name, nfields, size, fields){};
 };
 
+struct CTFForward : public CTFType {
+  CTFForward(lldb::user_id_t uid, llvm::StringRef name)
+      : CTFType(eForward, uid, name) {}
+};
+
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H

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

private:
   llvm::Expected<lldb::TypeSP> CreateType(CTFType *ctf_type);
   llvm::Expected<lldb::TypeSP> CreateInteger(const CTFInteger &ctf_integer);
   llvm::Expected<lldb::TypeSP> CreateModifier(const CTFModifier &ctf_modifier);
   llvm::Expected<lldb::TypeSP> CreateTypedef(const CTFTypedef &ctf_typedef);
   llvm::Expected<lldb::TypeSP> CreateArray(const CTFArray &ctf_array);
   llvm::Expected<lldb::TypeSP> CreateEnum(const CTFEnum &ctf_enum);
   llvm::Expected<lldb::TypeSP> CreateFunction(const CTFFunction &ctf_function);
   llvm::Expected<lldb::TypeSP> CreateRecord(const CTFRecord &ctf_record);
+  llvm::Expected<lldb::TypeSP> CreateForward(const CTFForward &ctf_forward);
 
   llvm::StringRef ReadString(lldb::offset_t offset) const;
 
   std::vector<uint16_t> GetFieldSizes(lldb::offset_t field_offset,
                                       uint32_t fields, uint32_t struct_size);
 
   DataExtractor m_data;
 

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

SymbolFileCTF::CreateRecord(const CTFRecord &ctf_record) {
   m_ast->CompleteTagDeclarationDefinition(record_type);
 
   Declaration decl;
   return MakeType(ctf_record.uid, ConstString(ctf_record.name), ctf_record.size,
                   nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID,
                   decl, record_type, lldb_private::Type::ResolveState::Full);
 }
 
+llvm::Expected<lldb::TypeSP>
+SymbolFileCTF::CreateForward(const CTFForward &ctf_forward) {
+  CompilerType forward_compiler_type = m_ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), eAccessPublic, ctf_forward.name,
+      clang::TTK_Struct, eLanguageTypeC);
+  Declaration decl;
+  return MakeType(ctf_forward.uid, ConstString(ctf_forward.name), 0, nullptr,
+                  LLDB_INVALID_UID, Type::eEncodingIsUID, decl,
+                  forward_compiler_type, Type::ResolveState::Forward);
+}
+
 llvm::Expected<TypeSP> SymbolFileCTF::CreateType(CTFType *ctf_type) {
   if (!ctf_type)
     return llvm::make_error<llvm::StringError>(
         "cannot create type for unparsed type", llvm::inconvertibleErrorCode());
 
   switch (ctf_type->kind) {
   case CTFType::Kind::eInteger:
     return CreateInteger(*static_cast<CTFInteger *>(ctf_type));
   case CTFType::Kind::eConst:
   case CTFType::Kind::ePointer:
   case CTFType::Kind::eRestrict:
   case CTFType::Kind::eVolatile:
     return CreateModifier(*static_cast<CTFModifier *>(ctf_type));
   case CTFType::Kind::eTypedef:
     return CreateTypedef(*static_cast<CTFTypedef *>(ctf_type));
   case CTFType::Kind::eArray:
     return CreateArray(*static_cast<CTFArray *>(ctf_type));
   case CTFType::Kind::eEnum:
     return CreateEnum(*static_cast<CTFEnum *>(ctf_type));
   case CTFType::Kind::eFunction:
     return CreateFunction(*static_cast<CTFFunction *>(ctf_type));
   case CTFType::Kind::eStruct:
   case CTFType::Kind::eUnion:
     return CreateRecord(*static_cast<CTFRecord *>(ctf_type));
+  case CTFType::Kind::eForward:
+    return CreateForward(*static_cast<CTFForward *>(ctf_type));
   case CTFType::Kind::eUnknown:
   case CTFType::Kind::eFloat:
-  case CTFType::Kind::eForward:
   case CTFType::Kind::eSlice:
     return llvm::make_error<llvm::StringError>(
         llvm::formatv("unsupported type (uid = {0}, name = {1}, kind = {2})",
                       ctf_type->uid, ctf_type->name, ctf_type->kind),
         llvm::inconvertibleErrorCode());
   }
 }
 
for (uint32_t i = 0; i < variable_length; ++i) {
       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);
     }
     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,
                                      name);
   case TypeKind::eFloat:
-  case TypeKind::eForward:
   case TypeKind::eSlice:
     offset += (variable_length * sizeof(uint32_t));
     break;
   }
 
   return llvm::make_error<llvm::StringError>(
       llvm::formatv("unsupported type (name = {0}, kind = {1}, vlength = {2})",
                     name, kind, variable_length),

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

def do_test(self):
         )
         self.expect(
             "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"])

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

 #include <stdio.h>
 
+struct ForwardDecl;
+
 typedef int MyInt;
 
 void populate(MyInt i);
 
 typedef enum MyEnum {
   eOne = 1,
   eTwo =2,
   eThree = 3,

 } MyNestedStructT;
 
 typedef struct MyStruct {
   MyNestedStructT n;
   void (*f)(int);
 } MyStructT;
 
 MyStructT foo;
+struct ForwardDecl *forward;
 
 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;
 }
 
 int main(int argc, char** argv) {
   populate(argc);
   printf("foo is at address: %p\n", (void*)&foo); // Break here
   return 0;
 }