[lldb] Improve memory usage by freeing CTF types (NFC)

[JDevlieghere]

Summary

Improve memory usage by reducing the lifetime of CTF types. Once a CTF type has been converted to a (complete) LLDB type, there's no need to keep it in memory anymore. For most types, we can free them right after creating the corresponding LLDB types. The only exception is record types, which are only completed lazily.

This patch also adds LLVM RTTI support to CTF type. This was suggested in D156498 but with just one caller that didn't seem worth it yet. This patch introduced a second call site which tipped the scales.

[Michael137]

LGTM

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

CTFType(Kind kind, lldb::user_id_t uid, llvm::StringRef name)
       : kind(kind), uid(uid), name(name) {}
 };
 
 struct CTFInteger : public CTFType {
   CTFInteger(lldb::user_id_t uid, llvm::StringRef name, uint32_t bits,
              uint32_t encoding)
       : CTFType(eInteger, uid, name), bits(bits), encoding(encoding) {}
 
+  static bool classof(const CTFType *T) { return T->kind == eInteger; }
+
   uint32_t bits;
   uint32_t encoding;
 };
 
 struct CTFModifier : public CTFType {
 protected:
   CTFModifier(Kind kind, lldb::user_id_t uid, uint32_t type)
       : CTFType(kind, uid, ""), type(type) {}
 
+  static bool classof(const CTFType *T) {
+    return T->kind == ePointer || T->kind == eConst || T->kind == eVolatile ||
+           T->kind == eRestrict;
+  }
+
 public:
   uint32_t type;
 };
 
 struct CTFPointer : public CTFModifier {
   CTFPointer(lldb::user_id_t uid, uint32_t type)
       : CTFModifier(ePointer, uid, type) {}
+
+  static bool classof(const CTFType *T) { return T->kind == ePointer; }
 };
 
 struct CTFConst : public CTFModifier {
   CTFConst(lldb::user_id_t uid, uint32_t type)
       : CTFModifier(eConst, uid, type) {}
+
+  static bool classof(const CTFType *T) { return T->kind == eConst; }
 };
 
 struct CTFVolatile : public CTFModifier {
   CTFVolatile(lldb::user_id_t uid, uint32_t type)
       : CTFModifier(eVolatile, uid, type) {}
+
+  static bool classof(const CTFType *T) { return T->kind == eVolatile; }
 };
 
 struct CTFRestrict : public CTFModifier {
   CTFRestrict(lldb::user_id_t uid, uint32_t type)
       : CTFModifier(eRestrict, uid, type) {}
+  static bool classof(const CTFType *T) { return T->kind == eRestrict; }
 };
 
 struct CTFTypedef : public CTFType {
   CTFTypedef(lldb::user_id_t uid, llvm::StringRef name, uint32_t type)
       : CTFType(eTypedef, uid, name), type(type) {}
 
+  static bool classof(const CTFType *T) { return T->kind == eTypedef; }
+
   uint32_t type;
 };
 
 struct CTFArray : public CTFType {
   CTFArray(lldb::user_id_t uid, llvm::StringRef name, uint32_t type,
            uint32_t index, uint32_t nelems)
       : CTFType(eArray, uid, name), type(type), index(index), nelems(nelems) {}
 
+  static bool classof(const CTFType *T) { return T->kind == eArray; }
+
   uint32_t type;
   uint32_t index;
   uint32_t nelems;
 };
 
 struct CTFEnum : public CTFType {
   struct Value {
     Value(llvm::StringRef name, uint32_t value) : name(name), value(value){};
     llvm::StringRef name;
     uint32_t value;
   };
 
   CTFEnum(lldb::user_id_t uid, llvm::StringRef name, uint32_t nelems,
           uint32_t size, std::vector<Value> values)
       : CTFType(eEnum, uid, name), nelems(nelems), size(size),
         values(std::move(values)) {
     assert(this->values.size() == nelems);
   }
 
+  static bool classof(const CTFType *T) { return T->kind == eEnum; }
+
   uint32_t nelems;
   uint32_t size;
   std::vector<Value> values;
 };
 
 struct CTFFunction : public CTFType {
   CTFFunction(lldb::user_id_t uid, llvm::StringRef name, uint32_t nargs,
               uint32_t return_type, std::vector<uint32_t> args, bool variadic)
       : CTFType(eFunction, uid, name), nargs(nargs), return_type(return_type),
         args(std::move(args)), variadic(variadic) {}
 
+  static bool classof(const CTFType *T) { return T->kind == eFunction; }
+
   uint32_t nargs;
   uint32_t return_type;
 
   std::vector<uint32_t> args;
   bool variadic = false;
 };
 
 struct CTFRecord : public CTFType {
 public:
   struct Field {
     Field(llvm::StringRef name, uint32_t type, uint64_t offset)
         : name(name), type(type), offset(offset) {}
 
     llvm::StringRef name;
     uint32_t type;
     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(std::move(fields)) {}
 
+  static bool classof(const CTFType *T) {
+    return T->kind == eStruct || T->kind == eUnion;
+  }
+
   uint32_t nfields;
   uint32_t size;
   std::vector<Field> fields;
 };
 
 struct CTFStruct : public CTFRecord {
   CTFStruct(lldb::user_id_t uid, llvm::StringRef name, uint32_t nfields,
             uint32_t size, std::vector<Field> fields)
       : CTFRecord(eStruct, uid, name, nfields, size, std::move(fields)){};
+
+  static bool classof(const CTFType *T) { return T->kind == eStruct; }
 };
 
 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, std::move(fields)){};
+
+  static bool classof(const CTFType *T) { return T->kind == eUnion; }
 };
 
 struct CTFForward : public CTFType {
   CTFForward(lldb::user_id_t uid, llvm::StringRef name)
       : CTFType(eForward, uid, name) {}
+
+  static bool classof(const CTFType *T) { return T->kind == eForward; }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_CTFTYPES_H

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

private:
   /// offset is zero.
   lldb::offset_t m_body_offset = 0;
 
   TypeSystemClang *m_ast;
   lldb::CompUnitSP m_comp_unit_sp;
 
   std::optional<ctf_header_t> m_header;
 
-  std::vector<std::unique_ptr<CTFType>> m_ctf_types;
+  /// Parsed CTF types.
+  llvm::DenseMap<lldb::user_id_t, std::unique_ptr<CTFType>> m_ctf_types;
+
+  /// Parsed LLDB types.
+  llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;
 
   /// To complete types, we need a way to map (imcomplete) compiler types back
   /// to parsed CTF types.
   llvm::DenseMap<lldb::opaque_compiler_type_t, const CTFType *>
       m_compiler_types;
 
-  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 uint16_t g_ctf_field_threshold = 0x2000;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H

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

bool SymbolFileCTF::CompleteType(CompilerType &compiler_type) {
   auto it = m_compiler_types.find(compiler_type.GetOpaqueQualType());
   if (it == m_compiler_types.end())
     return false;
 
   const CTFType *ctf_type = it->second;
   assert(ctf_type && "m_compiler_types should only contain valid CTF types");
 
   // We only support resolving record types.
-  assert(ctf_type->kind == CTFType::Kind::eStruct ||
-         ctf_type->kind == CTFType::Kind::eUnion);
+  assert(llvm::isa<CTFRecord>(ctf_type));
 
   // Cast to the appropriate CTF type.
   const CTFRecord *ctf_record = static_cast<const CTFRecord *>(ctf_type);
 
   // If any of the fields are incomplete, we cannot complete the type.
   for (const CTFRecord::Field &field : ctf_record->fields) {
     if (!ResolveTypeUID(field.type)) {
       LLDB_LOG(GetLog(LLDBLog::Symbols),
for (const CTFRecord::Field &field : ctf_record->fields) {
     assert(field_type && "field must be complete");
     const uint32_t field_size = field_type->GetByteSize(nullptr).value_or(0);
     TypeSystemClang::AddFieldToRecordType(compiler_type, field.name,
                                           field_type->GetFullCompilerType(),
                                           eAccessPublic, field_size);
   }
   m_ast->CompleteTagDeclarationDefinition(compiler_type);
 
-  // Now that the compiler type is no longer incomplete we don't need to
-  // remember it anymore.
+  // Now that the compiler type is complete, we don't need to remember it
+  // anymore and can remove the CTF record type.
   m_compiler_types.erase(compiler_type.GetOpaqueQualType());
+  m_ctf_types.erase(ctf_type->uid);
 
   return true;
 }
 
 llvm::Expected<lldb::TypeSP>
 SymbolFileCTF::CreateForward(const CTFForward &ctf_forward) {
   CompilerType forward_compiler_type = m_ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), eAccessPublic, ctf_forward.name,
size_t SymbolFileCTF::ParseTypes(CompileUnit &cu) {
   lldb::offset_t type_offset = m_body_offset + m_header->typeoff;
   const lldb::offset_t type_offset_end = m_body_offset + m_header->stroff;
 
   lldb::user_id_t type_uid = 1;
   while (type_offset < type_offset_end) {
     llvm::Expected<std::unique_ptr<CTFType>> type_or_error =
         ParseType(type_offset, type_uid);
     if (type_or_error) {
-      m_ctf_types.emplace_back(std::move(*type_or_error));
+      m_ctf_types[(*type_or_error)->uid] = std::move(*type_or_error);
     } else {
-      m_ctf_types.emplace_back(std::unique_ptr<CTFType>());
       LLDB_LOG_ERROR(log, type_or_error.takeError(),
                      "Failed to parse type {1} at offset {2}: {0}", type_uid,
                      type_offset);
     }
     type_uid++;
   }
 
   LLDB_LOG(log, "Parsed {0} CTF types", m_ctf_types.size());

 }
 
 void SymbolFileCTF::AddSymbols(Symtab &symtab) {
   // CTF does not encode symbols.
   // We rely on the existing symbol table to map symbols to type.
 }
 
 lldb_private::Type *SymbolFileCTF::ResolveTypeUID(lldb::user_id_t type_uid) {
-  auto find_result = m_types.find(type_uid);
-  if (find_result != m_types.end())
-    return find_result->second.get();
+  auto type_it = m_types.find(type_uid);
+  if (type_it != m_types.end())
+    return type_it->second.get();
 
-  if (type_uid == 0 || type_uid > m_ctf_types.size())
+  auto ctf_type_it = m_ctf_types.find(type_uid);
+  if (ctf_type_it == m_ctf_types.end())
     return nullptr;
 
-  CTFType *ctf_type = m_ctf_types[type_uid - 1].get();
-  if (!ctf_type)
-    return nullptr;
+  CTFType *ctf_type = ctf_type_it->second.get();
+  assert(ctf_type && "m_ctf_types should only contain valid CTF types");
 
   Log *log = GetLog(LLDBLog::Symbols);
 
   llvm::Expected<TypeSP> type_or_error = CreateType(ctf_type);
   if (!type_or_error) {
     LLDB_LOG_ERROR(log, type_or_error.takeError(),
                    "Failed to create type for {1}: {0}", ctf_type->uid);
     return {};
   }
 
   TypeSP type_sp = *type_or_error;
 
   if (log) {
     StreamString ss;
     type_sp->Dump(&ss, true);
     LLDB_LOGV(log, "Adding type {0}: {1}", type_sp->GetID(),
               llvm::StringRef(ss.GetString()).rtrim());
   }
 
   m_types[type_uid] = type_sp;
 
+  // Except for record types which we'll need to complete later, we don't need
+  // the CTF type anymore.
+  if (!isa<CTFRecord>(ctf_type))
+    m_ctf_types.erase(type_uid);
+
   return type_sp.get();
 }
 
 void SymbolFileCTF::FindTypes(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext &parent_decl_ctx,
     uint32_t max_matches,
     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,