1//===-- SymbolFileOnDemand.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_SYMBOL_SYMBOLFILEONDEMAND_H
10#define LLDB_SYMBOL_SYMBOLFILEONDEMAND_H
11
12#include <mutex>
13#include <optional>
14#include <vector>
15
16#include "lldb/Symbol/ObjectFile.h"
17#include "lldb/Symbol/SymbolContext.h"
18#include "lldb/Symbol/SymbolFile.h"
19#include "lldb/Target/Statistics.h"
20#include "lldb/Utility/ConstString.h"
21#include "lldb/Utility/Flags.h"
22#include "lldb/Utility/LLDBLog.h"
23#include "lldb/Utility/Log.h"
24#include "lldb/lldb-private.h"
25
26namespace lldb_private {
27
28/// SymbolFileOnDemand wraps an actual SymbolFile by providing
29/// on demand symbol parsing/indexing to improve performance.
30/// By default SymbolFileOnDemand will skip load the underlying
31/// symbols. Any client can on demand hydrate the underlying
32/// SymbolFile via SymbolFile::SetLoadDebugInfoEnabled().
33class SymbolFileOnDemand : public lldb_private::SymbolFile {
34 /// LLVM RTTI support.
35 static char ID;
36
37public:
38 /// LLVM RTTI support.
39 /// \{
40 bool isA(const void *ClassID) const override {
41 return ClassID == &ID || SymbolFile::isA(ClassID);
42 }
43 static bool classof(const SymbolFile *obj) { return obj->isA(ClassID: &ID); }
44 /// \}
45
46 SymbolFileOnDemand(std::unique_ptr<SymbolFile> &&symbol_file);
47 ~SymbolFileOnDemand() override;
48
49 // PluginInterface protocol
50 llvm::StringRef GetPluginName() override { return "ondemand"; }
51
52 bool GetLoadDebugInfoEnabled() override { return m_debug_info_enabled; }
53
54 void SetLoadDebugInfoEnabled() override;
55
56 uint32_t GetNumCompileUnits() override;
57 lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override;
58
59 SymbolFile *GetBackingSymbolFile() override { return m_sym_file_impl.get(); }
60
61 uint32_t CalculateAbilities() override;
62
63 std::recursive_mutex &GetModuleMutex() const override;
64
65 lldb::LanguageType
66 ParseLanguage(lldb_private::CompileUnit &comp_unit) override;
67
68 lldb_private::XcodeSDK
69 ParseXcodeSDK(lldb_private::CompileUnit &comp_unit) override;
70
71 void InitializeObject() override;
72
73 size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;
74
75 bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;
76
77 bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;
78
79 bool ForEachExternalModule(
80 lldb_private::CompileUnit &, llvm::DenseSet<lldb_private::SymbolFile *> &,
81 llvm::function_ref<bool(lldb_private::Module &)>) override;
82
83 bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,
84 lldb_private::SupportFileList &support_files) override;
85
86 bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override;
87
88 size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
89
90 bool ParseImportedModules(
91 const lldb_private::SymbolContext &sc,
92 std::vector<lldb_private::SourceModule> &imported_modules) override;
93
94 size_t ParseBlocksRecursive(lldb_private::Function &func) override;
95
96 size_t
97 ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
98
99 lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
100 std::optional<ArrayInfo> GetDynamicArrayInfoForUID(
101 lldb::user_id_t type_uid,
102 const lldb_private::ExecutionContext *exe_ctx) override;
103
104 bool CompleteType(lldb_private::CompilerType &compiler_type) override;
105
106 lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
107
108 lldb_private::CompilerDeclContext
109 GetDeclContextForUID(lldb::user_id_t uid) override;
110
111 lldb_private::CompilerDeclContext
112 GetDeclContextContainingUID(lldb::user_id_t uid) override;
113
114 void
115 ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
116
117 uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
118 lldb::SymbolContextItem resolve_scope,
119 lldb_private::SymbolContext &sc) override;
120
121 lldb_private::Status
122 CalculateFrameVariableError(lldb_private::StackFrame &frame) override;
123
124 uint32_t ResolveSymbolContext(
125 const lldb_private::SourceLocationSpec &src_location_spec,
126 lldb::SymbolContextItem resolve_scope,
127 lldb_private::SymbolContextList &sc_list) override;
128
129 void Dump(lldb_private::Stream &s) override;
130 void DumpClangAST(lldb_private::Stream &s) override;
131
132 void
133 FindGlobalVariables(lldb_private::ConstString name,
134 const lldb_private::CompilerDeclContext &parent_decl_ctx,
135 uint32_t max_matches,
136 lldb_private::VariableList &variables) override;
137
138 void FindGlobalVariables(const lldb_private::RegularExpression &regex,
139 uint32_t max_matches,
140 lldb_private::VariableList &variables) override;
141
142 void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,
143 const lldb_private::CompilerDeclContext &parent_decl_ctx,
144 bool include_inlines,
145 lldb_private::SymbolContextList &sc_list) override;
146
147 void FindFunctions(const lldb_private::RegularExpression &regex,
148 bool include_inlines,
149 lldb_private::SymbolContextList &sc_list) override;
150
151 void GetMangledNamesForFunction(
152 const std::string &scope_qualified_name,
153 std::vector<lldb_private::ConstString> &mangled_names) override;
154
155 void FindTypes(const lldb_private::TypeQuery &query,
156 lldb_private::TypeResults &results) override;
157
158 void GetTypes(lldb_private::SymbolContextScope *sc_scope,
159 lldb::TypeClass type_mask,
160 lldb_private::TypeList &type_list) override;
161
162 llvm::Expected<lldb::TypeSystemSP>
163 GetTypeSystemForLanguage(lldb::LanguageType language) override;
164
165 lldb_private::CompilerDeclContext
166 FindNamespace(lldb_private::ConstString name,
167 const lldb_private::CompilerDeclContext &parent_decl_ctx,
168 bool only_root_namespaces) override;
169
170 std::vector<std::unique_ptr<lldb_private::CallEdge>>
171 ParseCallEdgesInFunction(UserID func_id) override;
172
173 lldb::UnwindPlanSP
174 GetUnwindPlan(const Address &address,
175 const RegisterInfoResolver &resolver) override;
176
177 llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) override;
178
179 void PreloadSymbols() override;
180
181 uint64_t GetDebugInfoSize(bool load_all_debug_info = false) override;
182 lldb_private::StatsDuration::Duration GetDebugInfoParseTime() override;
183 lldb_private::StatsDuration::Duration GetDebugInfoIndexTime() override;
184
185 uint32_t GetAbilities() override;
186
187 Symtab *GetSymtab() override { return m_sym_file_impl->GetSymtab(); }
188
189 ObjectFile *GetObjectFile() override {
190 return m_sym_file_impl->GetObjectFile();
191 }
192 const ObjectFile *GetObjectFile() const override {
193 return m_sym_file_impl->GetObjectFile();
194 }
195 ObjectFile *GetMainObjectFile() override {
196 return m_sym_file_impl->GetMainObjectFile();
197 }
198
199 void SectionFileAddressesChanged() override {
200 return m_sym_file_impl->SectionFileAddressesChanged();
201 }
202
203 bool GetDebugInfoIndexWasLoadedFromCache() const override {
204 return m_sym_file_impl->GetDebugInfoIndexWasLoadedFromCache();
205 }
206 void SetDebugInfoIndexWasLoadedFromCache() override {
207 m_sym_file_impl->SetDebugInfoIndexWasLoadedFromCache();
208 }
209 bool GetDebugInfoIndexWasSavedToCache() const override {
210 return m_sym_file_impl->GetDebugInfoIndexWasSavedToCache();
211 }
212 void SetDebugInfoIndexWasSavedToCache() override {
213 m_sym_file_impl->SetDebugInfoIndexWasSavedToCache();
214 }
215 bool GetDebugInfoHadFrameVariableErrors() const override {
216 return m_sym_file_impl->GetDebugInfoHadFrameVariableErrors();
217 }
218 void SetDebugInfoHadFrameVariableErrors() override {
219 return m_sym_file_impl->SetDebugInfoHadFrameVariableErrors();
220 }
221
222 bool GetSeparateDebugInfo(StructuredData::Dictionary &d,
223 bool errors_only) override {
224 return m_sym_file_impl->GetSeparateDebugInfo(d, errors_only);
225 }
226
227 lldb::TypeSP MakeType(lldb::user_id_t uid, ConstString name,
228 std::optional<uint64_t> byte_size,
229 SymbolContextScope *context,
230 lldb::user_id_t encoding_uid,
231 Type::EncodingDataType encoding_uid_type,
232 const Declaration &decl,
233 const CompilerType &compiler_qual_type,
234 Type::ResolveState compiler_type_resolve_state,
235 uint32_t opaque_payload = 0) override {
236 return m_sym_file_impl->MakeType(
237 uid, name, byte_size, context, encoding_uid, encoding_uid_type, decl,
238 compiler_qual_type, compiler_type_resolve_state, opaque_payload);
239 }
240
241 lldb::TypeSP CopyType(const lldb::TypeSP &other_type) override {
242 return m_sym_file_impl->CopyType(other_type);
243 }
244
245private:
246 Log *GetLog() const { return ::lldb_private::GetLog(mask: LLDBLog::OnDemand); }
247
248 ConstString GetSymbolFileName() {
249 return GetObjectFile()->GetFileSpec().GetFilename();
250 }
251
252private:
253 bool m_debug_info_enabled = false;
254 bool m_preload_symbols = false;
255 std::unique_ptr<SymbolFile> m_sym_file_impl;
256};
257} // namespace lldb_private
258
259#endif // LLDB_SYMBOL_SYMBOLFILEONDEMAND_H
260

source code of lldb/include/lldb/Symbol/SymbolFileOnDemand.h