1061da546Spatrick //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===// 2061da546Spatrick // 3061da546Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4061da546Spatrick // See https://llvm.org/LICENSE.txt for license information. 5061da546Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6061da546Spatrick // 7061da546Spatrick //===----------------------------------------------------------------------===// 8061da546Spatrick 9dda28197Spatrick #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H 10dda28197Spatrick #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H 11061da546Spatrick 12061da546Spatrick #include "DWARFDIE.h" 13061da546Spatrick #include "DWARFDebugInfoEntry.h" 14dda28197Spatrick #include "lldb/Utility/XcodeSDK.h" 15*f6aab3d8Srobert #include "lldb/lldb-enumerations.h" 16*f6aab3d8Srobert #include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h" 17061da546Spatrick #include "llvm/Support/RWMutex.h" 18061da546Spatrick #include <atomic> 19*f6aab3d8Srobert #include <optional> 20061da546Spatrick 21061da546Spatrick class DWARFUnit; 22061da546Spatrick class DWARFCompileUnit; 23061da546Spatrick class NameToDIE; 24061da546Spatrick class SymbolFileDWARF; 25061da546Spatrick class SymbolFileDWARFDwo; 26061da546Spatrick 27061da546Spatrick typedef std::shared_ptr<DWARFUnit> DWARFUnitSP; 28061da546Spatrick 29061da546Spatrick enum DWARFProducer { 30061da546Spatrick eProducerInvalid = 0, 31061da546Spatrick eProducerClang, 32061da546Spatrick eProducerGCC, 33061da546Spatrick eProducerLLVMGCC, 34*f6aab3d8Srobert eProducerSwift, 35*f6aab3d8Srobert eProducerOther 36061da546Spatrick }; 37061da546Spatrick 38061da546Spatrick /// Base class describing the header of any kind of "unit." Some information 39061da546Spatrick /// is specific to certain unit types. We separate this class out so we can 40061da546Spatrick /// parse the header before deciding what specific kind of unit to construct. 41061da546Spatrick class DWARFUnitHeader { 42061da546Spatrick dw_offset_t m_offset = 0; 43061da546Spatrick dw_offset_t m_length = 0; 44061da546Spatrick uint16_t m_version = 0; 45061da546Spatrick dw_offset_t m_abbr_offset = 0; 46dda28197Spatrick 47dda28197Spatrick const llvm::DWARFUnitIndex::Entry *m_index_entry = nullptr; 48dda28197Spatrick 49061da546Spatrick uint8_t m_unit_type = 0; 50061da546Spatrick uint8_t m_addr_size = 0; 51061da546Spatrick 52061da546Spatrick uint64_t m_type_hash = 0; 53061da546Spatrick uint32_t m_type_offset = 0; 54061da546Spatrick 55*f6aab3d8Srobert std::optional<uint64_t> m_dwo_id; 56061da546Spatrick 57061da546Spatrick DWARFUnitHeader() = default; 58061da546Spatrick 59061da546Spatrick public: GetOffset()60061da546Spatrick dw_offset_t GetOffset() const { return m_offset; } GetVersion()61061da546Spatrick uint16_t GetVersion() const { return m_version; } GetAddressByteSize()62061da546Spatrick uint16_t GetAddressByteSize() const { return m_addr_size; } GetLength()63061da546Spatrick dw_offset_t GetLength() const { return m_length; } GetAbbrOffset()64061da546Spatrick dw_offset_t GetAbbrOffset() const { return m_abbr_offset; } GetUnitType()65061da546Spatrick uint8_t GetUnitType() const { return m_unit_type; } GetIndexEntry()66dda28197Spatrick const llvm::DWARFUnitIndex::Entry *GetIndexEntry() const { 67dda28197Spatrick return m_index_entry; 68dda28197Spatrick } GetTypeHash()69061da546Spatrick uint64_t GetTypeHash() const { return m_type_hash; } GetTypeOffset()70061da546Spatrick dw_offset_t GetTypeOffset() const { return m_type_offset; } GetDWOId()71*f6aab3d8Srobert std::optional<uint64_t> GetDWOId() const { return m_dwo_id; } IsTypeUnit()72061da546Spatrick bool IsTypeUnit() const { 73*f6aab3d8Srobert return m_unit_type == llvm::dwarf::DW_UT_type || 74*f6aab3d8Srobert m_unit_type == llvm::dwarf::DW_UT_split_type; 75061da546Spatrick } GetNextUnitOffset()76061da546Spatrick uint32_t GetNextUnitOffset() const { return m_offset + m_length + 4; } 77061da546Spatrick 78061da546Spatrick static llvm::Expected<DWARFUnitHeader> 79061da546Spatrick extract(const lldb_private::DWARFDataExtractor &data, DIERef::Section section, 80be691f3bSpatrick lldb_private::DWARFContext &dwarf_context, 81be691f3bSpatrick lldb::offset_t *offset_ptr); 82061da546Spatrick }; 83061da546Spatrick 84061da546Spatrick class DWARFUnit : public lldb_private::UserID { 85061da546Spatrick using die_iterator_range = 86061da546Spatrick llvm::iterator_range<DWARFDebugInfoEntry::collection::iterator>; 87061da546Spatrick 88061da546Spatrick public: 89061da546Spatrick static llvm::Expected<DWARFUnitSP> 90061da546Spatrick extract(SymbolFileDWARF &dwarf2Data, lldb::user_id_t uid, 91061da546Spatrick const lldb_private::DWARFDataExtractor &debug_info, 92be691f3bSpatrick DIERef::Section section, lldb::offset_t *offset_ptr); 93061da546Spatrick virtual ~DWARFUnit(); 94061da546Spatrick IsDWOUnit()95dda28197Spatrick bool IsDWOUnit() { return m_is_dwo; } 96*f6aab3d8Srobert std::optional<uint64_t> GetDWOId(); 97dda28197Spatrick 98061da546Spatrick void ExtractUnitDIEIfNeeded(); 99*f6aab3d8Srobert void ExtractUnitDIENoDwoIfNeeded(); 100061da546Spatrick void ExtractDIEsIfNeeded(); 101061da546Spatrick 102061da546Spatrick class ScopedExtractDIEs { 103061da546Spatrick DWARFUnit *m_cu; 104061da546Spatrick public: 105061da546Spatrick bool m_clear_dies = false; 106061da546Spatrick ScopedExtractDIEs(DWARFUnit &cu); 107061da546Spatrick ~ScopedExtractDIEs(); 108dda28197Spatrick ScopedExtractDIEs(const ScopedExtractDIEs &) = delete; 109dda28197Spatrick const ScopedExtractDIEs &operator=(const ScopedExtractDIEs &) = delete; 110061da546Spatrick ScopedExtractDIEs(ScopedExtractDIEs &&rhs); 111061da546Spatrick ScopedExtractDIEs &operator=(ScopedExtractDIEs &&rhs); 112061da546Spatrick }; 113061da546Spatrick ScopedExtractDIEs ExtractDIEsScoped(); 114061da546Spatrick 115061da546Spatrick bool Verify(lldb_private::Stream *s) const; 116061da546Spatrick virtual void Dump(lldb_private::Stream *s) const = 0; 117061da546Spatrick /// Get the data that contains the DIE information for this unit. 118061da546Spatrick /// 119061da546Spatrick /// This will return the correct bytes that contain the data for 120061da546Spatrick /// this DWARFUnit. It could be .debug_info or .debug_types 121061da546Spatrick /// depending on where the data for this unit originates. 122061da546Spatrick /// 123061da546Spatrick /// \return 124061da546Spatrick /// The correct data for the DIE information in this unit. 125061da546Spatrick const lldb_private::DWARFDataExtractor &GetData() const; 126061da546Spatrick 127061da546Spatrick /// Get the size in bytes of the unit header. 128061da546Spatrick /// 129061da546Spatrick /// \return 130061da546Spatrick /// Byte size of the unit header 131061da546Spatrick uint32_t GetHeaderByteSize() const; 132061da546Spatrick 133061da546Spatrick // Offset of the initial length field. GetOffset()134061da546Spatrick dw_offset_t GetOffset() const { return m_header.GetOffset(); } 135061da546Spatrick /// Get the size in bytes of the length field in the header. 136061da546Spatrick /// 137061da546Spatrick /// In DWARF32 this is just 4 bytes 138061da546Spatrick /// 139061da546Spatrick /// \return 140061da546Spatrick /// Byte size of the compile unit header length field GetLengthByteSize()141061da546Spatrick size_t GetLengthByteSize() const { return 4; } 142061da546Spatrick ContainsDIEOffset(dw_offset_t die_offset)143061da546Spatrick bool ContainsDIEOffset(dw_offset_t die_offset) const { 144061da546Spatrick return die_offset >= GetFirstDIEOffset() && 145061da546Spatrick die_offset < GetNextUnitOffset(); 146061da546Spatrick } GetFirstDIEOffset()147061da546Spatrick dw_offset_t GetFirstDIEOffset() const { 148061da546Spatrick return GetOffset() + GetHeaderByteSize(); 149061da546Spatrick } GetNextUnitOffset()150061da546Spatrick dw_offset_t GetNextUnitOffset() const { return m_header.GetNextUnitOffset(); } 151061da546Spatrick // Size of the CU data (without initial length and without header). 152061da546Spatrick size_t GetDebugInfoSize() const; 153061da546Spatrick // Size of the CU data incl. header but without initial length. GetLength()154061da546Spatrick uint32_t GetLength() const { return m_header.GetLength(); } GetVersion()155061da546Spatrick uint16_t GetVersion() const { return m_header.GetVersion(); } 156061da546Spatrick const DWARFAbbreviationDeclarationSet *GetAbbreviations() const; 157061da546Spatrick dw_offset_t GetAbbrevOffset() const; GetAddressByteSize()158061da546Spatrick uint8_t GetAddressByteSize() const { return m_header.GetAddressByteSize(); } GetAddrBase()159*f6aab3d8Srobert dw_addr_t GetAddrBase() const { return m_addr_base.value_or(0); } GetBaseAddress()160061da546Spatrick dw_addr_t GetBaseAddress() const { return m_base_addr; } 161061da546Spatrick dw_offset_t GetLineTableOffset(); GetRangesBase()162061da546Spatrick dw_addr_t GetRangesBase() const { return m_ranges_base; } GetStrOffsetsBase()163061da546Spatrick dw_addr_t GetStrOffsetsBase() const { return m_str_offsets_base; } 164061da546Spatrick void SetAddrBase(dw_addr_t addr_base); 165061da546Spatrick void SetLoclistsBase(dw_addr_t loclists_base); 166061da546Spatrick void SetRangesBase(dw_addr_t ranges_base); 167061da546Spatrick void SetStrOffsetsBase(dw_offset_t str_offsets_base); 168061da546Spatrick virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0; 169061da546Spatrick 170*f6aab3d8Srobert dw_addr_t ReadAddressFromDebugAddrSection(uint32_t index) const; 171*f6aab3d8Srobert 172061da546Spatrick lldb::ByteOrder GetByteOrder() const; 173061da546Spatrick 174061da546Spatrick const DWARFDebugAranges &GetFunctionAranges(); 175061da546Spatrick 176061da546Spatrick void SetBaseAddress(dw_addr_t base_addr); 177061da546Spatrick GetUnitDIEOnly()178be691f3bSpatrick DWARFBaseDIE GetUnitDIEOnly() { return {this, GetUnitDIEPtrOnly()}; } 179061da546Spatrick DIE()180061da546Spatrick DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); } 181061da546Spatrick 182061da546Spatrick DWARFDIE GetDIE(dw_offset_t die_offset); 183061da546Spatrick 184061da546Spatrick DWARFUnit &GetNonSkeletonUnit(); 185061da546Spatrick 186061da546Spatrick static uint8_t GetAddressByteSize(const DWARFUnit *cu); 187061da546Spatrick 188061da546Spatrick static uint8_t GetDefaultAddressSize(); 189061da546Spatrick 190061da546Spatrick void *GetUserData() const; 191061da546Spatrick 192061da546Spatrick void SetUserData(void *d); 193061da546Spatrick 194061da546Spatrick bool Supports_DW_AT_APPLE_objc_complete_type(); 195061da546Spatrick 196061da546Spatrick bool DW_AT_decl_file_attributes_are_invalid(); 197061da546Spatrick 198061da546Spatrick bool Supports_unnamed_objc_bitfields(); 199061da546Spatrick GetSymbolFileDWARF()200061da546Spatrick SymbolFileDWARF &GetSymbolFileDWARF() const { return m_dwarf; } 201061da546Spatrick 202061da546Spatrick DWARFProducer GetProducer(); 203061da546Spatrick 204*f6aab3d8Srobert llvm::VersionTuple GetProducerVersion(); 205061da546Spatrick 206dda28197Spatrick uint64_t GetDWARFLanguageType(); 207061da546Spatrick 208061da546Spatrick bool GetIsOptimized(); 209061da546Spatrick 210061da546Spatrick const lldb_private::FileSpec &GetCompilationDirectory(); 211061da546Spatrick const lldb_private::FileSpec &GetAbsolutePath(); 212061da546Spatrick lldb_private::FileSpec GetFile(size_t file_idx); 213061da546Spatrick lldb_private::FileSpec::Style GetPathStyle(); 214061da546Spatrick 215061da546Spatrick SymbolFileDWARFDwo *GetDwoSymbolFile(); 216061da546Spatrick dies()217061da546Spatrick die_iterator_range dies() { 218061da546Spatrick ExtractDIEsIfNeeded(); 219061da546Spatrick return die_iterator_range(m_die_array.begin(), m_die_array.end()); 220061da546Spatrick } 221061da546Spatrick GetDebugSection()222061da546Spatrick DIERef::Section GetDebugSection() const { return m_section; } 223061da546Spatrick GetUnitType()224061da546Spatrick uint8_t GetUnitType() const { return m_header.GetUnitType(); } IsTypeUnit()225061da546Spatrick bool IsTypeUnit() const { return m_header.IsTypeUnit(); } 226061da546Spatrick 227*f6aab3d8Srobert std::optional<uint64_t> GetStringOffsetSectionItem(uint32_t index) const; 228dda28197Spatrick 229061da546Spatrick /// Return a list of address ranges resulting from a (possibly encoded) 230061da546Spatrick /// range list starting at a given offset in the appropriate ranges section. 231061da546Spatrick llvm::Expected<DWARFRangeList> FindRnglistFromOffset(dw_offset_t offset); 232061da546Spatrick 233061da546Spatrick /// Return a list of address ranges retrieved from an encoded range 234061da546Spatrick /// list whose offset is found via a table lookup given an index (DWARF v5 235061da546Spatrick /// and later). 236061da546Spatrick llvm::Expected<DWARFRangeList> FindRnglistFromIndex(uint32_t index); 237061da546Spatrick 238061da546Spatrick /// Return a rangelist's offset based on an index. The index designates 239061da546Spatrick /// an entry in the rangelist table's offset array and is supplied by 240061da546Spatrick /// DW_FORM_rnglistx. 241be691f3bSpatrick llvm::Expected<uint64_t> GetRnglistOffset(uint32_t Index); 242061da546Spatrick GetLoclistOffset(uint32_t Index)243*f6aab3d8Srobert std::optional<uint64_t> GetLoclistOffset(uint32_t Index) { 244061da546Spatrick if (!m_loclist_table_header) 245*f6aab3d8Srobert return std::nullopt; 246061da546Spatrick 247*f6aab3d8Srobert std::optional<uint64_t> Offset = m_loclist_table_header->getOffsetEntry( 248be691f3bSpatrick m_dwarf.GetDWARFContext().getOrLoadLocListsData().GetAsLLVM(), Index); 249061da546Spatrick if (!Offset) 250*f6aab3d8Srobert return std::nullopt; 251061da546Spatrick return *Offset + m_loclists_base; 252061da546Spatrick } 253061da546Spatrick 254061da546Spatrick /// Return the location table for parsing the given location list data. The 255061da546Spatrick /// format is chosen according to the unit type. Never returns null. 256061da546Spatrick std::unique_ptr<llvm::DWARFLocationTable> 257061da546Spatrick GetLocationTable(const lldb_private::DataExtractor &data) const; 258061da546Spatrick 259dda28197Spatrick lldb_private::DWARFDataExtractor GetLocationData() const; 260061da546Spatrick 261*f6aab3d8Srobert /// Returns true if any DIEs in the unit match any DW_TAG values in \a tags. 262*f6aab3d8Srobert /// 263*f6aab3d8Srobert /// \param[in] tags 264*f6aab3d8Srobert /// An array of dw_tag_t values to check all abbrevitions for. 265*f6aab3d8Srobert /// 266*f6aab3d8Srobert /// \returns 267*f6aab3d8Srobert /// True if any DIEs match any tag in \a tags, false otherwise. 268*f6aab3d8Srobert bool HasAny(llvm::ArrayRef<dw_tag_t> tags); 269*f6aab3d8Srobert 270*f6aab3d8Srobert 271*f6aab3d8Srobert /// Get the fission .dwo file specific error for this compile unit. 272*f6aab3d8Srobert /// 273*f6aab3d8Srobert /// The skeleton compile unit only can have a DWO error. Any other type 274*f6aab3d8Srobert /// of DWARFUnit will not have a valid DWO error. 275*f6aab3d8Srobert /// 276*f6aab3d8Srobert /// \returns 277*f6aab3d8Srobert /// A valid DWO error if there is a problem with anything in the 278*f6aab3d8Srobert /// locating or parsing inforamtion in the .dwo file GetDwoError()279*f6aab3d8Srobert const lldb_private::Status &GetDwoError() const { return m_dwo_error; } 280*f6aab3d8Srobert 281*f6aab3d8Srobert /// Set the fission .dwo file specific error for this compile unit. 282*f6aab3d8Srobert /// 283*f6aab3d8Srobert /// This helps tracks issues that arise when trying to locate or parse a 284*f6aab3d8Srobert /// .dwo file. Things like a missing .dwo file, DWO ID mismatch, and other 285*f6aab3d8Srobert /// .dwo errors can be stored in each compile unit so the issues can be 286*f6aab3d8Srobert /// communicated to the user. SetDwoError(const lldb_private::Status & error)287*f6aab3d8Srobert void SetDwoError(const lldb_private::Status &error) { m_dwo_error = error; } 288*f6aab3d8Srobert 289061da546Spatrick protected: 290061da546Spatrick DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid, 291061da546Spatrick const DWARFUnitHeader &header, 292061da546Spatrick const DWARFAbbreviationDeclarationSet &abbrevs, 293061da546Spatrick DIERef::Section section, bool is_dwo); 294061da546Spatrick 295061da546Spatrick llvm::Error ExtractHeader(SymbolFileDWARF &dwarf, 296061da546Spatrick const lldb_private::DWARFDataExtractor &data, 297061da546Spatrick lldb::offset_t *offset_ptr); 298061da546Spatrick 299061da546Spatrick // Get the DWARF unit DWARF debug information entry. Parse the single DIE 300061da546Spatrick // if needed. GetUnitDIEPtrOnly()301061da546Spatrick const DWARFDebugInfoEntry *GetUnitDIEPtrOnly() { 302*f6aab3d8Srobert ExtractUnitDIENoDwoIfNeeded(); 303061da546Spatrick // m_first_die_mutex is not required as m_first_die is never cleared. 304061da546Spatrick if (!m_first_die) 305*f6aab3d8Srobert return nullptr; 306061da546Spatrick return &m_first_die; 307061da546Spatrick } 308061da546Spatrick 309061da546Spatrick // Get all DWARF debug informration entries. Parse all DIEs if needed. DIEPtr()310061da546Spatrick const DWARFDebugInfoEntry *DIEPtr() { 311061da546Spatrick ExtractDIEsIfNeeded(); 312061da546Spatrick if (m_die_array.empty()) 313*f6aab3d8Srobert return nullptr; 314061da546Spatrick return &m_die_array[0]; 315061da546Spatrick } 316061da546Spatrick 317*f6aab3d8Srobert const std::optional<llvm::DWARFDebugRnglistTable> &GetRnglistTable(); 318*f6aab3d8Srobert 319*f6aab3d8Srobert lldb_private::DWARFDataExtractor GetRnglistData() const; 320be691f3bSpatrick 321061da546Spatrick SymbolFileDWARF &m_dwarf; 322dda28197Spatrick std::shared_ptr<DWARFUnit> m_dwo; 323061da546Spatrick DWARFUnitHeader m_header; 324061da546Spatrick const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr; 325061da546Spatrick void *m_user_data = nullptr; 326061da546Spatrick // The compile unit debug information entry item 327061da546Spatrick DWARFDebugInfoEntry::collection m_die_array; 328061da546Spatrick mutable llvm::sys::RWMutex m_die_array_mutex; 329061da546Spatrick // It is used for tracking of ScopedExtractDIEs instances. 330061da546Spatrick mutable llvm::sys::RWMutex m_die_array_scoped_mutex; 331061da546Spatrick // ScopedExtractDIEs instances should not call ClearDIEsRWLocked() 332061da546Spatrick // as someone called ExtractDIEsIfNeeded(). 333061da546Spatrick std::atomic<bool> m_cancel_scopes; 334061da546Spatrick // GetUnitDIEPtrOnly() needs to return pointer to the first DIE. 335061da546Spatrick // But the first element of m_die_array after ExtractUnitDIEIfNeeded() 336061da546Spatrick // would possibly move in memory after later ExtractDIEsIfNeeded(). 337061da546Spatrick DWARFDebugInfoEntry m_first_die; 338061da546Spatrick llvm::sys::RWMutex m_first_die_mutex; 339061da546Spatrick // A table similar to the .debug_aranges table, but this one points to the 340061da546Spatrick // exact DW_TAG_subprogram DIEs 341061da546Spatrick std::unique_ptr<DWARFDebugAranges> m_func_aranges_up; 342061da546Spatrick dw_addr_t m_base_addr = 0; 343061da546Spatrick DWARFProducer m_producer = eProducerInvalid; 344*f6aab3d8Srobert llvm::VersionTuple m_producer_version; 345*f6aab3d8Srobert std::optional<uint64_t> m_language_type; 346061da546Spatrick lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate; 347*f6aab3d8Srobert std::optional<lldb_private::FileSpec> m_comp_dir; 348*f6aab3d8Srobert std::optional<lldb_private::FileSpec> m_file_spec; 349*f6aab3d8Srobert std::optional<dw_addr_t> m_addr_base; ///< Value of DW_AT_addr_base. 350061da546Spatrick dw_addr_t m_loclists_base = 0; ///< Value of DW_AT_loclists_base. 351061da546Spatrick dw_addr_t m_ranges_base = 0; ///< Value of DW_AT_rnglists_base. 352*f6aab3d8Srobert std::optional<uint64_t> m_gnu_addr_base; 353*f6aab3d8Srobert std::optional<uint64_t> m_gnu_ranges_base; 354061da546Spatrick 355061da546Spatrick /// Value of DW_AT_stmt_list. 356061da546Spatrick dw_offset_t m_line_table_offset = DW_INVALID_OFFSET; 357061da546Spatrick 358061da546Spatrick dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base. 359061da546Spatrick 360*f6aab3d8Srobert std::optional<llvm::DWARFDebugRnglistTable> m_rnglist_table; 361be691f3bSpatrick bool m_rnglist_table_done = false; 362*f6aab3d8Srobert std::optional<llvm::DWARFListTableHeader> m_loclist_table_header; 363061da546Spatrick 364061da546Spatrick const DIERef::Section m_section; 365061da546Spatrick bool m_is_dwo; 366*f6aab3d8Srobert bool m_has_parsed_non_skeleton_unit; 367be691f3bSpatrick /// Value of DW_AT_GNU_dwo_id (v4) or dwo_id from CU header (v5). 368*f6aab3d8Srobert std::optional<uint64_t> m_dwo_id; 369*f6aab3d8Srobert /// If we get an error when trying to load a .dwo file, save that error here. 370*f6aab3d8Srobert /// Errors include .dwo/.dwp file not found, or the .dwp/.dwp file was found 371*f6aab3d8Srobert /// but DWO ID doesn't match, etc. 372*f6aab3d8Srobert lldb_private::Status m_dwo_error; 373061da546Spatrick 374061da546Spatrick private: 375061da546Spatrick void ParseProducerInfo(); 376061da546Spatrick void ExtractDIEsRWLocked(); 377061da546Spatrick void ClearDIEsRWLocked(); 378061da546Spatrick 379061da546Spatrick void AddUnitDIE(const DWARFDebugInfoEntry &cu_die); 380dda28197Spatrick void SetDwoStrOffsetsBase(); 381061da546Spatrick 382061da546Spatrick void ComputeCompDirAndGuessPathStyle(); 383061da546Spatrick void ComputeAbsolutePath(); 384061da546Spatrick 385dda28197Spatrick DWARFUnit(const DWARFUnit &) = delete; 386dda28197Spatrick const DWARFUnit &operator=(const DWARFUnit &) = delete; 387061da546Spatrick }; 388061da546Spatrick 389dda28197Spatrick #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H 390