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 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 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 34 std::recursive_mutex &SymbolFileOnDemand::GetModuleMutex() const { 35 return m_sym_file_impl->GetModuleMutex(); 36 } 37 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 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 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 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 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 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 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 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 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 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 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 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 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 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> 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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> 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 485 SymbolFileOnDemand::FindNamespace(ConstString name, 486 const CompilerDeclContext &parent_decl_ctx, 487 bool only_root_namespaces) { 488 if (!m_debug_info_enabled) { 489 LLDB_LOG(GetLog(), "[{0}] {1}({2}) is skipped", GetSymbolFileName(), 490 __FUNCTION__, name); 491 return SymbolFile::FindNamespace(name, parent_decl_ctx, 492 only_root_namespaces); 493 } 494 return m_sym_file_impl->FindNamespace(name, parent_decl_ctx, 495 only_root_namespaces); 496 } 497 498 std::vector<std::unique_ptr<lldb_private::CallEdge>> 499 SymbolFileOnDemand::ParseCallEdgesInFunction(UserID func_id) { 500 if (!m_debug_info_enabled) { 501 Log *log = GetLog(); 502 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__); 503 if (log) { 504 std::vector<std::unique_ptr<lldb_private::CallEdge>> call_edges = 505 m_sym_file_impl->ParseCallEdgesInFunction(func_id); 506 if (call_edges.size() > 0) { 507 LLDB_LOG(log, "{0} call edges would be parsed for {1} if hydrated.", 508 call_edges.size(), func_id.GetID()); 509 } 510 } 511 return {}; 512 } 513 return m_sym_file_impl->ParseCallEdgesInFunction(func_id); 514 } 515 516 lldb::UnwindPlanSP 517 SymbolFileOnDemand::GetUnwindPlan(const Address &address, 518 const RegisterInfoResolver &resolver) { 519 if (!m_debug_info_enabled) { 520 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(), 521 __FUNCTION__); 522 return nullptr; 523 } 524 return m_sym_file_impl->GetUnwindPlan(address, resolver); 525 } 526 527 llvm::Expected<lldb::addr_t> 528 SymbolFileOnDemand::GetParameterStackSize(Symbol &symbol) { 529 if (!m_debug_info_enabled) { 530 Log *log = GetLog(); 531 LLDB_LOG(log, "[{0}] {1} is skipped", GetSymbolFileName(), __FUNCTION__); 532 if (log) { 533 llvm::Expected<lldb::addr_t> stack_size = 534 m_sym_file_impl->GetParameterStackSize(symbol); 535 if (stack_size) { 536 LLDB_LOG(log, "{0} stack size would return for symbol {1} if hydrated.", 537 *stack_size, symbol.GetName()); 538 } 539 } 540 return SymbolFile::GetParameterStackSize(symbol); 541 } 542 return m_sym_file_impl->GetParameterStackSize(symbol); 543 } 544 545 void SymbolFileOnDemand::PreloadSymbols() { 546 m_preload_symbols = true; 547 if (!m_debug_info_enabled) { 548 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(), 549 __FUNCTION__); 550 return; 551 } 552 return m_sym_file_impl->PreloadSymbols(); 553 } 554 555 uint64_t SymbolFileOnDemand::GetDebugInfoSize() { 556 // Always return the real debug info size. 557 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(), 558 __FUNCTION__); 559 return m_sym_file_impl->GetDebugInfoSize(); 560 } 561 562 StatsDuration::Duration SymbolFileOnDemand::GetDebugInfoParseTime() { 563 // Always return the real parse time. 564 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(), 565 __FUNCTION__); 566 return m_sym_file_impl->GetDebugInfoParseTime(); 567 } 568 569 StatsDuration::Duration SymbolFileOnDemand::GetDebugInfoIndexTime() { 570 // Always return the real index time. 571 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped", GetSymbolFileName(), 572 __FUNCTION__); 573 return m_sym_file_impl->GetDebugInfoIndexTime(); 574 } 575 576 void SymbolFileOnDemand::SetLoadDebugInfoEnabled() { 577 if (m_debug_info_enabled) 578 return; 579 LLDB_LOG(GetLog(), "[{0}] Hydrate debug info", GetSymbolFileName()); 580 m_debug_info_enabled = true; 581 InitializeObject(); 582 if (m_preload_symbols) 583 PreloadSymbols(); 584 } 585 586 uint32_t SymbolFileOnDemand::GetNumCompileUnits() { 587 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration", 588 GetSymbolFileName(), __FUNCTION__); 589 return m_sym_file_impl->GetNumCompileUnits(); 590 } 591 592 CompUnitSP SymbolFileOnDemand::GetCompileUnitAtIndex(uint32_t idx) { 593 LLDB_LOG(GetLog(), "[{0}] {1} is not skipped to support breakpoint hydration", 594 GetSymbolFileName(), __FUNCTION__); 595 return m_sym_file_impl->GetCompileUnitAtIndex(idx); 596 } 597 598 uint32_t SymbolFileOnDemand::GetAbilities() { 599 if (!m_debug_info_enabled) { 600 LLDB_LOG(GetLog(), "[{0}] {1} is skipped", GetSymbolFileName(), 601 __FUNCTION__); 602 return 0; 603 } 604 return m_sym_file_impl->GetAbilities(); 605 } 606