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
20namespace lldb_private {
21
22class SymbolFileCTF : public lldb_private::SymbolFileCommon {
23 /// LLVM RTTI support.
24 static char ID;
25
26public:
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(ClassID: &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 SupportFileList &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 FindTypes(const lldb_private::TypeQuery &match,
109 lldb_private::TypeResults &results) override;
110
111 void FindTypesByRegex(const lldb_private::RegularExpression &regex,
112 uint32_t max_matches, lldb_private::TypeMap &types);
113
114 void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
115 const lldb_private::CompilerDeclContext &parent_decl_ctx,
116 bool include_inlines,
117 lldb_private::SymbolContextList &sc_list) override;
118
119 void FindFunctions(const lldb_private::RegularExpression &regex,
120 bool include_inlines,
121 lldb_private::SymbolContextList &sc_list) override;
122
123 void
124 FindGlobalVariables(lldb_private::ConstString name,
125 const lldb_private::CompilerDeclContext &parent_decl_ctx,
126 uint32_t max_matches,
127 lldb_private::VariableList &variables) override;
128
129 void FindGlobalVariables(const lldb_private::RegularExpression &regex,
130 uint32_t max_matches,
131 lldb_private::VariableList &variables) override;
132
133 enum TypeKind : uint32_t {
134 eUnknown = 0,
135 eInteger = 1,
136 eFloat = 2,
137 ePointer = 3,
138 eArray = 4,
139 eFunction = 5,
140 eStruct = 6,
141 eUnion = 7,
142 eEnum = 8,
143 eForward = 9,
144 eTypedef = 10,
145 eVolatile = 11,
146 eConst = 12,
147 eRestrict = 13,
148 eSlice = 14,
149 };
150
151private:
152 enum Flags : uint32_t {
153 eFlagCompress = (1u << 0),
154 eFlagNewFuncInfo = (1u << 1),
155 eFlagIdxSorted = (1u << 2),
156 eFlagDynStr = (1u << 3),
157 };
158
159 enum IntEncoding : uint32_t {
160 eSigned = 0x1,
161 eChar = 0x2,
162 eBool = 0x4,
163 eVarArgs = 0x8,
164 };
165
166 struct ctf_preamble_t {
167 uint16_t magic;
168 uint8_t version;
169 uint8_t flags;
170 };
171
172 struct ctf_header_t {
173 ctf_preamble_t preamble;
174 uint32_t parlabel;
175 uint32_t parname;
176 uint32_t lbloff;
177 uint32_t objtoff;
178 uint32_t funcoff;
179 uint32_t typeoff;
180 uint32_t stroff;
181 uint32_t strlen;
182 };
183
184 struct ctf_type_t {
185 uint32_t name;
186 uint32_t info;
187 union {
188 uint32_t size;
189 uint32_t type;
190 };
191 uint32_t lsizehi;
192 uint32_t lsizelo;
193 };
194
195 struct ctf_stype_t {
196 uint32_t name;
197 uint32_t info;
198 union {
199 uint32_t size;
200 uint32_t type;
201 };
202
203 bool IsLargeType() const { return size == 0xffff; }
204 uint32_t GetStructSize() const {
205 if (IsLargeType())
206 return sizeof(ctf_type_t);
207 return sizeof(ctf_stype_t);
208 }
209 uint32_t GetType() const { return type; }
210 uint32_t GetSize() const { return size; }
211 };
212
213 llvm::Expected<std::unique_ptr<CTFType>> ParseType(lldb::offset_t &offset,
214 lldb::user_id_t uid);
215
216 llvm::Expected<lldb::TypeSP> CreateType(CTFType *ctf_type);
217 llvm::Expected<lldb::TypeSP> CreateInteger(const CTFInteger &ctf_integer);
218 llvm::Expected<lldb::TypeSP> CreateModifier(const CTFModifier &ctf_modifier);
219 llvm::Expected<lldb::TypeSP> CreateTypedef(const CTFTypedef &ctf_typedef);
220 llvm::Expected<lldb::TypeSP> CreateArray(const CTFArray &ctf_array);
221 llvm::Expected<lldb::TypeSP> CreateEnum(const CTFEnum &ctf_enum);
222 llvm::Expected<lldb::TypeSP> CreateFunction(const CTFFunction &ctf_function);
223 llvm::Expected<lldb::TypeSP> CreateRecord(const CTFRecord &ctf_record);
224 llvm::Expected<lldb::TypeSP> CreateForward(const CTFForward &ctf_forward);
225
226 llvm::StringRef ReadString(lldb::offset_t offset) const;
227
228 std::vector<uint16_t> GetFieldSizes(lldb::offset_t field_offset,
229 uint32_t fields, uint32_t struct_size);
230
231 DataExtractor m_data;
232
233 /// The start offset of the CTF body into m_data. If the body is uncompressed,
234 /// m_data contains the header and the body and the body starts after the
235 /// header. If the body is compressed, m_data only contains the body and the
236 /// offset is zero.
237 lldb::offset_t m_body_offset = 0;
238
239 TypeSystemClang *m_ast;
240 lldb::CompUnitSP m_comp_unit_sp;
241
242 std::optional<ctf_header_t> m_header;
243
244 /// Parsed CTF types.
245 llvm::DenseMap<lldb::user_id_t, std::unique_ptr<CTFType>> m_ctf_types;
246
247 /// Parsed LLDB types.
248 llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;
249
250 /// To complete types, we need a way to map (imcomplete) compiler types back
251 /// to parsed CTF types.
252 llvm::DenseMap<lldb::opaque_compiler_type_t, const CTFType *>
253 m_compiler_types;
254
255 std::vector<lldb::FunctionSP> m_functions;
256 std::vector<lldb::VariableSP> m_variables;
257
258 static constexpr uint16_t g_ctf_magic = 0xcff1;
259 static constexpr uint8_t g_ctf_version = 4;
260 static constexpr uint16_t g_ctf_field_threshold = 0x2000;
261};
262} // namespace lldb_private
263
264#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_CTF_SYMBOLFILECTF_H
265

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