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

   1 //===-- SymbolFileCTF.h -----------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H
  10 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H
  11
  12 #include <map>
  13 #include <optional>
  14 #include <vector>
  15
  16 #include "CTFTypes.h"
  17 #include "lldb/Symbol/CompileUnit.h"
  18 #include "lldb/Symbol/SymbolFile.h"
  19
  20 namespace lldb_private {
  21
  22 class SymbolFileCTF : public lldb_private::SymbolFileCommon {
  23   /// LLVM RTTI support.
  24   static char ID;
  25
  26 public:
  27   /// LLVM RTTI support.
  28   /// \{
  29   bool isA(const void *ClassID) const override {
  30     return ClassID == &ID || SymbolFileCommon::isA(ClassID);
  31   }
  32   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
  33   /// \}
  34
  35   SymbolFileCTF(lldb::ObjectFileSP objfile_sp);
  36
  37   static void Initialize();
  38
  39   static void Terminate();
  40
  41   static llvm::StringRef GetPluginNameStatic() { return "CTF"; }
  42
  43   static llvm::StringRef GetPluginDescriptionStatic();
  44
  45   static lldb_private::SymbolFile *
  46   CreateInstance(lldb::ObjectFileSP objfile_sp);
  47
  48   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
  49
  50   uint32_t CalculateAbilities() override;
  51
  52   void InitializeObject() override;
  53
  54   lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override {
  55     return lldb::eLanguageTypeUnknown;
  56   }
  57
  58   bool ParseHeader();
  59
  60   size_t ParseFunctions(CompileUnit &comp_unit) override;
  61
  62   size_t ParseObjects(CompileUnit &comp_unit);
  63
  64   bool ParseLineTable(CompileUnit &comp_unit) override { return false; }
  65
  66   bool ParseDebugMacros(CompileUnit &comp_unit) override { return false; }
  67
  68   bool ParseSupportFiles(CompileUnit &comp_unit,
  69                          FileSpecList &support_files) override {
  70     return false;
  71   }
  72
  73   size_t ParseTypes(CompileUnit &cu) override;
  74
  75   bool ParseImportedModules(
  76       const SymbolContext &sc,
  77       std::vector<lldb_private::SourceModule> &imported_modules) override {
  78     return false;
  79   }
  80
  81   size_t ParseBlocksRecursive(Function &func) override { return 0; }
  82
  83   size_t ParseVariablesForContext(const SymbolContext &sc) override;
  84
  85   uint32_t CalculateNumCompileUnits() override { return 0; }
  86
  87   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
  88
  89   Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
  90   std::optional<ArrayInfo> GetDynamicArrayInfoForUID(
  91       lldb::user_id_t type_uid,
  92       const lldb_private::ExecutionContext *exe_ctx) override {
  93     return std::nullopt;
  94   }
  95
  96   bool CompleteType(CompilerType &compiler_type) override;
  97
  98   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
  99                                 lldb::SymbolContextItem resolve_scope,
 100                                 lldb_private::SymbolContext &sc) override;
 101
 102   void AddSymbols(Symtab &symtab) override;
 103
 104   void GetTypes(lldb_private::SymbolContextScope *sc_scope,
 105                 lldb::TypeClass type_mask,
 106                 lldb_private::TypeList &type_list) override {}
 107
 108   void
 109   FindTypes(lldb_private::ConstString name,
 110             const lldb_private::CompilerDeclContext &parent_decl_ctx,
 111             uint32_t max_matches,
 112             llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
 113             lldb_private::TypeMap &types) override;
 114
 115   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
 116                         uint32_t max_matches, lldb_private::TypeMap &types);
 117
 118   void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
 119                      const lldb_private::CompilerDeclContext &parent_decl_ctx,
 120                      bool include_inlines,
 121                      lldb_private::SymbolContextList &sc_list) override;
 122
 123   void FindFunctions(const lldb_private::RegularExpression &regex,
 124                      bool include_inlines,
 125                      lldb_private::SymbolContextList &sc_list) override;
 126
 127   void
 128   FindGlobalVariables(lldb_private::ConstString name,
 129                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
 130                       uint32_t max_matches,
 131                       lldb_private::VariableList &variables) override;
 132
 133   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
 134                            uint32_t max_matches,
 135                            lldb_private::VariableList &variables) override;
 136
 137   enum TypeKind : uint32_t {
 138     eUnknown = 0,
 139     eInteger = 1,
 140     eFloat = 2,
 141     ePointer = 3,
 142     eArray = 4,
 143     eFunction = 5,
 144     eStruct = 6,
 145     eUnion = 7,
 146     eEnum = 8,
 147     eForward = 9,
 148     eTypedef = 10,
 149     eVolatile = 11,
 150     eConst = 12,
 151     eRestrict = 13,
 152     eSlice = 14,
 153   };
 154
 155 private:
 156   enum Flags : uint32_t {
 157     eFlagCompress = (1u << 0),
 158     eFlagNewFuncInfo = (1u << 1),
 159     eFlagIdxSorted = (1u << 2),
 160     eFlagDynStr = (1u << 3),
 161   };
 162
 163   enum IntEncoding : uint32_t {
 164     eSigned = 0x1,
 165     eChar = 0x2,
 166     eBool = 0x4,
 167     eVarArgs = 0x8,
 168   };
 169
 170   struct ctf_preamble_t {
 171     uint16_t magic;
 172     uint8_t version;
 173     uint8_t flags;
 174   };
 175
 176   struct ctf_header_t {
 177     ctf_preamble_t preamble;
 178     uint32_t parlabel;
 179     uint32_t parname;
 180     uint32_t lbloff;
 181     uint32_t objtoff;
 182     uint32_t funcoff;
 183     uint32_t typeoff;
 184     uint32_t stroff;
 185     uint32_t strlen;
 186   };
 187
 188   struct ctf_type_t {
 189     uint32_t name;
 190     uint32_t info;
 191     union {
 192       uint32_t size;
 193       uint32_t type;
 194     };
 195     uint32_t lsizehi;
 196     uint32_t lsizelo;
 197   };
 198
 199   struct ctf_stype_t {
 200     uint32_t name;
 201     uint32_t info;
 202     union {
 203       uint32_t size;
 204       uint32_t type;
 205     };
 206
 207     bool IsLargeType() const { return size == 0xffff; }
 208     uint32_t GetStructSize() const {
 209       if (IsLargeType())
 210         return sizeof(ctf_type_t);
 211       return sizeof(ctf_stype_t);
 212     }
 213     uint32_t GetType() const { return type; }
 214     uint32_t GetSize() const { return size; }
 215   };
 216
 217   llvm::Expected<std::unique_ptr<CTFType>> ParseType(lldb::offset_t &offset,
 218                                                      lldb::user_id_t uid);
 219
 220   llvm::Expected<lldb::TypeSP> CreateType(CTFType *ctf_type);
 221   llvm::Expected<lldb::TypeSP> CreateInteger(const CTFInteger &ctf_integer);
 222   llvm::Expected<lldb::TypeSP> CreateModifier(const CTFModifier &ctf_modifier);
 223   llvm::Expected<lldb::TypeSP> CreateTypedef(const CTFTypedef &ctf_typedef);
 224   llvm::Expected<lldb::TypeSP> CreateArray(const CTFArray &ctf_array);
 225   llvm::Expected<lldb::TypeSP> CreateEnum(const CTFEnum &ctf_enum);
 226   llvm::Expected<lldb::TypeSP> CreateFunction(const CTFFunction &ctf_function);
 227   llvm::Expected<lldb::TypeSP> CreateRecord(const CTFRecord &ctf_record);
 228   llvm::Expected<lldb::TypeSP> CreateForward(const CTFForward &ctf_forward);
 229
 230   llvm::StringRef ReadString(lldb::offset_t offset) const;
 231
 232   std::vector<uint16_t> GetFieldSizes(lldb::offset_t field_offset,
 233                                       uint32_t fields, uint32_t struct_size);
 234
 235   DataExtractor m_data;
 236
 237   /// The start offset of the CTF body into m_data. If the body is uncompressed,
 238   /// m_data contains the header and the body and the body starts after the
 239   /// header. If the body is compressed, m_data only contains the body and the
 240   /// offset is zero.
 241   lldb::offset_t m_body_offset = 0;
 242
 243   TypeSystemClang *m_ast;
 244   lldb::CompUnitSP m_comp_unit_sp;
 245
 246   std::optional<ctf_header_t> m_header;
 247
 248   /// Parsed CTF types.
 249   llvm::DenseMap<lldb::user_id_t, std::unique_ptr<CTFType>> m_ctf_types;
 250
 251   /// Parsed LLDB types.
 252   llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;
 253
 254   /// To complete types, we need a way to map (imcomplete) compiler types back
 255   /// to parsed CTF types.
 256   llvm::DenseMap<lldb::opaque_compiler_type_t, const CTFType *>
 257       m_compiler_types;
 258
 259   std::vector<lldb::FunctionSP> m_functions;
 260   std::vector<lldb::VariableSP> m_variables;
 261
 262   static constexpr uint16_t g_ctf_magic = 0xcff1;
 263   static constexpr uint8_t g_ctf_version = 4;
 264   static constexpr uint16_t g_ctf_field_threshold = 0x2000;
 265 };
 266 } // namespace lldb_private
 267
 268 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H