DWARF: Add "dwo_num" field to the DIERef class

[labath]

Summary

When dwo support was introduced, it used a trick where debug info
entries were referenced by the offset of the compile unit in the main
file, but the die offset was relative to the dwo file. Although there
was some elegance to it, this representation was starting to reach its
breaking point:

• the fact that the skeleton compile unit owned the DWO file meant that it was impossible (or at least hard and unintuitive) to support DWO files containing more than one compile unit. These kinds of files are produced by LTO for example.
• it made it impossible to reference any DIEs in the skeleton compile unit (although the skeleton units are generally empty, clang still puts some info into them with -fsplit-dwarf-inlining).
• (current motivation) it made it very hard to support type units placed in DWO files, as type units don't have any skeleton units which could be referenced in the main file

This patch addresses this problem by introducing an additional
"dwo_num" field to the DIERef class, whose purpose is to identify the
dwo file. It's kind of similar to the dwo_id field in DWARF5 unit
headers, but while this is a 64bit hash whose main purpose is to catch
file mismatches, this is just a smaller integer used to indentify a
loaded dwo file. Currently, this is based on the index of the skeleton
compile unit which owns the dwo file, but it is intended to be
eventually independent of that (to support the LTO use case).

Simultaneously the unit_offset field is changed to reference the compile
unit containing the referenced die instead of the main unit. This means
we can remove the "BaseObjectOffset" field from the DWARFUnit class. It
also means we can remove some of the workarounds put in place to support
the skeleton-unit+dwo-die combo. More work is needed to remove all of
them, which is out of scope of this patch.

[clayborg]

I am concerned with increasing the size of DIERef objects. If we go to 12 bytes per DIERef, and we mostly store these in NameToDIE in "lldb_private::UniqueCStringMap<DIERef> m_map;" maps, which contain a std::vector of UniqueCStringMap::Entry objects which are:

struct Entry {
  ConstString cstring;
  T value;
};

Where T is DIERef. This will align to 24 bytes. Before we would be at 16 when DIERef was 8 bytes. I know we already exceeded the 8 byte size of DIERef with the added "section" field in DIERef with SVN revision 360872, so we already have 24 byte alignment, but the memory used by LLDB for large debug sessions will have increased significantly since a month ago.

If DIERef becomes the same size as DWARFDIE objects, we still need DIERef as when we index the DWARF we end up with DIERef objects and then we can unload the actual DWARF for the compile unit (so we can't switch over to using DWARFDIE since they have pointers to the loaded DWARF DIEs, but we will need to watch for code that might have been using a DIERef in lieu of DWARFDIE objects due to the DIERef size being smaller, but now that they are closer or will usually align to the same size, some clients might be able to switch over to use DWARFDIE objects now that there is really no size win.

So to address my concern with increase in DIERef size is wether we can use the "lldb::user_id_t" in the NameToDie map if we can always change a user_id_t into a DIERef and get back a size win in the process? Possibly look at anyone else storing DIERef objects and see if they can use lldb::user_id_t values too?

source/Plugins/SymbolFile/DWARF/DIERef.h

50–53

I'm a bit concerned about increasing the size by 4 bytes here. All of our indexes are using maps of name to DIERef objects right?

53

Insert a message here?

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

245–246

Make a DWARFDIE accessor function?:

DIERef DWARFDIE::GetDIERef() const;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1502

Can a DWO file be missing and ever return NULL here?

1503

NULL can never be returned here?

[labath]

I've been thinking about the DIERef class a lot while doing this, and the more I thought about it, the more I became convinced that forcing everything to go through DIERefs is not a good idea. It is kind of useful to have it as a sort of exchange currency between various components, but that means it forces an particular access pattern for the debug info, one which may not be always optimal. For example, there's no reason why the manual index would need to use offsets of anything. Offsets require binary search, but the manual index has already gone through the debug info once, so it can easily remember the indexes of everything. Indexes don't need binary search, and they can be stored more compactly. Even for the debug_names index, which does use offsets, the DIERef representation is not the ideal form. That's because it uses unit-relative die indexes while DIERef stores the absolute index. This means it still has to look up the DWO unit in order to correctly construct an absolute die offset.

So, I was thinking that instead of the indexes handing vectors of DIERef, they could provide an iterator api that would return DWARFDIEs directly. This way each index would be completely free to use whatever internal representation it wants. All it would need to do is to be able to convert it to a DWARFDIE eventually. The reason I've put putting it off for now is that the iterators, when combined with the polymorphism of the index class can get a bit messy, and so I wasn't sure if this is worth that effort. However, I agree that the size of the manual index is important, so I am going to post a dumbed-down version of this idea, which uses a compact representation internally, but then still converts it to an array of DIERefs.

source/Plugins/SymbolFile/DWARF/DIERef.h

50–53

I would say only the manual index is affected by this. All the indexes *return* results as a DIERef, but I don't think that's a problem because they don't store them this way internally.

53

What would you have me say? I can't think of anything that wouldn't already be obvious from the assert condition. I think that's one of the reasons why c++>=14 makes the message optional..

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

245–246

Actually, there is one already, I just forgot to use it.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1502

Given that the DWO numbers are completely made up and handed out by SymbolFileDWARFDwos, the only way you can get a valid dwo number is if you already had a SymbolFileDWARFDwo to give it to you. That means we can assume that the unit at the given index will be a skeleton unit and that it will contain a valid dwo symbol file.

[labath]

• use the existing function for DWARFDIE->DIERef conversion
• fix a bug where we were ignoring the dwo_num and section fields when searching for all entries in a given unit. Technically, this was incorrect even when we introduced the "section" field, but there it did not matter because this function is only used for searching for global variables, and those don't appear in a type unit. Add a test.

[labath]

Remove the cu_offset field from DIERef, bringing the total size back down to "8", as dicussed here, and on D63491.

[clayborg]

source/Plugins/SymbolFile/DWARF/DIERef.h

30–35

maybe make "llvm::Optional<uint32_t> num" the last arg and give it a llvm::None default argument value? Rename to dwo_num as well.

50–51

Can we use "uint32_t" here? Explicitly specify the size would be nice.

Also we can avoid using invalid_dwo_num in this class if we do:

uint32_t m_dwo_num : 30;
uint32_t m_dwo_valid : 1;
uint32_t m_section : 1;

source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

20

can/should we still pass "const DIERef &ref" by value like we used to now that it is smaller?

source/Plugins/SymbolFile/DWARF/DWARFIndex.h

60

can/should we still pass "const DIERef &ref" by value like we used to now that it is smaller?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1233–1241

Can we move the lldb::user_id_t code into DIERef now that it is really simple to decode? Too many details are leaking out of DIERef like its invalid dwo num enocding, where the section is in the user_id_t...

This code could be:

return DecodedUID{*this, DIERef(uid)};

[labath]

source/Plugins/SymbolFile/DWARF/DIERef.h

30–35

I'd rather not do that. There aren't that many places that are constructing DIERefs -- I counted just four, and only one (the one in apple index) of them is passing llvm::None as the argument. I think it's better to have the person writing the code stop and think about what is the right value here, instead of just hoping that the default argument will be correct (which it won't be, in most cases).

Also having the arguments ordered this way makes it a nice logical progression. First you select the file, then the section in that file, and finally you give the offset in that section.

source/Plugins/SymbolFile/DWARF/DWARFIndex.h

60

Yeah, that's a good point.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1233–1241

I don't think that's a good idea for two reasons:

• decoding is fairly simply in the non-debug-map case, but with a debug-map, the decoding is still relatively complicated, as you need to consult the debug map in order to find the right symbol file. If we don't move that part into the DIERef class, then we'll end up with a constructor that only works in some cases, which will be confusing. If we do move it, then we're letting information about SymbolFileDWARF and it's relationship to SymbolFileDWARFDebugMap leak into DIERef class.
• I wouldn't even say this is leaking information out of the DIERef class. SymbolFileDWARF is responsible for the conversion from a DIERef into a user_id_t (in SymbolFileDWARF::GetUID), and so it should also covert it back. For that to work, it obviously needs to be aware of the fields in the DIERef and their value ranges, but it is free to encode that information into a user_id_t any way it sees fit. (However, this reminds me that I should update GetUID to make use of the dwo_num abstraction. Right now, it works because the dwo_num is derived from the SymbolFile ID, but it would be cleaner to use dwo_num explicitly.)

[labath]

• use uint32_t for bitfields
• pass DIERefs by value
• implement GetUID so that it is structurally similar to the decoding code in DecodeUID

[clayborg]

source/Plugins/SymbolFile/DWARF/DIERef.h

35

Sounds good

lit/SymbolFile/DWARF/find-variable-file.cpp

 // REQUIRES: lld
 
 // RUN: %clang -g -c -o %t-1.o --target=x86_64-pc-linux -mllvm -accel-tables=Disable %s
 // RUN: %clang -g -c -o %t-2.o --target=x86_64-pc-linux -mllvm -accel-tables=Disable %S/Inputs/find-variable-file-2.cpp
 // RUN: ld.lld %t-1.o %t-2.o -o %t
 // RUN: lldb-test symbols --file=find-variable-file.cpp --find=variable %t | \
 // RUN:   FileCheck --check-prefix=ONE %s
 // RUN: lldb-test symbols --file=find-variable-file-2.cpp --find=variable %t | \
 // RUN:   FileCheck --check-prefix=TWO %s
 
+// Run the same test with split-dwarf. This is interesting because the two
+// split compile units will have the same offset (0).
+// RUN: %clang -g -c -o %t-1.o --target=x86_64-pc-linux -gsplit-dwarf %s
+// RUN: %clang -g -c -o %t-2.o --target=x86_64-pc-linux -gsplit-dwarf %S/Inputs/find-variable-file-2.cpp
+// RUN: ld.lld %t-1.o %t-2.o -o %t
+// RUN: lldb-test symbols --file=find-variable-file.cpp --find=variable %t | \
+// RUN:   FileCheck --check-prefix=ONE %s
+// RUN: lldb-test symbols --file=find-variable-file-2.cpp --find=variable %t | \
+// RUN:   FileCheck --check-prefix=TWO %s
+
 // RUN: %clang -g -c -o %t-1.o --target=x86_64-pc-linux -mllvm -accel-tables=Dwarf %s
 // RUN: %clang -g -c -o %t-2.o --target=x86_64-pc-linux -mllvm -accel-tables=Dwarf %S/Inputs/find-variable-file-2.cpp
 // RUN: ld.lld %t-1.o %t-2.o -o %t
 // RUN: lldb-test symbols --file=find-variable-file.cpp --find=variable %t | \
 // RUN:   FileCheck --check-prefix=ONE %s
 // RUN: lldb-test symbols --file=find-variable-file-2.cpp --find=variable %t | \
 // RUN:   FileCheck --check-prefix=TWO %s
 

source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.h

void GetGlobalVariables(const RegularExpression &regex,
                           DIEArray &offsets) override;
   void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
   void GetObjCMethods(ConstString class_name, DIEArray &offsets) override;
   void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
                             DIEArray &offsets) override;
   void GetTypes(ConstString name, DIEArray &offsets) override;
   void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
   void GetNamespaces(ConstString name, DIEArray &offsets) override;
-  void GetFunctions(ConstString name, DWARFDebugInfo &info,
+  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
                     std::vector<DWARFDIE> &dies) override;
   void GetFunctions(const RegularExpression &regex, DIEArray &offsets) override;
 
   void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override;
   void Dump(Stream &s) override;
 

source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

 //===-- AppleDWARFIndex.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/AppleDWARFIndex.h"
-#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 
 using namespace lldb_private;
if (has_tag && has_qualified_name_hash) {
     m_apple_types_up->FindByName(type_name.GetStringRef(), offsets);
 }
 
 void AppleDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
   if (m_apple_namespaces_up)
     m_apple_namespaces_up->FindByName(name.GetStringRef(), offsets);
 }
 
-void AppleDWARFIndex::GetFunctions(ConstString name, DWARFDebugInfo &info,
+void AppleDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                                    const CompilerDeclContext &parent_decl_ctx,
                                    uint32_t name_type_mask,
                                    std::vector<DWARFDIE> &dies) {
   DIEArray offsets;
   m_apple_names_up->FindByName(name.GetStringRef(), offsets);
   for (const DIERef &die_ref : offsets) {
-    ProcessFunctionDIE(name.GetStringRef(), die_ref, info, parent_decl_ctx,
+    ProcessFunctionDIE(name.GetStringRef(), die_ref, dwarf, parent_decl_ctx,
                        name_type_mask, dies);
   }
 }
 
 void AppleDWARFIndex::GetFunctions(const RegularExpression &regex,
                                    DIEArray &offsets) {
   if (!m_apple_names_up)
     return;

source/Plugins/SymbolFile/DWARF/DIERef.h

 //===-- DIERef.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DIERef_h_
 #define SymbolFileDWARF_DIERef_h_
 
 #include "lldb/Core/dwarf.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FormatProviders.h"
+#include <cassert>
 #include <vector>
 
 /// Identifies a DWARF debug info entry within a given Module. It contains three
 /// "coordinates":
-/// - section: identifies the section of the debug info entry: debug_info or
-///   debug_types
-/// - unit_offset: the offset of the unit containing the debug info entry. For
-///   regular (unsplit) units, this field is optional, as the die_offset is
-///   enough to uniquely identify the containing unit. For split units, this
-///   field must contain the offset of the skeleton unit in the main object
-///   file.
-/// - die_offset: The offset of te debug info entry as an absolute offset from
+/// - dwo_num: identifies the dwo file in the Module. If this field is not set,
+///   the DIERef references the main file.
+/// - section: identifies the section of the debug info entry in the given file:
+///   debug_info or debug_types.
+/// - die_offset: The offset of the debug info entry as an absolute offset from
 ///   the beginning of the section specified in the section field.
 class DIERef {
 public:
   enum Section : uint8_t { DebugInfo, DebugTypes };
 
-  DIERef(Section s, llvm::Optional<dw_offset_t> u, dw_offset_t d)
-      : m_section(s), m_unit_offset(u.getValueOr(DW_INVALID_OFFSET)),
-        m_die_offset(d) {}
-
-  Section section() const { return static_cast<Section>(m_section); }
+  DIERef(llvm::Optional<uint32_t> dwo_num, Section section,
+         dw_offset_t die_offset)
+      : m_dwo_num(dwo_num.getValueOr(0)), m_dwo_num_valid(bool(dwo_num)),
+        m_section(section), m_die_offset(die_offset) {
+    assert(this->dwo_num() == dwo_num && "Dwo number out of range?");
+  }
 
-  llvm::Optional<dw_offset_t> unit_offset() const {
-    if (m_unit_offset != DW_INVALID_OFFSET)
-      return m_unit_offset;
+  llvm::Optional<uint32_t> dwo_num() const {
+    if (m_dwo_num_valid)
+      return m_dwo_num;
     return llvm::None;
   }
 
+  Section section() const { return static_cast<Section>(m_section); }
+
   dw_offset_t die_offset() const { return m_die_offset; }
 
 private:
-  unsigned m_section : 1;
-  dw_offset_t m_unit_offset;
+  uint32_t m_dwo_num : 30;
+  uint32_t m_dwo_num_valid : 1;
+  uint32_t m_section : 1;
   dw_offset_t m_die_offset;
 };
+static_assert(sizeof(DIERef) == 8, "");
 
 typedef std::vector<DIERef> DIEArray;
 
 namespace llvm {
 template<> struct format_provider<DIERef> {
   static void format(const DIERef &ref, raw_ostream &OS, StringRef Style);
 };
 } // namespace llvm
 
 #endif // SymbolFileDWARF_DIERef_h_

source/Plugins/SymbolFile/DWARF/DIERef.cpp

 //===-- DIERef.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DIERef.h"
 #include "llvm/Support/Format.h"
 
 void llvm::format_provider<DIERef>::format(const DIERef &ref, raw_ostream &OS,
                                            StringRef Style) {
+  if (ref.dwo_num())
+    OS << format_hex_no_prefix(*ref.dwo_num(), 8) << "/";
   OS << (ref.section() == DIERef::DebugInfo ? "INFO" : "TYPE");
-  if (ref.unit_offset())
-    OS << "/" << format_hex_no_prefix(*ref.unit_offset(), 8);
   OS << "/" << format_hex_no_prefix(ref.die_offset(), 8);
 }

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

 #include "lldb/Symbol/ObjectFile.h"
 
 using namespace lldb_private;
 
 llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
   if (!IsValid())
     return llvm::None;
 
-  dw_offset_t cu_offset = m_cu->GetOffset();
-  if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
-    cu_offset = m_cu->GetBaseObjOffset();
-  return DIERef(m_cu->GetDebugSection(), cu_offset, m_die->GetOffset());
+  return DIERef(m_cu->GetSymbolFileDWARF().GetDwoNum(), m_cu->GetDebugSection(),
+                m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else
     return 0;
 }

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

if (IsValid()) {
     DWARFUnit *cu = GetCU();
     DWARFDebugInfoEntry *function_die = nullptr;
     DWARFDebugInfoEntry *block_die = nullptr;
     if (m_die->LookupAddress(file_addr, cu, &function_die, &block_die)) {
       if (block_die && block_die != function_die) {
         if (cu->ContainsDIEOffset(block_die->GetOffset()))
           return DWARFDIE(cu, block_die);
         else
-          return DWARFDIE(dwarf->DebugInfo()->GetUnit(
-                              DIERef(cu->GetDebugSection(), cu->GetOffset(),
-                                     block_die->GetOffset())),
+          return DWARFDIE(dwarf->DebugInfo()->GetUnit(DIERef(
+                              cu->GetSymbolFileDWARF().GetDwoNum(),
+                              cu->GetDebugSection(), block_die->GetOffset())),
                           block_die);
       }
     }
   }
   return DWARFDIE();
 }
 
 const char *DWARFDIE::GetMangledName() const {

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

if (result && result->GetOffset() != cu_offset) {
     idx = DW_INVALID_INDEX;
   }
   if (idx_ptr)
     *idx_ptr = idx;
   return result;
 }
 
 DWARFUnit *DWARFDebugInfo::GetUnit(const DIERef &die_ref) {
-  if (die_ref.unit_offset())
-    return GetUnitAtOffset(die_ref.section(), *die_ref.unit_offset());
   return GetUnitContainingDIEOffset(die_ref.section(), die_ref.die_offset());
 }
 
 DWARFUnit *
 DWARFDebugInfo::GetUnitContainingDIEOffset(DIERef::Section section,
                                            dw_offset_t die_offset) {
   uint32_t idx = FindUnitIndex(section, die_offset);
   DWARFUnit *result = GetUnitAtIndex(idx);

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 //
 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges attributes.
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
     const DWARFUnit *cu, const char *&name, const char *&mangled,
     DWARFRangeList &ranges, int &decl_file, int &decl_line, int &decl_column,
     int &call_file, int &call_line, int &call_column,
     DWARFExpression *frame_base) const {
-  SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
-  if (dwo_symbol_file)
-    return GetDIENamesAndRanges(
-        dwo_symbol_file->GetCompileUnit(), name, mangled, ranges, decl_file,
-        decl_line, decl_column, call_file, call_line, call_column, frame_base);
-
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
   std::vector<DWARFDIE> dies;
   bool set_frame_base_loclist_addr = false;
 
   auto abbrevDecl = GetAbbreviationDeclarationPtr(cu);
 
   SymbolFileDWARF &dwarf = cu->GetSymbolFileDWARF();

 // Get the value of an attribute and return the .debug_info or .debug_types
 // offset of the attribute if it was properly extracted into form_value,
 // or zero if we fail since an offset of zero is invalid for an attribute (it
 // would be a compile unit header).
 dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
     const DWARFUnit *cu, const dw_attr_t attr, DWARFFormValue &form_value,
     dw_offset_t *end_attr_offset_ptr,
     bool check_specification_or_abstract_origin) const {
-  SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
-  if (dwo_symbol_file && m_tag != DW_TAG_compile_unit &&
-                         m_tag != DW_TAG_partial_unit)
-    return GetAttributeValue(dwo_symbol_file->GetCompileUnit(), attr,
-                             form_value, end_attr_offset_ptr,
-                             check_specification_or_abstract_origin);
-
-  auto abbrevDecl = GetAbbreviationDeclarationPtr(cu);
-
-  if (abbrevDecl) {
+  if (auto *abbrevDecl = GetAbbreviationDeclarationPtr(cu)) {
     uint32_t attr_idx = abbrevDecl->FindAttributeIndex(attr);
 
     if (attr_idx != DW_INVALID_INDEX) {
       const DWARFDataExtractor &data = cu->GetData();
       lldb::offset_t offset = GetFirstAttributeOffset();
 
       uint32_t idx = 0;
       while (idx < attr_idx)
if (GetAttributeValue(cu, DW_AT_abstract_origin, form_value)) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
         if (die_offset)
           return die_offset;
       }
     }
   }
 
+  // If we're a unit DIE, also check the attributes of the dwo unit (if any).
+  if (GetParent())
+    return 0;
+  SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (!dwo_symbol_file)
     return 0;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return 0;
 
   DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();

source/Plugins/SymbolFile/DWARF/DWARFIndex.h

 //===-- DWARFIndex.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_DWARFINDEX_H
 #define LLDB_DWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DIERef.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/DWARFFormValue.h"
 
-class DWARFDebugInfo;
 class DWARFDeclContext;
 class DWARFDIE;
 
 namespace lldb_private {
 class DWARFIndex {
 public:
   DWARFIndex(Module &module) : m_module(module) {}
   virtual ~DWARFIndex();
public:
   virtual void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) = 0;
   virtual void GetObjCMethods(ConstString class_name, DIEArray &offsets) = 0;
   virtual void GetCompleteObjCClass(ConstString class_name,
                                     bool must_be_implementation,
                                     DIEArray &offsets) = 0;
   virtual void GetTypes(ConstString name, DIEArray &offsets) = 0;
   virtual void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) = 0;
   virtual void GetNamespaces(ConstString name, DIEArray &offsets) = 0;
-  virtual void GetFunctions(ConstString name, DWARFDebugInfo &info,
+  virtual void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                             const CompilerDeclContext &parent_decl_ctx,
                             uint32_t name_type_mask,
                             std::vector<DWARFDIE> &dies) = 0;
   virtual void GetFunctions(const RegularExpression &regex,
                             DIEArray &offsets) = 0;
 
   virtual void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) = 0;
   virtual void Dump(Stream &s) = 0;
 
 protected:
   Module &m_module;
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
   void ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
-                          DWARFDebugInfo &info,
+                          SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,
                           uint32_t name_type_mask, std::vector<DWARFDIE> &dies);
 };
 } // namespace lldb_private
 
 #endif // LLDB_DWARFINDEX_H

source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

 //===-- DWARFIndex.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
-#include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
-#include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
-
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
+#include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 DWARFIndex::~DWARFIndex() = default;
 
 void DWARFIndex::ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
-                                    DWARFDebugInfo &info,
+                                    SymbolFileDWARF &dwarf,
                                     const CompilerDeclContext &parent_decl_ctx,
                                     uint32_t name_type_mask,
                                     std::vector<DWARFDIE> &dies) {
-  DWARFDIE die = info.GetDIE(ref);
+  DWARFDIE die = dwarf.GetDIE(ref);
   if (!die) {
     ReportInvalidDIERef(ref, name);
     return;
   }
 
   // Exit early if we're searching exclusively for methods or selectors and
   // we have a context specified (no methods in namespaces).
   uint32_t looking_for_nonmethods =

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   uint8_t GetAddressByteSize() const { return m_header.GetAddressByteSize(); }
   dw_addr_t GetAddrBase() const { return m_addr_base; }
   dw_addr_t GetBaseAddress() const { return m_base_addr; }
   dw_offset_t GetLineTableOffset();
   dw_addr_t GetRangesBase() const { return m_ranges_base; }
   dw_addr_t GetStrOffsetsBase() const { return m_str_offsets_base; }
   void SetAddrBase(dw_addr_t addr_base);
   void SetRangesBase(dw_addr_t ranges_base);
-  void SetBaseObjOffset(dw_offset_t base_obj_offset);
   void SetStrOffsetsBase(dw_offset_t str_offsets_base);
   virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0;
 
   lldb::ByteOrder GetByteOrder() const;
 
   lldb_private::TypeSystem *GetTypeSystem();
 
   const DWARFDebugAranges &GetFunctionAranges();
 
   void SetBaseAddress(dw_addr_t base_addr);
 
   DWARFBaseDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
 
   DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }
 
   DWARFDIE GetDIE(dw_offset_t die_offset);
 
+  DWARFUnit &GetNonSkeletonUnit();
+
   static uint8_t GetAddressByteSize(const DWARFUnit *cu);
 
   static uint8_t GetDefaultAddressSize();
 
   void *GetUserData() const;
 
   void SetUserData(void *d);
 
public:
 
   const lldb_private::FileSpec &GetCompilationDirectory();
   const lldb_private::FileSpec &GetAbsolutePath();
   lldb_private::FileSpec GetFile(size_t file_idx);
   lldb_private::FileSpec::Style GetPathStyle();
 
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
-  dw_offset_t GetBaseObjOffset() const;
-
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
   DIERef::Section GetDebugSection() const { return m_section; }
 
   uint8_t GetUnitType() const { return m_header.GetUnitType(); }
protected:
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   llvm::Optional<lldb_private::FileSpec> m_file_spec;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
-  // If this is a dwo compile unit this is the offset of the base compile unit
-  // in the main object file
-  dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;
 
   /// Value of DW_AT_stmt_list.
   dw_offset_t m_line_table_offset = DW_INVALID_OFFSET;
 
   dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base.
   const DIERef::Section m_section;
 
 private:

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
   else if (gnu_addr_base)
     dwo_cu->SetAddrBase(*gnu_addr_base);
 
   if (ranges_base)
     dwo_cu->SetRangesBase(*ranges_base);
   else if (gnu_ranges_base)
     dwo_cu->SetRangesBase(*gnu_ranges_base);
 
-  dwo_cu->SetBaseObjOffset(GetOffset());
   SetDwoStrOffsetsBase(dwo_cu);
 }
 
 DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {
   if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 
     // Re-check the aranges auto pointer contents in case it was created above

 }
 
 void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; }
 
 void DWARFUnit::SetRangesBase(dw_addr_t ranges_base) {
   m_ranges_base = ranges_base;
 }
 
-void DWARFUnit::SetBaseObjOffset(dw_offset_t base_obj_offset) {
-  m_base_obj_offset = base_obj_offset;
-}
-
 void DWARFUnit::SetStrOffsetsBase(dw_offset_t str_offsets_base) {
   m_str_offsets_base = str_offsets_base;
 }
 
 // It may be called only with m_die_array_mutex held R/W.
 void DWARFUnit::ClearDIEsRWLocked() {
   m_die_array.clear();
   m_die_array.shrink_to_fit();
if (die_offset != DW_INVALID_OFFSET) {
     } else
       GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "GetDIE for DIE 0x%" PRIx32 " is outside of its CU 0x%" PRIx32,
           die_offset, GetOffset());
   }
   return DWARFDIE(); // Not found
 }
 
+DWARFUnit &DWARFUnit::GetNonSkeletonUnit() {
+  if (SymbolFileDWARFDwo *dwo = GetDwoSymbolFile())
+    return *dwo->GetCompileUnit();
+  return *this;
+}
+
 uint8_t DWARFUnit::GetAddressByteSize(const DWARFUnit *cu) {
   if (cu)
     return cu->GetAddressByteSize();
   return DWARFUnit::GetDefaultAddressSize();
 }
 
 uint8_t DWARFUnit::GetDefaultAddressSize() { return 4; }
 
void DWARFUnit::ComputeAbsolutePath() {
   if (m_file_spec->IsRelative())
     m_file_spec->MakeAbsolute(GetCompilationDirectory());
 }
 
 SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
   return m_dwo_symbol_file.get();
 }
 
-dw_offset_t DWARFUnit::GetBaseObjOffset() const { return m_base_obj_offset; }
-
 const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() {
   if (m_func_aranges_up == nullptr) {
     m_func_aranges_up.reset(new DWARFDebugAranges());
     const DWARFDebugInfoEntry *die = DIEPtr();
     if (die)
       die->BuildFunctionAddressRangeTable(this, m_func_aranges_up.get());
 
     if (m_dwo_symbol_file) {

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h

void GetGlobalVariables(const RegularExpression &regex,
                           DIEArray &offsets) override;
   void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
   void GetObjCMethods(ConstString class_name, DIEArray &offsets) override {}
   void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
                             DIEArray &offsets) override;
   void GetTypes(ConstString name, DIEArray &offsets) override;
   void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
   void GetNamespaces(ConstString name, DIEArray &offsets) override;
-  void GetFunctions(ConstString name, DWARFDebugInfo &info,
+  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
                     std::vector<DWARFDIE> &dies) override;
   void GetFunctions(const RegularExpression &regex,
                     DIEArray &offsets) override;
 
   void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override {}
   void Dump(Stream &s) override;

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
   DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, *cu_offset);
   if (!cu)
     return llvm::None;
 
   // This initializes the DWO symbol file. It's not possible for
   // GetDwoSymbolFile to call this automatically because of mutual recursion
   // between this and DWARFDebugInfoEntry::GetAttributeValue.
   cu->ExtractUnitDIEIfNeeded();
-  uint64_t die_bias = cu->GetDwoSymbolFile() ? 0 : *cu_offset;
+  cu = &cu->GetNonSkeletonUnit();
 
   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
-    return DIERef(DIERef::Section::DebugInfo, *cu_offset, die_bias + *die_offset);
+    return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(),
+                  DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
 
   return llvm::None;
 }
 
 void DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
                                   DIEArray &offsets) {
   if (llvm::Optional<DIERef> ref = ToDIERef(entry))
     offsets.push_back(*ref);
for (const DebugNames::Entry &entry :
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
     llvm::Optional<DIERef> ref = ToDIERef(entry);
     if (!ref)
       continue;
 
-    DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo,
-                                                 *ref->unit_offset());
+    DWARFUnit *cu = m_debug_info.GetUnit(*ref);
     if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) {
       incomplete_types.push_back(*ref);
       continue;
     }
 
     // FIXME: We should return DWARFDIEs so we don't have to resolve it twice.
     DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die)
void DebugNamesDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (entry.tag() == DW_TAG_namespace)
       Append(entry, offsets);
   }
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
-    ConstString name, DWARFDebugInfo &info,
+    ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
     std::vector<DWARFDIE> &dies) {
 
   std::vector<DWARFDIE> v;
-  m_fallback.GetFunctions(name, info, parent_decl_ctx, name_type_mask, v);
+  m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask, v);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
     if (llvm::Optional<DIERef> ref = ToDIERef(entry))
-      ProcessFunctionDIE(name.GetStringRef(), *ref, info, parent_decl_ctx,
+      ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
                          name_type_mask, v);
   }
 
   std::set<DWARFDebugInfoEntry *> seen;
   for (DWARFDIE die : v)
     if (seen.insert(die.GetDIE()).second)
       dies.push_back(die);
 }

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

struct DIEInfo {
 
     /// A 32 bit hash of the fully qualified name
     uint32_t qualified_name_hash = 0;
 
     DIEInfo() = default;
     DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
 
     explicit operator DIERef() const {
-      return DIERef(DIERef::Section::DebugInfo, llvm::None, die_offset);
+      return DIERef(llvm::None, DIERef::Section::DebugInfo, die_offset);
     }
   };
 
   struct Atom {
     AtomType type;
     dw_form_t form;
   };
 

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h

 //===-- ManualDWARFIndex.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_MANUALDWARFINDEX_H
 #define LLDB_MANUALDWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/NameToDIE.h"
 #include "llvm/ADT/DenseSet.h"
 
+class DWARFDebugInfo;
+
 namespace lldb_private {
 class ManualDWARFIndex : public DWARFIndex {
 public:
   ManualDWARFIndex(Module &module, DWARFDebugInfo *debug_info,
                    llvm::DenseSet<dw_offset_t> units_to_avoid = {})
       : DWARFIndex(module), m_debug_info(debug_info),
         m_units_to_avoid(std::move(units_to_avoid)) {}
 
   void Preload() override { Index(); }
 
   void GetGlobalVariables(ConstString basename, DIEArray &offsets) override;
   void GetGlobalVariables(const RegularExpression &regex,
                           DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
+  void GetGlobalVariables(const DWARFUnit &unit, DIEArray &offsets) override;
   void GetObjCMethods(ConstString class_name, DIEArray &offsets) override;
   void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
                             DIEArray &offsets) override;
   void GetTypes(ConstString name, DIEArray &offsets) override;
   void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
   void GetNamespaces(ConstString name, DIEArray &offsets) override;
-  void GetFunctions(ConstString name, DWARFDebugInfo &info,
+  void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
                     std::vector<DWARFDIE> &dies) override;
   void GetFunctions(const RegularExpression &regex, DIEArray &offsets) override;
 
   void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override {}
   void Dump(Stream &s) override;
 
 private:
   struct IndexSet {
     NameToDIE function_basenames;
     NameToDIE function_fullnames;
     NameToDIE function_methods;
     NameToDIE function_selectors;
     NameToDIE objc_class_selectors;
     NameToDIE globals;
     NameToDIE types;
     NameToDIE namespaces;
   };
   void Index();
   void IndexUnit(DWARFUnit &unit, IndexSet &set);
 
-  static void
-  IndexUnitImpl(DWARFUnit &unit, const lldb::LanguageType cu_language,
-                const dw_offset_t cu_offset, IndexSet &set);
+  static void IndexUnitImpl(DWARFUnit &unit,
+                            const lldb::LanguageType cu_language,
+                            IndexSet &set);
 
   /// Non-null value means we haven't built the index yet.
   DWARFDebugInfo *m_debug_info;
   /// Which dwarf units should we skip while building the index.
   llvm::DenseSet<dw_offset_t> m_units_to_avoid;
 
   IndexSet m_set;
 };
 } // namespace lldb_private
 
 #endif // LLDB_MANUALDWARFINDEX_H

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, IndexSet &set) {
   if (log) {
     m_module.LogMessage(
         log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = unit.GetLanguageType();
 
-  IndexUnitImpl(unit, cu_language, unit.GetOffset(), set);
+  IndexUnitImpl(unit, cu_language, set);
 
   SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile();
   if (dwo_symbol_file && dwo_symbol_file->GetCompileUnit()) {
-    IndexUnitImpl(*dwo_symbol_file->GetCompileUnit(), cu_language,
-                  unit.GetOffset(), set);
+    IndexUnitImpl(*dwo_symbol_file->GetCompileUnit(), cu_language, set);
   }
 }
 
-void ManualDWARFIndex::IndexUnitImpl(
-    DWARFUnit &unit, const LanguageType cu_language,
-    const dw_offset_t cu_offset, IndexSet &set) {
+void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
+                                     const LanguageType cu_language,
+                                     IndexSet &set) {
   for (const DWARFDebugInfoEntry &die : unit.dies()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
if (num_attributes > 0) {
         case DW_AT_specification:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             specification_die_form = form_value;
           break;
         }
       }
     }
 
-    DIERef ref(unit.GetDebugSection(), cu_offset, die.GetOffset());
+    DIERef ref = *DWARFDIE(&unit, &die).GetDIERef();
     switch (tag) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_subprogram:
       if (has_address) {
         if (name) {
           bool is_objc_method = false;
           if (cu_language == eLanguageTypeObjC ||
               cu_language == eLanguageTypeObjC_plus_plus) {
             ObjCLanguage::MethodName objc_method(name, true);

 }
 
 void ManualDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
                                           DIEArray &offsets) {
   Index();
   m_set.globals.Find(regex, offsets);
 }
 
-void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
+void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &unit,
                                           DIEArray &offsets) {
   Index();
-  m_set.globals.FindAllEntriesForCompileUnit(cu.GetOffset(), offsets);
+  m_set.globals.FindAllEntriesForUnit(unit, offsets);
 }
 
 void ManualDWARFIndex::GetObjCMethods(ConstString class_name,
                                       DIEArray &offsets) {
   Index();
   m_set.objc_class_selectors.Find(class_name, offsets);
 }
 
void ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
   m_set.types.Find(ConstString(context[0].name), offsets);
 }
 
 void ManualDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
   Index();
   m_set.namespaces.Find(name, offsets);
 }
 
-void ManualDWARFIndex::GetFunctions(ConstString name, DWARFDebugInfo &info,
+void ManualDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                                     const CompilerDeclContext &parent_decl_ctx,
                                     uint32_t name_type_mask,
                                     std::vector<DWARFDIE> &dies) {
   Index();
 
   if (name_type_mask & eFunctionNameTypeFull) {
     DIEArray offsets;
     m_set.function_basenames.Find(name, offsets);
     m_set.function_methods.Find(name, offsets);
     m_set.function_fullnames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
-      DWARFDIE die = info.GetDIE(die_ref);
+      DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
       if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
         dies.push_back(die);
     }
   }
   if (name_type_mask & eFunctionNameTypeBase) {
     DIEArray offsets;
     m_set.function_basenames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
-      DWARFDIE die = info.GetDIE(die_ref);
+      DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
       if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
         dies.push_back(die);
     }
     offsets.clear();
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
     DIEArray offsets;
     m_set.function_methods.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
-      if (DWARFDIE die = info.GetDIE(die_ref))
+      if (DWARFDIE die = dwarf.GetDIE(die_ref))
         dies.push_back(die);
     }
   }
 
   if (name_type_mask & eFunctionNameTypeSelector &&
       !parent_decl_ctx.IsValid()) {
     DIEArray offsets;
     m_set.function_selectors.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
-      if (DWARFDIE die = info.GetDIE(die_ref))
+      if (DWARFDIE die = dwarf.GetDIE(die_ref))
         dies.push_back(die);
     }
   }
 }
 
 void ManualDWARFIndex::GetFunctions(const RegularExpression &regex,
                                     DIEArray &offsets) {
   Index();

source/Plugins/SymbolFile/DWARF/NameToDIE.h

 
 #include <functional>
 
 #include "DIERef.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-defines.h"
 
-class SymbolFileDWARF;
+class DWARFUnit;
 
 class NameToDIE {
 public:
   NameToDIE() : m_map() {}
 
   ~NameToDIE() {}
 
   void Dump(lldb_private::Stream *s);
 
   void Insert(lldb_private::ConstString name, const DIERef &die_ref);
 
   void Append(const NameToDIE &other);
 
   void Finalize();
 
   size_t Find(lldb_private::ConstString name,
               DIEArray &info_array) const;
 
   size_t Find(const lldb_private::RegularExpression &regex,
               DIEArray &info_array) const;
 
-  size_t FindAllEntriesForCompileUnit(dw_offset_t cu_offset,
-                                      DIEArray &info_array) const;
+  size_t FindAllEntriesForUnit(const DWARFUnit &unit,
 
   void
   ForEach(std::function<bool(lldb_private::ConstString name,
                              const DIERef &die_ref)> const
               &callback) const;
 
 protected:
   lldb_private::UniqueCStringMap<DIERef> m_map;
 };
 
 #endif // SymbolFileDWARF_NameToDIE_h_

source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

 //===-- NameToDIE.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "NameToDIE.h"
+#include "DWARFUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
-#include "DWARFDebugInfo.h"
-#include "DWARFDebugInfoEntry.h"
-#include "SymbolFileDWARF.h"
-
 using namespace lldb;
 using namespace lldb_private;
 
 void NameToDIE::Finalize() {
   m_map.Sort();
   m_map.SizeToFit();
 }
 
 void NameToDIE::Insert(ConstString name, const DIERef &die_ref) {
-  assert(die_ref.unit_offset().hasValue());
   m_map.Append(name, die_ref);
 }
 
 size_t NameToDIE::Find(ConstString name, DIEArray &info_array) const {
   return m_map.GetValues(name, info_array);
 }
 
 size_t NameToDIE::Find(const RegularExpression &regex,
                        DIEArray &info_array) const {
   return m_map.GetValues(regex, info_array);
 }
 
-size_t NameToDIE::FindAllEntriesForCompileUnit(dw_offset_t cu_offset,
-                                               DIEArray &info_array) const {
+size_t NameToDIE::FindAllEntriesForUnit(const DWARFUnit &unit,
   const size_t initial_size = info_array.size();
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     const DIERef &die_ref = m_map.GetValueAtIndexUnchecked(i);
-    if (cu_offset == *die_ref.unit_offset())
+    if (unit.GetSymbolFileDWARF().GetDwoNum() == die_ref.dwo_num() &&
+        unit.GetDebugSection() == die_ref.section() &&
+        unit.GetOffset() <= die_ref.die_offset() &&
+        die_ref.die_offset() < unit.GetNextUnitOffset())
       info_array.push_back(die_ref);
   }
   return info_array.size() - initial_size;
 }
 
 void NameToDIE::Dump(Stream *s) {
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
     return GetUID(die.GetDIERef());
   }
 
   lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) {
     return ref ? GetUID(*ref) : LLDB_INVALID_UID;
   }
 
-  lldb::user_id_t GetUID(const DIERef &ref) {
-    return GetID() | ref.die_offset() |
-           (lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes)
-            << 63);
-  }
+  lldb::user_id_t GetUID(DIERef ref);
 
   virtual std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   // For regular SymbolFileDWARF instances the method returns nullptr,
   // for the instances of the subclass SymbolFileDWARFDwo
   // the method returns a pointer to the base compile unit.
   virtual DWARFCompileUnit *GetBaseCompileUnit() { return nullptr; }
 
+  virtual llvm::Optional<uint32_t> GetDwoNum() { return llvm::None; }
+
   static bool
   DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
                    const DWARFDIE &die);
 
   std::vector<lldb_private::CallEdge>
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

std::vector<DWARFDIE> decl_ctx_die_list =
       ast_parser->GetDIEForDeclContext(decl_ctx);
 
   for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
     for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
          decl = decl.GetSibling())
       ast_parser->GetDeclForUIDFromDWARF(decl);
 }
 
+user_id_t SymbolFileDWARF::GetUID(DIERef ref) {
+  if (GetDebugMapSymfile())
+    return GetID() | ref.die_offset();
+
+  return user_id_t(GetDwoNum().getValueOr(0x7fffffff)) << 32 |
+         ref.die_offset() |
+         (lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63);
+}
+
 llvm::Optional<SymbolFileDWARF::DecodedUID>
 SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
   if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
     SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
         debug_map->GetOSOIndexFromUserID(uid));
     return DecodedUID{
-        *dwarf,
-        {DIERef::Section::DebugInfo, DW_INVALID_OFFSET, dw_offset_t(uid)}};
+        *dwarf, {llvm::None, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
   }
-  DIERef::Section section =
-      uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
-  uint32_t dwarf_id = uid >> 32 & 0x7fffffff;
   dw_offset_t die_offset = uid;
-
   if (die_offset == DW_INVALID_OFFSET)
     return llvm::None;
 
-  SymbolFileDWARF *dwarf = this;
-  if (DebugInfo()) {
-    if (DWARFUnit *unit = DebugInfo()->GetUnitAtIndex(dwarf_id)) {
-      if (unit->GetDwoSymbolFile())
-        dwarf = unit->GetDwoSymbolFile();
-    }
-  }
-  return DecodedUID{*dwarf, {section, DW_INVALID_OFFSET, die_offset}};
+  DIERef::Section section =
+      uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
+
+  llvm::Optional<uint32_t> dwo_num = uid >> 32 & 0x7fffffff;
+  if (*dwo_num == 0x7fffffff)
+    dwo_num = llvm::None;
+
+  return DecodedUID{*this, {dwo_num, section, die_offset}};
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
lldb::ModuleSP SymbolFileDWARF::GetDWOModule(ConstString name) {
   if (pos != m_external_type_modules.end())
     return pos->second;
   else
     return lldb::ModuleSP();
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
+  if (die_ref.dwo_num()) {
+    return DebugInfo()
+        ->GetUnitAtIndex(*die_ref.dwo_num())
+        ->GetDwoSymbolFile()
+        ->GetDIE(die_ref);
+  }
+
+
   DWARFDebugInfo *debug_info = DebugInfo();
   if (debug_info)
     return debug_info->GetDIE(die_ref);
   else
     return DWARFDIE();
 }
 
 std::unique_ptr<SymbolFileDWARFDwo>
uint32_t SymbolFileDWARF::FindFunctions(
   if (name.IsEmpty())
     return 0;
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
-  DWARFDebugInfo *info = DebugInfo();
-  if (info == nullptr)
-    return 0;
-
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
   DIEArray offsets;
   CompilerDeclContext empty_decl_ctx;
   if (!parent_decl_ctx)
     parent_decl_ctx = &empty_decl_ctx;
 
   std::vector<DWARFDIE> dies;
-  m_index->GetFunctions(name, *info, *parent_decl_ctx, name_type_mask, dies);
+  m_index->GetFunctions(name, *this, *parent_decl_ctx, name_type_mask, dies);
   for (const DWARFDIE &die: dies) {
     if (resolved_dies.insert(die.GetDIE()).second)
       ResolveFunction(die, include_inlines, sc_list);
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
if (sc.function) {
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == nullptr) {
         variables = std::make_shared<VariableList>();
         sc.comp_unit->SetVariableList(variables);
 
         DIEArray die_offsets;
-        m_index->GetGlobalVariables(*dwarf_cu, die_offsets);
+        m_index->GetGlobalVariables(dwarf_cu->GetNonSkeletonUnit(),
+                                    die_offsets);
         const size_t num_matches = die_offsets.size();
         if (num_matches) {
           for (size_t i = 0; i < num_matches; ++i) {
             const DIERef &die_ref = die_offsets[i];
             DWARFDIE die = GetDIE(die_ref);
             if (die) {
               VariableSP var_sp(
                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

public:
   std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die) override {
     return nullptr;
   }
 
   DWARFCompileUnit *GetBaseCompileUnit() override { return &m_base_dwarf_cu; }
 
+  llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
+
 protected:
   void LoadSectionData(lldb::SectionType sect_type,
                        lldb_private::DWARFDataExtractor &data) override;
 
   DIEToTypePtr &GetDIEToType() override;
 
   DIEToVariableSP &GetDIEToVariable() override;
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 
 TypeSystem *
 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
   return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
 }
 
 DWARFDIE
 SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
-  lldbassert(!die_ref.unit_offset() ||
-             *die_ref.unit_offset() == m_base_dwarf_cu.GetOffset());
-  return DebugInfo()->GetDIEForDIEOffset(die_ref.section(),
-                                         die_ref.die_offset());
+  if (*die_ref.dwo_num() == GetDwoNum())
+    return DebugInfo()->GetDIE(die_ref);
+  return GetBaseSymbolFile().GetDIE(die_ref);
 }