1 //===-- SymbolFileDWARF.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_DWARF_SYMBOLFILEDWARF_H 10 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H 11 12 #include <list> 13 #include <map> 14 #include <mutex> 15 #include <unordered_map> 16 #include <vector> 17 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/SetVector.h" 20 #include "llvm/Support/Threading.h" 21 22 #include "lldb/Core/UniqueCStringMap.h" 23 #include "lldb/Core/dwarf.h" 24 #include "lldb/Symbol/DebugMacros.h" 25 #include "lldb/Symbol/SymbolContext.h" 26 #include "lldb/Symbol/SymbolFile.h" 27 #include "lldb/Utility/ConstString.h" 28 #include "lldb/Utility/Flags.h" 29 #include "lldb/Utility/RangeMap.h" 30 #include "lldb/lldb-private.h" 31 32 #include "DWARFContext.h" 33 #include "DWARFDataExtractor.h" 34 #include "DWARFDefines.h" 35 #include "DWARFIndex.h" 36 #include "UniqueDWARFASTType.h" 37 38 // Forward Declarations for this DWARF plugin 39 class DebugMapModule; 40 class DWARFAbbreviationDeclaration; 41 class DWARFAbbreviationDeclarationSet; 42 class DWARFCompileUnit; 43 class DWARFDebugAbbrev; 44 class DWARFDebugAranges; 45 class DWARFDebugInfo; 46 class DWARFDebugInfoEntry; 47 class DWARFDebugLine; 48 class DWARFDebugRanges; 49 class DWARFDeclContext; 50 class DWARFFormValue; 51 class DWARFTypeUnit; 52 class SymbolFileDWARFDebugMap; 53 class SymbolFileDWARFDwo; 54 class SymbolFileDWARFDwp; 55 56 #define DIE_IS_BEING_PARSED ((lldb_private::Type *)1) 57 58 class SymbolFileDWARF : public lldb_private::SymbolFile, 59 public lldb_private::UserID { 60 /// LLVM RTTI support. 61 static char ID; 62 63 public: 64 /// LLVM RTTI support. 65 /// \{ isA(const void * ClassID)66 bool isA(const void *ClassID) const override { 67 return ClassID == &ID || SymbolFile::isA(ClassID); 68 } classof(const SymbolFile * obj)69 static bool classof(const SymbolFile *obj) { return obj->isA(&ID); } 70 /// \} 71 72 friend class SymbolFileDWARFDebugMap; 73 friend class SymbolFileDWARFDwo; 74 friend class DebugMapModule; 75 friend class DWARFCompileUnit; 76 friend class DWARFDIE; 77 friend class DWARFASTParserClang; 78 79 // Static Functions 80 static void Initialize(); 81 82 static void Terminate(); 83 84 static void DebuggerInitialize(lldb_private::Debugger &debugger); 85 86 static lldb_private::ConstString GetPluginNameStatic(); 87 88 static const char *GetPluginDescriptionStatic(); 89 90 static lldb_private::SymbolFile * 91 CreateInstance(lldb::ObjectFileSP objfile_sp); 92 93 // Constructors and Destructors 94 95 SymbolFileDWARF(lldb::ObjectFileSP objfile_sp, 96 lldb_private::SectionList *dwo_section_list); 97 98 ~SymbolFileDWARF() override; 99 100 uint32_t CalculateAbilities() override; 101 102 void InitializeObject() override; 103 104 // Compile Unit function calls 105 106 lldb::LanguageType 107 ParseLanguage(lldb_private::CompileUnit &comp_unit) override; 108 109 lldb_private::XcodeSDK 110 ParseXcodeSDK(lldb_private::CompileUnit &comp_unit) override; 111 112 size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override; 113 114 bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override; 115 116 bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override; 117 118 bool ForEachExternalModule( 119 lldb_private::CompileUnit &, llvm::DenseSet<lldb_private::SymbolFile *> &, 120 llvm::function_ref<bool(lldb_private::Module &)>) override; 121 122 bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit, 123 lldb_private::FileSpecList &support_files) override; 124 125 bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override; 126 127 size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override; 128 129 bool ParseImportedModules( 130 const lldb_private::SymbolContext &sc, 131 std::vector<lldb_private::SourceModule> &imported_modules) override; 132 133 size_t ParseBlocksRecursive(lldb_private::Function &func) override; 134 135 size_t 136 ParseVariablesForContext(const lldb_private::SymbolContext &sc) override; 137 138 lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override; 139 llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID( 140 lldb::user_id_t type_uid, 141 const lldb_private::ExecutionContext *exe_ctx) override; 142 143 bool CompleteType(lldb_private::CompilerType &compiler_type) override; 144 145 lldb_private::Type *ResolveType(const DWARFDIE &die, 146 bool assert_not_being_parsed = true, 147 bool resolve_function_context = false); 148 149 lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override; 150 151 lldb_private::CompilerDeclContext 152 GetDeclContextForUID(lldb::user_id_t uid) override; 153 154 lldb_private::CompilerDeclContext 155 GetDeclContextContainingUID(lldb::user_id_t uid) override; 156 157 void 158 ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override; 159 160 uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr, 161 lldb::SymbolContextItem resolve_scope, 162 lldb_private::SymbolContext &sc) override; 163 164 uint32_t 165 ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line, 166 bool check_inlines, 167 lldb::SymbolContextItem resolve_scope, 168 lldb_private::SymbolContextList &sc_list) override; 169 170 void 171 FindGlobalVariables(lldb_private::ConstString name, 172 const lldb_private::CompilerDeclContext &parent_decl_ctx, 173 uint32_t max_matches, 174 lldb_private::VariableList &variables) override; 175 176 void FindGlobalVariables(const lldb_private::RegularExpression ®ex, 177 uint32_t max_matches, 178 lldb_private::VariableList &variables) override; 179 180 void FindFunctions(lldb_private::ConstString name, 181 const lldb_private::CompilerDeclContext &parent_decl_ctx, 182 lldb::FunctionNameType name_type_mask, 183 bool include_inlines, 184 lldb_private::SymbolContextList &sc_list) override; 185 186 void FindFunctions(const lldb_private::RegularExpression ®ex, 187 bool include_inlines, 188 lldb_private::SymbolContextList &sc_list) override; 189 190 void GetMangledNamesForFunction( 191 const std::string &scope_qualified_name, 192 std::vector<lldb_private::ConstString> &mangled_names) override; 193 194 void 195 FindTypes(lldb_private::ConstString name, 196 const lldb_private::CompilerDeclContext &parent_decl_ctx, 197 uint32_t max_matches, 198 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 199 lldb_private::TypeMap &types) override; 200 201 void FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern, 202 lldb_private::LanguageSet languages, 203 llvm::DenseSet<SymbolFile *> &searched_symbol_files, 204 lldb_private::TypeMap &types) override; 205 206 void GetTypes(lldb_private::SymbolContextScope *sc_scope, 207 lldb::TypeClass type_mask, 208 lldb_private::TypeList &type_list) override; 209 210 llvm::Expected<lldb_private::TypeSystem &> 211 GetTypeSystemForLanguage(lldb::LanguageType language) override; 212 213 lldb_private::CompilerDeclContext FindNamespace( 214 lldb_private::ConstString name, 215 const lldb_private::CompilerDeclContext &parent_decl_ctx) override; 216 217 void PreloadSymbols() override; 218 219 std::recursive_mutex &GetModuleMutex() const override; 220 221 // PluginInterface protocol 222 lldb_private::ConstString GetPluginName() override; 223 224 uint32_t GetPluginVersion() override; 225 226 DWARFDebugAbbrev *DebugAbbrev(); 227 228 DWARFDebugInfo &DebugInfo(); 229 230 DWARFDebugRanges *GetDebugRanges(); 231 232 static bool SupportedVersion(uint16_t version); 233 234 DWARFDIE 235 GetDeclContextDIEContainingDIE(const DWARFDIE &die); 236 237 bool 238 HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type); 239 240 lldb_private::CompileUnit * 241 GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu); 242 243 virtual void GetObjCMethods(lldb_private::ConstString class_name, 244 llvm::function_ref<bool(DWARFDIE die)> callback); 245 246 bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu); 247 248 lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset); 249 250 static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die); 251 252 lldb::ModuleSP GetExternalModule(lldb_private::ConstString name); 253 254 typedef std::map<lldb_private::ConstString, lldb::ModuleSP> 255 ExternalTypeModuleMap; 256 257 /// Return the list of Clang modules imported by this SymbolFile. getExternalTypeModules()258 const ExternalTypeModuleMap& getExternalTypeModules() const { 259 return m_external_type_modules; 260 } 261 262 virtual DWARFDIE GetDIE(const DIERef &die_ref); 263 264 DWARFDIE GetDIE(lldb::user_id_t uid); 265 GetUID(const DWARFBaseDIE & die)266 lldb::user_id_t GetUID(const DWARFBaseDIE &die) { 267 return GetUID(die.GetDIERef()); 268 } 269 GetUID(const llvm::Optional<DIERef> & ref)270 lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) { 271 return ref ? GetUID(*ref) : LLDB_INVALID_UID; 272 } 273 274 lldb::user_id_t GetUID(DIERef ref); 275 276 std::shared_ptr<SymbolFileDWARFDwo> 277 GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu, 278 const DWARFDebugInfoEntry &cu_die); 279 GetDwoNum()280 virtual llvm::Optional<uint32_t> GetDwoNum() { return llvm::None; } 281 282 /// If this is a DWARF object with a single CU, return its DW_AT_dwo_id. 283 llvm::Optional<uint64_t> GetDWOId(); 284 285 static bool 286 DIEInDeclContext(const lldb_private::CompilerDeclContext &parent_decl_ctx, 287 const DWARFDIE &die); 288 289 std::vector<std::unique_ptr<lldb_private::CallEdge>> 290 ParseCallEdgesInFunction(UserID func_id) override; 291 292 void Dump(lldb_private::Stream &s) override; 293 294 void DumpClangAST(lldb_private::Stream &s) override; 295 GetDWARFContext()296 lldb_private::DWARFContext &GetDWARFContext() { return m_context; } 297 298 const std::shared_ptr<SymbolFileDWARFDwo> &GetDwpSymbolFile(); 299 300 lldb_private::FileSpec GetFile(DWARFUnit &unit, size_t file_idx); 301 302 static llvm::Expected<lldb_private::TypeSystem &> 303 GetTypeSystem(DWARFUnit &unit); 304 305 static DWARFASTParser *GetDWARFParser(DWARFUnit &unit); 306 307 // CompilerDecl related functions 308 309 static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die); 310 311 static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die); 312 313 static lldb_private::CompilerDeclContext 314 GetContainingDeclContext(const DWARFDIE &die); 315 316 static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die); 317 318 static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val); 319 320 static lldb::LanguageType GetLanguage(DWARFUnit &unit); 321 322 protected: 323 typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *> 324 DIEToTypePtr; 325 typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP> 326 DIEToVariableSP; 327 typedef llvm::DenseMap<const DWARFDebugInfoEntry *, 328 lldb::opaque_compiler_type_t> 329 DIEToClangType; 330 typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE; 331 332 SymbolFileDWARF(const SymbolFileDWARF &) = delete; 333 const SymbolFileDWARF &operator=(const SymbolFileDWARF &) = delete; 334 335 virtual void LoadSectionData(lldb::SectionType sect_type, 336 lldb_private::DWARFDataExtractor &data); 337 338 bool DeclContextMatchesThisSymbolFile( 339 const lldb_private::CompilerDeclContext &decl_ctx); 340 341 uint32_t CalculateNumCompileUnits() override; 342 343 lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override; 344 345 lldb_private::TypeList &GetTypeList() override; 346 347 lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu); 348 349 virtual DWARFCompileUnit * 350 GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit); 351 352 DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu); 353 354 bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc); 355 356 lldb_private::Function *ParseFunction(lldb_private::CompileUnit &comp_unit, 357 const DWARFDIE &die); 358 359 size_t ParseBlocksRecursive(lldb_private::CompileUnit &comp_unit, 360 lldb_private::Block *parent_block, 361 const DWARFDIE &die, 362 lldb::addr_t subprogram_low_pc, uint32_t depth); 363 364 size_t ParseTypes(const lldb_private::SymbolContext &sc, const DWARFDIE &die, 365 bool parse_siblings, bool parse_children); 366 367 lldb::TypeSP ParseType(const lldb_private::SymbolContext &sc, 368 const DWARFDIE &die, bool *type_is_new); 369 370 lldb_private::Type *ResolveTypeUID(const DWARFDIE &die, 371 bool assert_not_being_parsed); 372 373 lldb_private::Type *ResolveTypeUID(const DIERef &die_ref); 374 375 lldb::VariableSP ParseVariableDIE(const lldb_private::SymbolContext &sc, 376 const DWARFDIE &die, 377 const lldb::addr_t func_low_pc); 378 379 size_t ParseVariables(const lldb_private::SymbolContext &sc, 380 const DWARFDIE &orig_die, 381 const lldb::addr_t func_low_pc, bool parse_siblings, 382 bool parse_children, 383 lldb_private::VariableList *cc_variable_list = nullptr); 384 385 bool ClassOrStructIsVirtual(const DWARFDIE &die); 386 387 // Given a die_offset, figure out the symbol context representing that die. 388 bool ResolveFunction(const DWARFDIE &die, bool include_inlines, 389 lldb_private::SymbolContextList &sc_list); 390 391 /// Resolve functions and (possibly) blocks for the given file address and a 392 /// compile unit. The compile unit comes from the sc argument and it must be 393 /// set. The results of the lookup (if any) are written back to the symbol 394 /// context. 395 void ResolveFunctionAndBlock(lldb::addr_t file_vm_addr, bool lookup_block, 396 lldb_private::SymbolContext &sc); 397 398 virtual lldb::TypeSP 399 FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx); 400 401 virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE( 402 const DWARFDIE &die, lldb_private::ConstString type_name, 403 bool must_be_implementation); 404 405 lldb_private::Symbol * 406 GetObjCClassSymbol(lldb_private::ConstString objc_class_name); 407 408 lldb::TypeSP GetTypeForDIE(const DWARFDIE &die, 409 bool resolve_function_context = false); 410 SetDebugMapModule(const lldb::ModuleSP & module_sp)411 void SetDebugMapModule(const lldb::ModuleSP &module_sp) { 412 m_debug_map_module_wp = module_sp; 413 } 414 415 SymbolFileDWARFDebugMap *GetDebugMapSymfile(); 416 417 DWARFDIE 418 FindBlockContainingSpecification(const DIERef &func_die_ref, 419 dw_offset_t spec_block_die_offset); 420 421 DWARFDIE 422 FindBlockContainingSpecification(const DWARFDIE &die, 423 dw_offset_t spec_block_die_offset); 424 425 virtual UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap(); 426 427 bool DIEDeclContextsMatch(const DWARFDIE &die1, const DWARFDIE &die2); 428 429 bool ClassContainsSelector(const DWARFDIE &class_die, 430 lldb_private::ConstString selector); 431 432 /// Parse call site entries (DW_TAG_call_site), including any nested call site 433 /// parameters (DW_TAG_call_site_parameter). 434 std::vector<std::unique_ptr<lldb_private::CallEdge>> 435 CollectCallEdges(lldb::ModuleSP module, DWARFDIE function_die); 436 437 /// If this symbol file is linked to by a debug map (see 438 /// SymbolFileDWARFDebugMap), and \p file_addr is a file address relative to 439 /// an object file, adjust \p file_addr so that it is relative to the main 440 /// binary. Returns the adjusted address, or \p file_addr if no adjustment is 441 /// needed, on success and LLDB_INVALID_ADDRESS otherwise. 442 lldb::addr_t FixupAddress(lldb::addr_t file_addr); 443 444 bool FixupAddress(lldb_private::Address &addr); 445 446 typedef llvm::SetVector<lldb_private::Type *> TypeSet; 447 448 void GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset, 449 dw_offset_t max_die_offset, uint32_t type_mask, 450 TypeSet &type_set); 451 452 typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, 453 lldb_private::Variable *> 454 GlobalVariableMap; 455 456 GlobalVariableMap &GetGlobalAranges(); 457 458 void UpdateExternalModuleListIfNeeded(); 459 GetDIEToType()460 virtual DIEToTypePtr &GetDIEToType() { return m_die_to_type; } 461 GetDIEToVariable()462 virtual DIEToVariableSP &GetDIEToVariable() { return m_die_to_variable_sp; } 463 GetForwardDeclDieToClangType()464 virtual DIEToClangType &GetForwardDeclDieToClangType() { 465 return m_forward_decl_die_to_clang_type; 466 } 467 GetForwardDeclClangTypeToDie()468 virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() { 469 return m_forward_decl_clang_type_to_die; 470 } 471 472 void BuildCuTranslationTable(); 473 llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx); 474 475 struct DecodedUID { 476 SymbolFileDWARF &dwarf; 477 DIERef ref; 478 }; 479 llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid); 480 481 void FindDwpSymbolFile(); 482 483 const lldb_private::FileSpecList &GetTypeUnitSupportFiles(DWARFTypeUnit &tu); 484 485 lldb::ModuleWP m_debug_map_module_wp; 486 SymbolFileDWARFDebugMap *m_debug_map_symfile; 487 488 llvm::once_flag m_dwp_symfile_once_flag; 489 std::shared_ptr<SymbolFileDWARFDwo> m_dwp_symfile; 490 491 lldb_private::DWARFContext m_context; 492 493 llvm::once_flag m_info_once_flag; 494 std::unique_ptr<DWARFDebugInfo> m_info; 495 496 std::unique_ptr<DWARFDebugAbbrev> m_abbr; 497 std::unique_ptr<GlobalVariableMap> m_global_aranges_up; 498 499 typedef std::unordered_map<lldb::offset_t, lldb_private::DebugMacrosSP> 500 DebugMacrosMap; 501 DebugMacrosMap m_debug_macros_map; 502 503 ExternalTypeModuleMap m_external_type_modules; 504 std::unique_ptr<lldb_private::DWARFIndex> m_index; 505 bool m_fetched_external_modules : 1; 506 lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type; 507 508 typedef std::set<DIERef> DIERefSet; 509 typedef llvm::StringMap<DIERefSet> NameToOffsetMap; 510 NameToOffsetMap m_function_scope_qualified_name_map; 511 std::unique_ptr<DWARFDebugRanges> m_ranges; 512 UniqueDWARFASTTypeMap m_unique_ast_type_map; 513 DIEToTypePtr m_die_to_type; 514 DIEToVariableSP m_die_to_variable_sp; 515 DIEToClangType m_forward_decl_die_to_clang_type; 516 ClangTypeToDIE m_forward_decl_clang_type_to_die; 517 llvm::DenseMap<dw_offset_t, lldb_private::FileSpecList> 518 m_type_unit_support_files; 519 std::vector<uint32_t> m_lldb_cu_to_dwarf_unit; 520 }; 521 522 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H 523