68918125c1
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. Differential revision: https://reviews.llvm.org/D156606
269 lines
8.0 KiB
C++
269 lines
8.0 KiB
C++
//===-- SymbolFileCTF.h -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H
|
|
#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H
|
|
|
|
#include <map>
|
|
#include <optional>
|
|
#include <vector>
|
|
|
|
#include "CTFTypes.h"
|
|
#include "lldb/Symbol/CompileUnit.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
|
|
namespace lldb_private {
|
|
|
|
class SymbolFileCTF : public lldb_private::SymbolFileCommon {
|
|
/// LLVM RTTI support.
|
|
static char ID;
|
|
|
|
public:
|
|
/// LLVM RTTI support.
|
|
/// \{
|
|
bool isA(const void *ClassID) const override {
|
|
return ClassID == &ID || SymbolFileCommon::isA(ClassID);
|
|
}
|
|
static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
|
|
/// \}
|
|
|
|
SymbolFileCTF(lldb::ObjectFileSP objfile_sp);
|
|
|
|
static void Initialize();
|
|
|
|
static void Terminate();
|
|
|
|
static llvm::StringRef GetPluginNameStatic() { return "CTF"; }
|
|
|
|
static llvm::StringRef GetPluginDescriptionStatic();
|
|
|
|
static lldb_private::SymbolFile *
|
|
CreateInstance(lldb::ObjectFileSP objfile_sp);
|
|
|
|
llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
|
|
|
|
uint32_t CalculateAbilities() override;
|
|
|
|
void InitializeObject() override;
|
|
|
|
lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override {
|
|
return lldb::eLanguageTypeUnknown;
|
|
}
|
|
|
|
bool ParseHeader();
|
|
|
|
size_t ParseFunctions(CompileUnit &comp_unit) override;
|
|
|
|
size_t ParseObjects(CompileUnit &comp_unit);
|
|
|
|
bool ParseLineTable(CompileUnit &comp_unit) override { return false; }
|
|
|
|
bool ParseDebugMacros(CompileUnit &comp_unit) override { return false; }
|
|
|
|
bool ParseSupportFiles(CompileUnit &comp_unit,
|
|
FileSpecList &support_files) override {
|
|
return false;
|
|
}
|
|
|
|
size_t ParseTypes(CompileUnit &cu) override;
|
|
|
|
bool ParseImportedModules(
|
|
const SymbolContext &sc,
|
|
std::vector<lldb_private::SourceModule> &imported_modules) override {
|
|
return false;
|
|
}
|
|
|
|
size_t ParseBlocksRecursive(Function &func) override { return 0; }
|
|
|
|
size_t ParseVariablesForContext(const SymbolContext &sc) override;
|
|
|
|
uint32_t CalculateNumCompileUnits() override { return 0; }
|
|
|
|
lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
|
|
|
|
Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
|
|
std::optional<ArrayInfo> GetDynamicArrayInfoForUID(
|
|
lldb::user_id_t type_uid,
|
|
const lldb_private::ExecutionContext *exe_ctx) override {
|
|
return std::nullopt;
|
|
}
|
|
|
|
bool CompleteType(CompilerType &compiler_type) override;
|
|
|
|
uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
|
|
lldb::SymbolContextItem resolve_scope,
|
|
lldb_private::SymbolContext &sc) override;
|
|
|
|
void AddSymbols(Symtab &symtab) override;
|
|
|
|
void GetTypes(lldb_private::SymbolContextScope *sc_scope,
|
|
lldb::TypeClass type_mask,
|
|
lldb_private::TypeList &type_list) override {}
|
|
|
|
void
|
|
FindTypes(lldb_private::ConstString name,
|
|
const lldb_private::CompilerDeclContext &parent_decl_ctx,
|
|
uint32_t max_matches,
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
|
|
lldb_private::TypeMap &types) override;
|
|
|
|
void FindTypesByRegex(const lldb_private::RegularExpression ®ex,
|
|
uint32_t max_matches, lldb_private::TypeMap &types);
|
|
|
|
void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
|
|
const lldb_private::CompilerDeclContext &parent_decl_ctx,
|
|
bool include_inlines,
|
|
lldb_private::SymbolContextList &sc_list) override;
|
|
|
|
void FindFunctions(const lldb_private::RegularExpression ®ex,
|
|
bool include_inlines,
|
|
lldb_private::SymbolContextList &sc_list) override;
|
|
|
|
void
|
|
FindGlobalVariables(lldb_private::ConstString name,
|
|
const lldb_private::CompilerDeclContext &parent_decl_ctx,
|
|
uint32_t max_matches,
|
|
lldb_private::VariableList &variables) override;
|
|
|
|
void FindGlobalVariables(const lldb_private::RegularExpression ®ex,
|
|
uint32_t max_matches,
|
|
lldb_private::VariableList &variables) override;
|
|
|
|
enum TypeKind : uint32_t {
|
|
eUnknown = 0,
|
|
eInteger = 1,
|
|
eFloat = 2,
|
|
ePointer = 3,
|
|
eArray = 4,
|
|
eFunction = 5,
|
|
eStruct = 6,
|
|
eUnion = 7,
|
|
eEnum = 8,
|
|
eForward = 9,
|
|
eTypedef = 10,
|
|
eVolatile = 11,
|
|
eConst = 12,
|
|
eRestrict = 13,
|
|
eSlice = 14,
|
|
};
|
|
|
|
private:
|
|
enum Flags : uint32_t {
|
|
eFlagCompress = (1u << 0),
|
|
eFlagNewFuncInfo = (1u << 1),
|
|
eFlagIdxSorted = (1u << 2),
|
|
eFlagDynStr = (1u << 3),
|
|
};
|
|
|
|
enum IntEncoding : uint32_t {
|
|
eSigned = 0x1,
|
|
eChar = 0x2,
|
|
eBool = 0x4,
|
|
eVarArgs = 0x8,
|
|
};
|
|
|
|
struct ctf_preamble_t {
|
|
uint16_t magic;
|
|
uint8_t version;
|
|
uint8_t flags;
|
|
};
|
|
|
|
struct ctf_header_t {
|
|
ctf_preamble_t preamble;
|
|
uint32_t parlabel;
|
|
uint32_t parname;
|
|
uint32_t lbloff;
|
|
uint32_t objtoff;
|
|
uint32_t funcoff;
|
|
uint32_t typeoff;
|
|
uint32_t stroff;
|
|
uint32_t strlen;
|
|
};
|
|
|
|
struct ctf_type_t {
|
|
uint32_t name;
|
|
uint32_t info;
|
|
union {
|
|
uint32_t size;
|
|
uint32_t type;
|
|
};
|
|
uint32_t lsizehi;
|
|
uint32_t lsizelo;
|
|
};
|
|
|
|
struct ctf_stype_t {
|
|
uint32_t name;
|
|
uint32_t info;
|
|
union {
|
|
uint32_t size;
|
|
uint32_t type;
|
|
};
|
|
|
|
bool IsLargeType() const { return size == 0xffff; }
|
|
uint32_t GetStructSize() const {
|
|
if (IsLargeType())
|
|
return sizeof(ctf_type_t);
|
|
return sizeof(ctf_stype_t);
|
|
}
|
|
uint32_t GetType() const { return type; }
|
|
uint32_t GetSize() const { return size; }
|
|
};
|
|
|
|
llvm::Expected<std::unique_ptr<CTFType>> ParseType(lldb::offset_t &offset,
|
|
lldb::user_id_t uid);
|
|
|
|
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;
|
|
|
|
/// The start offset of the CTF body into m_data. If the body is uncompressed,
|
|
/// m_data contains the header and the body and the body starts after the
|
|
/// header. If the body is compressed, m_data only contains the body and the
|
|
/// 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;
|
|
|
|
/// 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;
|
|
|
|
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
|