1 //===-- SymbolFileDWARFDebugMap.cpp ---------------------------------------===//
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 #include "lldb/Symbol/SymbolFileOnDemand.h"
10
11 #include "lldb/Core/Module.h"
12 #include "lldb/Symbol/SymbolFile.h"
13
14 #include <memory>
15 #include <optional>
16
17 using namespace lldb;
18 using namespace lldb_private;
19
20 char SymbolFileOnDemand::ID;
21
SymbolFileOnDemand(std::unique_ptr<SymbolFile> && symbol_file)22 SymbolFileOnDemand::SymbolFileOnDemand(
23 std::unique_ptr<SymbolFile> &&symbol_file)
24 : m_sym_file_impl(std::move(symbol_file)) {}
25
26 SymbolFileOnDemand::~SymbolFileOnDemand() = default;
27
CalculateAbilities()28 uint32_t SymbolFileOnDemand::CalculateAbilities() {
29 // Explicitly allow ability checking to pass though.
30 // This should be a cheap operation.
31 return m_sym_file_impl->CalculateAbilities();
32 }
33
GetModuleMutex() const34 std::recursive_mutex &SymbolFileOnDemand::GetModuleMutex() const {
35 return m_sym_file_impl->GetModuleMutex();
36 }
37
InitializeObject()38 void SymbolFileOnDemand::InitializeObject() {
39 if (!m_debug_info_enabled) {
40 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
41 __FUNCTION__);
42 return;
43 }
44 return m_sym_file_impl->InitializeObject();
45 }
46
ParseLanguage(CompileUnit & comp_unit)47 lldb::LanguageType SymbolFileOnDemand::ParseLanguage(CompileUnit &comp_unit) {
48 if (!m_debug_info_enabled) {
49 Log *log = GetLog();
50 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
51 if (log) {
52 lldb::LanguageType langType = m_sym_file_impl->ParseLanguage(comp_unit);
53 if (langType != eLanguageTypeUnknown)
54 LLDB_LOG(log, "Language {0} would return if hydrated.", langType);
55 }
56 return eLanguageTypeUnknown;
57 }
58 return m_sym_file_impl->ParseLanguage(comp_unit);
59 }
60
ParseXcodeSDK(CompileUnit & comp_unit)61 XcodeSDK SymbolFileOnDemand::ParseXcodeSDK(CompileUnit &comp_unit) {
62 if (!m_debug_info_enabled) {
63 Log *log = GetLog();
64 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
65 XcodeSDK defaultValue{};
66 if (log) {
67 XcodeSDK sdk = m_sym_file_impl->ParseXcodeSDK(comp_unit);
68 if (!(sdk == defaultValue))
69 LLDB_LOG(log, "SDK {0} would return if hydrated.", sdk.GetString());
70 }
71 return defaultValue;
72 }
73 return m_sym_file_impl->ParseXcodeSDK(comp_unit);
74 }
75
ParseFunctions(CompileUnit & comp_unit)76 size_t SymbolFileOnDemand::ParseFunctions(CompileUnit &comp_unit) {
77 if (!m_debug_info_enabled) {
78 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
79 __FUNCTION__);
80 return 0;
81 }
82 return m_sym_file_impl->ParseFunctions(comp_unit);
83 }
84
ParseLineTable(CompileUnit & comp_unit)85 bool SymbolFileOnDemand::ParseLineTable(CompileUnit &comp_unit) {
86 if (!m_debug_info_enabled) {
87 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
88 __FUNCTION__);
89 return false;
90 }
91 return m_sym_file_impl->ParseLineTable(comp_unit);
92 }
93
ParseDebugMacros(CompileUnit & comp_unit)94 bool SymbolFileOnDemand::ParseDebugMacros(CompileUnit &comp_unit) {
95 if (!m_debug_info_enabled) {
96 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
97 __FUNCTION__);
98 return false;
99 }
100 return m_sym_file_impl->ParseDebugMacros(comp_unit);
101 }
102
ForEachExternalModule(CompileUnit & comp_unit,llvm::DenseSet<lldb_private::SymbolFile * > & visited_symbol_files,llvm::function_ref<bool (Module &)> lambda)103 bool SymbolFileOnDemand::ForEachExternalModule(
104 CompileUnit &comp_unit,
105 llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
106 llvm::function_ref<bool(Module &)> lambda) {
107 if (!m_debug_info_enabled) {
108 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
109 __FUNCTION__);
110 // Return false to not early exit.
111 return false;
112 }
113 return m_sym_file_impl->ForEachExternalModule(comp_unit, visited_symbol_files,
114 lambda);
115 }
116
ParseSupportFiles(CompileUnit & comp_unit,FileSpecList & support_files)117 bool SymbolFileOnDemand::ParseSupportFiles(CompileUnit &comp_unit,
118 FileSpecList &support_files) {
119 LLDB_LOG(GetLog(),
120 "[{0}] {1} is not skipped: explicitly allowed to support breakpoint",
121 GetSymbolFileName(), __FUNCTION__);
122 // Explicitly allow this API through to support source line breakpoint.
123 return m_sym_file_impl->ParseSupportFiles(comp_unit, support_files);
124 }
125
ParseIsOptimized(CompileUnit & comp_unit)126 bool SymbolFileOnDemand::ParseIsOptimized(CompileUnit &comp_unit) {
127 if (!m_debug_info_enabled) {
128 Log *log = GetLog();
129 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
130 if (log) {
131 bool optimized = m_sym_file_impl->ParseIsOptimized(comp_unit);
132 if (optimized) {
133 LLDB_LOG(log, "Would return optimized if hydrated.");
134 }
135 }
136 return false;
137 }
138 return m_sym_file_impl->ParseIsOptimized(comp_unit);
139 }
140
ParseTypes(CompileUnit & comp_unit)141 size_t SymbolFileOnDemand::ParseTypes(CompileUnit &comp_unit) {
142 if (!m_debug_info_enabled) {
143 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
144 __FUNCTION__);
145 return 0;
146 }
147 return m_sym_file_impl->ParseTypes(comp_unit);
148 }
149
ParseImportedModules(const lldb_private::SymbolContext & sc,std::vector<SourceModule> & imported_modules)150 bool SymbolFileOnDemand::ParseImportedModules(
151 const lldb_private::SymbolContext &sc,
152 std::vector<SourceModule> &imported_modules) {
153 if (!m_debug_info_enabled) {
154 Log *log = GetLog();
155 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
156 if (log) {
157 std::vector<SourceModule> tmp_imported_modules;
158 bool succeed =
159 m_sym_file_impl->ParseImportedModules(sc, tmp_imported_modules);
160 if (succeed)
161 LLDB_LOG(log, "{0} imported modules would be parsed if hydrated.",
162 tmp_imported_modules.size());
163 }
164 return false;
165 }
166 return m_sym_file_impl->ParseImportedModules(sc, imported_modules);
167 }
168
ParseBlocksRecursive(Function & func)169 size_t SymbolFileOnDemand::ParseBlocksRecursive(Function &func) {
170 if (!m_debug_info_enabled) {
171 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
172 __FUNCTION__);
173 return 0;
174 }
175 return m_sym_file_impl->ParseBlocksRecursive(func);
176 }
177
ParseVariablesForContext(const SymbolContext & sc)178 size_t SymbolFileOnDemand::ParseVariablesForContext(const SymbolContext &sc) {
179 if (!m_debug_info_enabled) {
180 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
181 __FUNCTION__);
182 return 0;
183 }
184 return m_sym_file_impl->ParseVariablesForContext(sc);
185 }
186
ResolveTypeUID(lldb::user_id_t type_uid)187 Type *SymbolFileOnDemand::ResolveTypeUID(lldb::user_id_t type_uid) {
188 if (!m_debug_info_enabled) {
189 Log *log = GetLog();
190 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
191 if (log) {
192 Type *resolved_type = m_sym_file_impl->ResolveTypeUID(type_uid);
193 if (resolved_type)
194 LLDB_LOG(log, "Type would be parsed for {0} if hydrated.", type_uid);
195 }
196 return nullptr;
197 }
198 return m_sym_file_impl->ResolveTypeUID(type_uid);
199 }
200
201 std::optional<SymbolFile::ArrayInfo>
GetDynamicArrayInfoForUID(lldb::user_id_t type_uid,const lldb_private::ExecutionContext * exe_ctx)202 SymbolFileOnDemand::GetDynamicArrayInfoForUID(
203 lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
204 if (!m_debug_info_enabled) {
205 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
206 __FUNCTION__);
207 return std::nullopt;
208 }
209 return m_sym_file_impl->GetDynamicArrayInfoForUID(type_uid, exe_ctx);
210 }
211
CompleteType(CompilerType & compiler_type)212 bool SymbolFileOnDemand::CompleteType(CompilerType &compiler_type) {
213 if (!m_debug_info_enabled) {
214 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
215 __FUNCTION__);
216 return false;
217 }
218 return m_sym_file_impl->CompleteType(compiler_type);
219 }
220
GetDeclForUID(lldb::user_id_t type_uid)221 CompilerDecl SymbolFileOnDemand::GetDeclForUID(lldb::user_id_t type_uid) {
222 if (!m_debug_info_enabled) {
223 Log *log = GetLog();
224 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
225 if (log) {
226 CompilerDecl parsed_decl = m_sym_file_impl->GetDeclForUID(type_uid);
227 if (parsed_decl != CompilerDecl()) {
228 LLDB_LOG(log, "CompilerDecl {0} would be parsed for {1} if hydrated.",
229 parsed_decl.GetName(), type_uid);
230 }
231 }
232 return CompilerDecl();
233 }
234 return m_sym_file_impl->GetDeclForUID(type_uid);
235 }
236
237 CompilerDeclContext
GetDeclContextForUID(lldb::user_id_t type_uid)238 SymbolFileOnDemand::GetDeclContextForUID(lldb::user_id_t type_uid) {
239 if (!m_debug_info_enabled) {
240 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
241 __FUNCTION__);
242 return CompilerDeclContext();
243 }
244 return m_sym_file_impl->GetDeclContextForUID(type_uid);
245 }
246
247 CompilerDeclContext
GetDeclContextContainingUID(lldb::user_id_t type_uid)248 SymbolFileOnDemand::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
249 if (!m_debug_info_enabled) {
250 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
251 __FUNCTION__);
252 return CompilerDeclContext();
253 }
254 return m_sym_file_impl->GetDeclContextContainingUID(type_uid);
255 }
256
ParseDeclsForContext(CompilerDeclContext decl_ctx)257 void SymbolFileOnDemand::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
258 if (!m_debug_info_enabled) {
259 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
260 __FUNCTION__);
261 return;
262 }
263 return m_sym_file_impl->ParseDeclsForContext(decl_ctx);
264 }
265
266 uint32_t
ResolveSymbolContext(const Address & so_addr,SymbolContextItem resolve_scope,SymbolContext & sc)267 SymbolFileOnDemand::ResolveSymbolContext(const Address &so_addr,
268 SymbolContextItem resolve_scope,
269 SymbolContext &sc) {
270 if (!m_debug_info_enabled) {
271 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
272 __FUNCTION__);
273 return 0;
274 }
275 return m_sym_file_impl->ResolveSymbolContext(so_addr, resolve_scope, sc);
276 }
277
CalculateFrameVariableError(StackFrame & frame)278 Status SymbolFileOnDemand::CalculateFrameVariableError(StackFrame &frame) {
279 if (!m_debug_info_enabled) {
280 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
281 __FUNCTION__);
282 return Status();
283 }
284 return m_sym_file_impl->CalculateFrameVariableError(frame);
285 }
286
ResolveSymbolContext(const SourceLocationSpec & src_location_spec,SymbolContextItem resolve_scope,SymbolContextList & sc_list)287 uint32_t SymbolFileOnDemand::ResolveSymbolContext(
288 const SourceLocationSpec &src_location_spec,
289 SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
290 if (!m_debug_info_enabled) {
291 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
292 __FUNCTION__);
293 return 0;
294 }
295 return m_sym_file_impl->ResolveSymbolContext(src_location_spec, resolve_scope,
296 sc_list);
297 }
298
Dump(lldb_private::Stream & s)299 void SymbolFileOnDemand::Dump(lldb_private::Stream &s) {
300 if (!m_debug_info_enabled) {
301 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
302 __FUNCTION__);
303 return;
304 }
305 return m_sym_file_impl->Dump(s);
306 }
307
DumpClangAST(lldb_private::Stream & s)308 void SymbolFileOnDemand::DumpClangAST(lldb_private::Stream &s) {
309 if (!m_debug_info_enabled) {
310 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
311 __FUNCTION__);
312 return;
313 }
314 return m_sym_file_impl->DumpClangAST(s);
315 }
316
FindGlobalVariables(const RegularExpression & regex,uint32_t max_matches,VariableList & variables)317 void SymbolFileOnDemand::FindGlobalVariables(const RegularExpression ®ex,
318 uint32_t max_matches,
319 VariableList &variables) {
320 if (!m_debug_info_enabled) {
321 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
322 __FUNCTION__);
323 return;
324 }
325 return m_sym_file_impl->FindGlobalVariables(regex, max_matches, variables);
326 }
327
FindGlobalVariables(ConstString name,const CompilerDeclContext & parent_decl_ctx,uint32_t max_matches,VariableList & variables)328 void SymbolFileOnDemand::FindGlobalVariables(
329 ConstString name, const CompilerDeclContext &parent_decl_ctx,
330 uint32_t max_matches, VariableList &variables) {
331 if (!m_debug_info_enabled) {
332 Log *log = GetLog();
333 Symtab *symtab = GetSymtab();
334 if (!symtab) {
335 LLDB_LOG(log, "[{0}] {1} is skipped - fail to get symtab",
336 GetSymbolFileName(), __FUNCTION__);
337 return;
338 }
339 Symbol *sym = symtab->FindFirstSymbolWithNameAndType(
340 name, eSymbolTypeData, Symtab::eDebugAny, Symtab::eVisibilityAny);
341 if (!sym) {
342 LLDB_LOG(log, "[{0}] {1} is skipped - fail to find match in symtab",
343 GetSymbolFileName(), __FUNCTION__);
344 return;
345 }
346 LLDB_LOG(log, "[{0}] {1} is NOT skipped - found match in symtab",
347 GetSymbolFileName(), __FUNCTION__);
348
349 // Found match in symbol table hydrate debug info and
350 // allow the FindGlobalVariables to go through.
351 SetLoadDebugInfoEnabled();
352 }
353 return m_sym_file_impl->FindGlobalVariables(name, parent_decl_ctx,
354 max_matches, variables);
355 }
356
FindFunctions(const RegularExpression & regex,bool include_inlines,SymbolContextList & sc_list)357 void SymbolFileOnDemand::FindFunctions(const RegularExpression ®ex,
358 bool include_inlines,
359 SymbolContextList &sc_list) {
360 if (!m_debug_info_enabled) {
361 Log *log = GetLog();
362 Symtab *symtab = GetSymtab();
363 if (!symtab) {
364 LLDB_LOG(log, "[{0}] {1} is skipped - fail to get symtab",
365 GetSymbolFileName(), __FUNCTION__);
366 return;
367 }
368 std::vector<uint32_t> symbol_indexes;
369 symtab->AppendSymbolIndexesMatchingRegExAndType(
370 regex, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny,
371 symbol_indexes);
372 if (symbol_indexes.empty()) {
373 LLDB_LOG(log, "[{0}] {1} is skipped - fail to find match in symtab",
374 GetSymbolFileName(), __FUNCTION__);
375 return;
376 }
377 LLDB_LOG(log, "[{0}] {1} is NOT skipped - found match in symtab",
378 GetSymbolFileName(), __FUNCTION__);
379
380 // Found match in symbol table hydrate debug info and
381 // allow the FindFucntions to go through.
382 SetLoadDebugInfoEnabled();
383 }
384 return m_sym_file_impl->FindFunctions(regex, include_inlines, sc_list);
385 }
386
FindFunctions(const Module::LookupInfo & lookup_info,const CompilerDeclContext & parent_decl_ctx,bool include_inlines,SymbolContextList & sc_list)387 void SymbolFileOnDemand::FindFunctions(
388 const Module::LookupInfo &lookup_info,
389 const CompilerDeclContext &parent_decl_ctx, bool include_inlines,
390 SymbolContextList &sc_list) {
391 ConstString name = lookup_info.GetLookupName();
392 FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
393 if (!m_debug_info_enabled) {
394 Log *log = GetLog();
395
396 Symtab *symtab = GetSymtab();
397 if (!symtab) {
398 LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to get symtab",
399 GetSymbolFileName(), __FUNCTION__, name);
400 return;
401 }
402
403 SymbolContextList sc_list_helper;
404 symtab->FindFunctionSymbols(name, name_type_mask, sc_list_helper);
405 if (sc_list_helper.GetSize() == 0) {
406 LLDB_LOG(log, "[{0}] {1}({2}) is skipped - fail to find match in symtab",
407 GetSymbolFileName(), __FUNCTION__, name);
408 return;
409 }
410 LLDB_LOG(log, "[{0}] {1}({2}) is NOT skipped - found match in symtab",
411 GetSymbolFileName(), __FUNCTION__, name);
412
413 // Found match in symbol table hydrate debug info and
414 // allow the FindFucntions to go through.
415 SetLoadDebugInfoEnabled();
416 }
417 return m_sym_file_impl->FindFunctions(lookup_info, parent_decl_ctx,
418 include_inlines, sc_list);
419 }
420
GetMangledNamesForFunction(const std::string & scope_qualified_name,std::vector<ConstString> & mangled_names)421 void SymbolFileOnDemand::GetMangledNamesForFunction(
422 const std::string &scope_qualified_name,
423 std::vector<ConstString> &mangled_names) {
424 if (!m_debug_info_enabled) {
425 Log *log = GetLog();
426 LLDB_LOG(log, "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
427 __FUNCTION__, scope_qualified_name);
428 return;
429 }
430 return m_sym_file_impl->GetMangledNamesForFunction(scope_qualified_name,
431 mangled_names);
432 }
433
FindTypes(ConstString name,const CompilerDeclContext & parent_decl_ctx,uint32_t max_matches,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeMap & types)434 void SymbolFileOnDemand::FindTypes(
435 ConstString name, const CompilerDeclContext &parent_decl_ctx,
436 uint32_t max_matches,
437 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
438 TypeMap &types) {
439 if (!m_debug_info_enabled) {
440 Log *log = GetLog();
441 LLDB_LOG(log, "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
442 __FUNCTION__, name);
443 return;
444 }
445 return m_sym_file_impl->FindTypes(name, parent_decl_ctx, max_matches,
446 searched_symbol_files, types);
447 }
448
FindTypes(llvm::ArrayRef<CompilerContext> pattern,LanguageSet languages,llvm::DenseSet<SymbolFile * > & searched_symbol_files,TypeMap & types)449 void SymbolFileOnDemand::FindTypes(
450 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
451 llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
452 if (!m_debug_info_enabled) {
453 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
454 __FUNCTION__);
455 return;
456 }
457 return m_sym_file_impl->FindTypes(pattern, languages, searched_symbol_files,
458 types);
459 }
460
GetTypes(SymbolContextScope * sc_scope,TypeClass type_mask,TypeList & type_list)461 void SymbolFileOnDemand::GetTypes(SymbolContextScope *sc_scope,
462 TypeClass type_mask, TypeList &type_list) {
463 if (!m_debug_info_enabled) {
464 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
465 __FUNCTION__);
466 return;
467 }
468 return m_sym_file_impl->GetTypes(sc_scope, type_mask, type_list);
469 }
470
471 llvm::Expected<lldb::TypeSystemSP>
GetTypeSystemForLanguage(LanguageType language)472 SymbolFileOnDemand::GetTypeSystemForLanguage(LanguageType language) {
473 if (!m_debug_info_enabled) {
474 Log *log = GetLog();
475 LLDB_LOG(log, "[{0}] {1} is skipped for language type {2}",
476 GetSymbolFileName(), __FUNCTION__, language);
477 return llvm::make_error<llvm::StringError>(
478 "GetTypeSystemForLanguage is skipped by SymbolFileOnDemand",
479 llvm::inconvertibleErrorCode());
480 }
481 return m_sym_file_impl->GetTypeSystemForLanguage(language);
482 }
483
484 CompilerDeclContext
FindNamespace(ConstString name,const CompilerDeclContext & parent_decl_ctx)485 SymbolFileOnDemand::FindNamespace(ConstString name,
486 const CompilerDeclContext &parent_decl_ctx) {
487 if (!m_debug_info_enabled) {
488 LLDB_LOG(GetLog(), "[{0}] {1}({2}) is skipped", GetSymbolFileName(),
489 __FUNCTION__, name);
490 return SymbolFile::FindNamespace(name, parent_decl_ctx);
491 }
492 return m_sym_file_impl->FindNamespace(name, parent_decl_ctx);
493 }
494
495 std::vector<std::unique_ptr<lldb_private::CallEdge>>
ParseCallEdgesInFunction(UserID func_id)496 SymbolFileOnDemand::ParseCallEdgesInFunction(UserID func_id) {
497 if (!m_debug_info_enabled) {
498 Log *log = GetLog();
499 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
500 if (log) {
501 std::vector<std::unique_ptr<lldb_private::CallEdge>> call_edges =
502 m_sym_file_impl->ParseCallEdgesInFunction(func_id);
503 if (call_edges.size() > 0) {
504 LLDB_LOG(log, "{0} call edges would be parsed for {1} if hydrated.",
505 call_edges.size(), func_id.GetID());
506 }
507 }
508 return {};
509 }
510 return m_sym_file_impl->ParseCallEdgesInFunction(func_id);
511 }
512
513 lldb::UnwindPlanSP
GetUnwindPlan(const Address & address,const RegisterInfoResolver & resolver)514 SymbolFileOnDemand::GetUnwindPlan(const Address &address,
515 const RegisterInfoResolver &resolver) {
516 if (!m_debug_info_enabled) {
517 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
518 __FUNCTION__);
519 return nullptr;
520 }
521 return m_sym_file_impl->GetUnwindPlan(address, resolver);
522 }
523
524 llvm::Expected<lldb::addr_t>
GetParameterStackSize(Symbol & symbol)525 SymbolFileOnDemand::GetParameterStackSize(Symbol &symbol) {
526 if (!m_debug_info_enabled) {
527 Log *log = GetLog();
528 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__);
529 if (log) {
530 llvm::Expected<lldb::addr_t> stack_size =
531 m_sym_file_impl->GetParameterStackSize(symbol);
532 if (stack_size) {
533 LLDB_LOG(log, "{0} stack size would return for symbol {1} if hydrated.",
534 *stack_size, symbol.GetName());
535 }
536 }
537 return SymbolFile::GetParameterStackSize(symbol);
538 }
539 return m_sym_file_impl->GetParameterStackSize(symbol);
540 }
541
PreloadSymbols()542 void SymbolFileOnDemand::PreloadSymbols() {
543 m_preload_symbols = true;
544 if (!m_debug_info_enabled) {
545 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
546 __FUNCTION__);
547 return;
548 }
549 return m_sym_file_impl->PreloadSymbols();
550 }
551
GetDebugInfoSize()552 uint64_t SymbolFileOnDemand::GetDebugInfoSize() {
553 // Always return the real debug info size.
554 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
555 __FUNCTION__);
556 return m_sym_file_impl->GetDebugInfoSize();
557 }
558
GetDebugInfoParseTime()559 StatsDuration::Duration SymbolFileOnDemand::GetDebugInfoParseTime() {
560 // Always return the real parse time.
561 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
562 __FUNCTION__);
563 return m_sym_file_impl->GetDebugInfoParseTime();
564 }
565
GetDebugInfoIndexTime()566 StatsDuration::Duration SymbolFileOnDemand::GetDebugInfoIndexTime() {
567 // Always return the real index time.
568 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(),
569 __FUNCTION__);
570 return m_sym_file_impl->GetDebugInfoIndexTime();
571 }
572
SetLoadDebugInfoEnabled()573 void SymbolFileOnDemand::SetLoadDebugInfoEnabled() {
574 if (m_debug_info_enabled)
575 return;
576 LLDB_LOG(GetLog(), "[{0}] Hydrate debug info", GetSymbolFileName());
577 m_debug_info_enabled = true;
578 InitializeObject();
579 if (m_preload_symbols)
580 PreloadSymbols();
581 }
582
GetNumCompileUnits()583 uint32_t SymbolFileOnDemand::GetNumCompileUnits() {
584 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration",
585 GetSymbolFileName(), __FUNCTION__);
586 return m_sym_file_impl->GetNumCompileUnits();
587 }
588
GetCompileUnitAtIndex(uint32_t idx)589 CompUnitSP SymbolFileOnDemand::GetCompileUnitAtIndex(uint32_t idx) {
590 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration",
591 GetSymbolFileName(), __FUNCTION__);
592 return m_sym_file_impl->GetCompileUnitAtIndex(idx);
593 }
594
GetAbilities()595 uint32_t SymbolFileOnDemand::GetAbilities() {
596 if (!m_debug_info_enabled) {
597 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(),
598 __FUNCTION__);
599 return 0;
600 }
601 return m_sym_file_impl->GetAbilities();
602 }
603