Remove `SymbolFileDWARF *` when there is already `DWARFUnit *`

[jankratochvil]

Summary

In D61502#1503247 @clayborg suggested that SymbolFileDWARF *dwarf2Data is really redundant in all the calls with also having DWARFUnit *cu. So remove it. I see no regressions.

There are some nullptr checks, I changed those needed from dwarf2Data == nullptr to cu == nullptr but then who knows if they can happen.

[jankratochvil]

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

380 ↗

(On Diff #199828)

Here is a NULL check.

1055 ↗

(On Diff #199828)

Here is a NULL check.

1086 ↗

(On Diff #199828)

Here is a NULL check.

[labath]

Seems like a nice cleanup. Given that code code already assumed that the DWARFUnit can't be null, I'd just delete the null checks..

[jankratochvil]

In D62011#1504877, @labath wrote:

Seems like a nice cleanup. Given that code code already assumed that the DWARFUnit can't be null, I'd just delete the null checks..

I have rechecked it now and 2 of the 3 tests are valid, it can be NULL, callers are:

DWARFDebugInfoEntry::DumpAttribute():
  case DW_AT_abstract_origin:
  case DW_AT_specification: {
    DWARFDIE abstract_die = form_value.Reference();
    GetName(abstract_die.GetCU(), abstract_die.GetOffset(), s);
  case DW_AT_type: {
    DWARFDIE type_die = form_value.Reference();
    AppendTypeName(type_die.GetCU(), type_die.GetOffset(), s);

Sorry for not verifying it myself first.

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

 
 const char *DWARFBaseDIE::GetTagAsCString() const {
   return lldb_private::DW_TAG_value_to_name(Tag());
 }
 
 const char *DWARFBaseDIE::GetAttributeValueAsString(const dw_attr_t attr,
                                                 const char *fail_value) const {
   if (IsValid())
-    return m_die->GetAttributeValueAsString(GetDWARF(), GetCU(), attr,
-                                            fail_value);
+    return m_die->GetAttributeValueAsString(GetCU(), attr, fail_value);
   else
     return fail_value;
 }
 
 uint64_t DWARFBaseDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
                                                uint64_t fail_value) const {
   if (IsValid())
-    return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr,
-                                              fail_value);
+    return m_die->GetAttributeValueAsUnsigned(GetCU(), attr, fail_value);
   else
     return fail_value;
 }
 
 uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
                                               uint64_t fail_value) const {
   if (IsValid())
-    return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
-                                             fail_value);
+    return m_die->GetAttributeValueAsAddress(GetCU(), attr, fail_value);
   else
     return fail_value;
 }
 
 lldb::user_id_t DWARFBaseDIE::GetID() const {
   if (IsValid())
     return GetDWARF()->GetUID(*this);
   return LLDB_INVALID_UID;
 }
 
 const char *DWARFBaseDIE::GetName() const {
   if (IsValid())
-    return m_die->GetName(GetDWARF(), m_cu);
+    return m_die->GetName(m_cu);
   else
     return nullptr;
 }
 
 lldb::LanguageType DWARFBaseDIE::GetLanguage() const {
   if (IsValid())
     return m_cu->GetLanguageType();
   else

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

if (IsValid())
     return DWARFDIE(m_cu, m_die->GetSibling());
   else
     return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::GetReferencedDIE(const dw_attr_t attr) const {
   if (IsValid())
-    return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr);
+    return m_die->GetAttributeValueAsReference(GetCU(), attr);
   else
     return {};
 }
 
 DWARFDIE
 DWARFDIE::GetDIE(dw_offset_t die_offset) const {
   if (IsValid())
     return m_cu->GetDIE(die_offset);
   else
     return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   if (IsValid()) {
     DWARFUnit *cu = GetCU();
-    SymbolFileDWARF *dwarf = cu->GetSymbolFileDWARF();
     const bool check_specification_or_abstract_origin = true;
     DWARFFormValue form_value;
-    if (m_die->GetAttributeValue(dwarf, cu, attr, form_value, nullptr,
+    if (m_die->GetAttributeValue(cu, attr, form_value, nullptr,
                                  check_specification_or_abstract_origin))
       return form_value.Reference();
   }
   return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
   if (IsValid()) {
     SymbolFileDWARF *dwarf = GetDWARF();
     DWARFUnit *cu = GetCU();
     DWARFDebugInfoEntry *function_die = nullptr;
     DWARFDebugInfoEntry *block_die = nullptr;
-    if (m_die->LookupAddress(file_addr, dwarf, cu, &function_die, &block_die)) {
+    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())),
                           block_die);
       }
     }
   }
   return DWARFDIE();
 }
 
 const char *DWARFDIE::GetMangledName() const {
   if (IsValid())
-    return m_die->GetMangledName(GetDWARF(), m_cu);
+    return m_die->GetMangledName(m_cu);
   else
     return nullptr;
 }
 
 const char *DWARFDIE::GetPubname() const {
   if (IsValid())
-    return m_die->GetPubname(GetDWARF(), m_cu);
+    return m_die->GetPubname(m_cu);
   else
     return nullptr;
 }
 
 const char *DWARFDIE::GetQualifiedName(std::string &storage) const {
   if (IsValid())
-    return m_die->GetQualifiedName(GetDWARF(), m_cu, storage);
+    return m_die->GetQualifiedName(m_cu, storage);
   else
     return nullptr;
 }
 
 lldb_private::Type *DWARFDIE::ResolveType() const {
   if (IsValid())
     return GetDWARF()->ResolveType(*this, true);
   else
std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
   }
 
   return result;
 }
 
 void DWARFDIE::GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const {
   if (IsValid()) {
     dwarf_decl_ctx.SetLanguage(GetLanguage());
-    m_die->GetDWARFDeclContext(GetDWARF(), GetCU(), dwarf_decl_ctx);
+    m_die->GetDWARFDeclContext(GetCU(), dwarf_decl_ctx);
   } else {
     dwarf_decl_ctx.Clear();
   }
 }
 
 void DWARFDIE::GetDeclContext(std::vector<CompilerContext> &context) const {
   const dw_tag_t tag = Tag();
   if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
void DWARFDIE::GetDeclContext(std::vector<CompilerContext> &context) const {
   default:
     break;
   }
 }
 
 DWARFDIE
 DWARFDIE::GetParentDeclContextDIE() const {
   if (IsValid())
-    return m_die->GetParentDeclContextDIE(GetDWARF(), m_cu);
+    return m_die->GetParentDeclContextDIE(m_cu);
   else
     return DWARFDIE();
 }
 
 bool DWARFDIE::IsStructUnionOrClass() const {
   const dw_tag_t tag = Tag();
   return tag == DW_TAG_class_type || tag == DW_TAG_structure_type ||
          tag == DW_TAG_union_type;

 
 bool DWARFDIE::GetDIENamesAndRanges(
     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,
     lldb_private::DWARFExpression *frame_base) const {
   if (IsValid()) {
     return m_die->GetDIENamesAndRanges(
-        GetDWARF(), GetCU(), name, mangled, ranges, decl_file, decl_line,
-        decl_column, call_file, call_line, call_column, frame_base);
+        GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
+        call_file, call_line, call_column, frame_base);
   } else
     return false;
 }
 
 CompilerDecl DWARFDIE::GetDecl() const {
   DWARFASTParser *dwarf_ast = GetDWARFParser();
   if (dwarf_ast)
     return dwarf_ast->GetDeclForUIDFromDWARF(*this);

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
   // Manually build arange data for everything that wasn't in the
   // .debug_aranges table.
   const size_t num_units = GetNumUnits();
   for (size_t idx = 0; idx < num_units; ++idx) {
     DWARFUnit *cu = GetUnitAtIndex(idx);
 
     dw_offset_t offset = cu->GetOffset();
     if (cus_with_data.find(offset) == cus_with_data.end())
-      cu->BuildAddressRangeTable(m_dwarf2Data, m_cu_aranges_up.get());
+      cu->BuildAddressRangeTable(m_cu_aranges_up.get());
   }
 
   const bool minimize = true;
   m_cu_aranges_up->Sort(minimize);
   return *m_cu_aranges_up;
 }
 
 void DWARFDebugInfo::ParseUnitHeadersIfNeeded() {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

public:
   DWARFDebugInfoEntry()
       : m_offset(DW_INVALID_OFFSET), m_parent_idx(0), m_sibling_idx(0),
         m_has_children(false), m_abbr_idx(0), m_tag(0) {}
 
   explicit operator bool() const { return m_offset != DW_INVALID_OFFSET; }
   bool operator==(const DWARFDebugInfoEntry &rhs) const;
   bool operator!=(const DWARFDebugInfoEntry &rhs) const;
 
-  void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
-                              const DWARFUnit *cu,
+  void BuildAddressRangeTable(const DWARFUnit *cu,
                               DWARFDebugAranges *debug_aranges) const;
 
-  void BuildFunctionAddressRangeTable(SymbolFileDWARF *dwarf2Data,
-                                      const DWARFUnit *cu,
+  void BuildFunctionAddressRangeTable(const DWARFUnit *cu,
                                       DWARFDebugAranges *debug_aranges) const;
 
   bool FastExtract(const lldb_private::DWARFDataExtractor &debug_info_data,
                    const DWARFUnit *cu,
                    const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
                    lldb::offset_t *offset_ptr);
 
   bool Extract(const DWARFUnit *cu, lldb::offset_t *offset_ptr);
 
-  bool LookupAddress(const dw_addr_t address, SymbolFileDWARF *dwarf2Data,
-                     const DWARFUnit *cu,
+  bool LookupAddress(const dw_addr_t address, const DWARFUnit *cu,
                      DWARFDebugInfoEntry **function_die,
                      DWARFDebugInfoEntry **block_die);
 
   size_t GetAttributes(const DWARFUnit *cu,
                        DWARFFormValue::FixedFormSizes fixed_form_sizes,
                        DWARFAttributes &attrs,
                        uint32_t curr_depth = 0)
       const; // "curr_depth" for internal use only, don't set this yourself!!!
 
   dw_offset_t
-  GetAttributeValue(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-                    const dw_attr_t attr, DWARFFormValue &formValue,
+  GetAttributeValue(const DWARFUnit *cu, const dw_attr_t attr,
+                    DWARFFormValue &formValue,
                     dw_offset_t *end_attr_offset_ptr = nullptr,
                     bool check_specification_or_abstract_origin = false) const;
 
   const char *GetAttributeValueAsString(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-      const dw_attr_t attr, const char *fail_value,
+      const DWARFUnit *cu, const dw_attr_t attr, const char *fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsUnsigned(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-      const dw_attr_t attr, uint64_t fail_value,
+      const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   DWARFDIE GetAttributeValueAsReference(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const dw_attr_t attr,
+      const DWARFUnit *cu, const dw_attr_t attr,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsAddress(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-      const dw_attr_t attr, uint64_t fail_value,
+      const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   dw_addr_t
-  GetAttributeHighPC(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-                     dw_addr_t lo_pc, uint64_t fail_value,
+  GetAttributeHighPC(const DWARFUnit *cu, dw_addr_t lo_pc, uint64_t fail_value,
                      bool check_specification_or_abstract_origin = false) const;
 
   bool GetAttributeAddressRange(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t &lo_pc,
-      dw_addr_t &hi_pc, uint64_t fail_value,
+      const DWARFUnit *cu, dw_addr_t &lo_pc, dw_addr_t &hi_pc,
+      uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   size_t GetAttributeAddressRanges(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-      DWARFRangeList &ranges, bool check_hi_lo_pc,
+      const DWARFUnit *cu, DWARFRangeList &ranges, bool check_hi_lo_pc,
       bool check_specification_or_abstract_origin = false) const;
 
-  const char *GetName(SymbolFileDWARF *dwarf2Data,
-                      const DWARFUnit *cu) const;
+  const char *GetName(const DWARFUnit *cu) const;
 
-  const char *GetMangledName(SymbolFileDWARF *dwarf2Data,
-                             const DWARFUnit *cu,
+  const char *GetMangledName(const DWARFUnit *cu,
                              bool substitute_name_allowed = true) const;
 
-  const char *GetPubname(SymbolFileDWARF *dwarf2Data,
-                         const DWARFUnit *cu) const;
+  const char *GetPubname(const DWARFUnit *cu) const;
 
-  static bool GetName(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-                      const dw_offset_t die_offset, lldb_private::Stream &s);
+  static bool GetName(const DWARFUnit *cu, const dw_offset_t die_offset,
+                      lldb_private::Stream &s);
 
-  static bool AppendTypeName(SymbolFileDWARF *dwarf2Data,
-                             const DWARFUnit *cu,
-                             const dw_offset_t die_offset,
+  static bool AppendTypeName(const DWARFUnit *cu, const dw_offset_t die_offset,
                              lldb_private::Stream &s);
 
-  const char *GetQualifiedName(SymbolFileDWARF *dwarf2Data,
-                               DWARFUnit *cu,
-                               std::string &storage) const;
+  const char *GetQualifiedName(DWARFUnit *cu, std::string &storage) const;
 
-  const char *GetQualifiedName(SymbolFileDWARF *dwarf2Data,
-                               DWARFUnit *cu,
-                               const DWARFAttributes &attributes,
+  const char *GetQualifiedName(DWARFUnit *cu, const DWARFAttributes &attributes,
                                std::string &storage) const;
 
   static bool OffsetLessThan(const DWARFDebugInfoEntry &a,
                              const DWARFDebugInfoEntry &b);
 
-  void Dump(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-            lldb_private::Stream &s, uint32_t recurse_depth) const;
+  void Dump(const DWARFUnit *cu, lldb_private::Stream &s,
+            uint32_t recurse_depth) const;
 
   static void
-  DumpAttribute(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
+  DumpAttribute(const DWARFUnit *cu,
                 const lldb_private::DWARFDataExtractor &debug_info_data,
                 lldb::offset_t *offset_ptr, lldb_private::Stream &s,
                 dw_attr_t attr, DWARFFormValue &form_value);
 
   bool
-  GetDIENamesAndRanges(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-                       const char *&name, const char *&mangled,
-                       DWARFRangeList &rangeList, int &decl_file,
-                       int &decl_line, int &decl_column, int &call_file,
-                       int &call_line, int &call_column,
+  GetDIENamesAndRanges(const DWARFUnit *cu, const char *&name,
+                       const char *&mangled, DWARFRangeList &rangeList,
+                       int &decl_file, int &decl_line, int &decl_column,
+                       int &call_file, int &call_line, int &call_column,
                        lldb_private::DWARFExpression *frame_base = NULL) const;
 
   const DWARFAbbreviationDeclaration *
-  GetAbbreviationDeclarationPtr(SymbolFileDWARF *dwarf2Data,
-                                const DWARFUnit *cu,
+  GetAbbreviationDeclarationPtr(const DWARFUnit *cu,
                                 lldb::offset_t &offset) const;
 
   dw_tag_t Tag() const { return m_tag; }
 
   bool IsNULL() const { return m_abbr_idx == 0; }
 
   dw_offset_t GetOffset() const { return m_offset; }
 
DWARFDebugInfoEntry *GetFirstChild() {
     return HasChildren() ? this + 1 : NULL;
   }
   const DWARFDebugInfoEntry *GetFirstChild() const {
     return HasChildren() ? this + 1 : NULL;
   }
 
   std::vector<DWARFDIE> GetDeclContextDIEs(DWARFUnit *cu) const;
 
-  void GetDWARFDeclContext(SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
+  void GetDWARFDeclContext(DWARFUnit *cu,
                            DWARFDeclContext &dwarf_decl_ctx) const;
 
-  bool MatchesDWARFDeclContext(SymbolFileDWARF *dwarf2Data,
-                               DWARFUnit *cu,
+  bool MatchesDWARFDeclContext(DWARFUnit *cu,
                                const DWARFDeclContext &dwarf_decl_ctx) const;
 
-  DWARFDIE GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
-                                   DWARFUnit *cu) const;
-  DWARFDIE GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
-                                   DWARFUnit *cu,
+  DWARFDIE GetParentDeclContextDIE(DWARFUnit *cu) const;
+  DWARFDIE GetParentDeclContextDIE(DWARFUnit *cu,
                                    const DWARFAttributes &attributes) const;
 
   void SetParent(DWARFDebugInfoEntry *parent) {
     if (parent) {
       // We know we are kept in a vector of contiguous entries, so we know
       // our parent will be some index behind "this".
       m_parent_idx = this - parent;
     } else

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

static dw_offset_t GetRangesOffset(const DWARFDebugRangesBase *debug_ranges,
   return form_value.Unsigned();
 }
 
 // GetDIENamesAndRanges
 //
 // 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(
-    SymbolFileDWARF *dwarf2Data, 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 {
-  if (dwarf2Data == nullptr)
-    return false;
-
+    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, dwo_symbol_file->GetCompileUnit(), name, mangled,
-        ranges, decl_file, decl_line, decl_column, call_file, call_line,
-        call_column, frame_base);
+        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<DIERef> die_refs;
   bool set_frame_base_loclist_addr = false;
 
   lldb::offset_t offset;
   const DWARFAbbreviationDeclaration *abbrevDecl =
-      GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+      GetAbbreviationDeclarationPtr(cu, offset);
 
+  SymbolFileDWARF *dwarf2Data = cu->GetSymbolFileDWARF();
   lldb::ModuleSP module = dwarf2Data->GetObjectFile()->GetModule();
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data = cu->GetData();
 
     if (!debug_info_data.ValidOffset(offset))
       return false;
 
if (set_frame_base_loclist_addr) {
     frame_base->SetLocationListSlide(lowest_range_pc - cu->GetBaseAddress());
   }
 
   if (ranges.IsEmpty() || name == NULL || mangled == NULL) {
     for (const DIERef &die_ref : die_refs) {
       if (die_ref.die_offset != DW_INVALID_OFFSET) {
         DWARFDIE die = dwarf2Data->GetDIE(die_ref);
         if (die)
-          die.GetDIE()->GetDIENamesAndRanges(
-              die.GetDWARF(), die.GetCU(), name, mangled, ranges, decl_file,
-              decl_line, decl_column, call_file, call_line, call_column);
+          die.GetDIE()->GetDIENamesAndRanges(die.GetCU(), name, mangled, ranges,
+                                             decl_file, decl_line, decl_column,
+                                             call_file, call_line, call_column);
       }
     }
   }
   return !ranges.IsEmpty();
 }
 
 // Dump
 //
 // Dumps a debug information entry and all of it's attributes to the specified
 // stream.
-void DWARFDebugInfoEntry::Dump(SymbolFileDWARF *dwarf2Data,
-                               const DWARFUnit *cu, Stream &s,
+void DWARFDebugInfoEntry::Dump(const DWARFUnit *cu, Stream &s,
                                uint32_t recurse_depth) const {
   const DWARFDataExtractor &debug_info_data = cu->GetData();
   lldb::offset_t offset = m_offset;
 
   if (debug_info_data.ValidOffset(offset)) {
     dw_uleb128_t abbrCode = debug_info_data.GetULEB128(&offset);
 
     s.Printf("\n0x%8.8x: ", m_offset);
if (abbrCode != m_abbr_idx) {
 
         // Dump all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
         for (uint32_t i = 0; i < numAttributes; ++i) {
           DWARFFormValue form_value(cu);
           dw_attr_t attr;
           abbrevDecl->GetAttrAndFormValueByIndex(i, attr, form_value);
 
-          DumpAttribute(dwarf2Data, cu, debug_info_data, &offset, s, attr,
-                        form_value);
+          DumpAttribute(cu, debug_info_data, &offset, s, attr, form_value);
         }
 
         const DWARFDebugInfoEntry *child = GetFirstChild();
         if (recurse_depth > 0 && child) {
           s.IndentMore();
 
           while (child) {
-            child->Dump(dwarf2Data, cu, s, recurse_depth - 1);
+            child->Dump(cu, s, recurse_depth - 1);
             child = child->GetSibling();
           }
           s.IndentLess();
         }
       } else
         s.Printf("Abbreviation code note found in 'debug_abbrev' class for "
                  "code: %u\n",
                  abbrCode);
     } else {
       s.Printf("NULL\n");
     }
   }
 }
 
 // DumpAttribute
 //
 // Dumps a debug information entry attribute along with it's form. Any special
 // display of attributes is done (disassemble location lists, show enumeration
 // values for attributes, etc).
 void DWARFDebugInfoEntry::DumpAttribute(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const DWARFDataExtractor &debug_info_data, lldb::offset_t *offset_ptr,
-    Stream &s, dw_attr_t attr, DWARFFormValue &form_value) {
+    const DWARFUnit *cu, const DWARFDataExtractor &debug_info_data,
+    lldb::offset_t *offset_ptr, Stream &s, dw_attr_t attr,
+    DWARFFormValue &form_value) {
   bool show_form = s.GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowForm);
 
   s.Printf("            ");
   s.Indent(DW_AT_value_to_name(attr));
 
   if (show_form) {
     s.Printf("[%s", DW_FORM_value_to_name(form_value.Form()));
   }
 
   if (!form_value.ExtractValue(debug_info_data, offset_ptr))
     return;
 
   if (show_form) {
     if (form_value.Form() == DW_FORM_indirect) {
       s.Printf(" [%s]", DW_FORM_value_to_name(form_value.Form()));
     }
 
     s.PutCString("] ");
   }
 
   s.PutCString("( ");
 
+  SymbolFileDWARF *dwarf2Data = cu->GetSymbolFileDWARF();
+
   // Check to see if we have any special attribute formatters
   switch (attr) {
   case DW_AT_stmt_list:
     s.Printf("0x%8.8" PRIx64, form_value.Unsigned());
     break;
 
   case DW_AT_language:
     s.PutCString(DW_LANG_value_to_name(form_value.Unsigned()));
case DW_AT_data_member_location: {
     }
   } break;
 
   case DW_AT_abstract_origin:
   case DW_AT_specification: {
     DWARFDIE abstract_die = form_value.Reference();
     form_value.Dump(s);
     //  *ostrm_ptr << HEX32 << abstract_die.GetOffset() << " ( ";
-    GetName(dwarf2Data, abstract_die.GetCU(), abstract_die.GetOffset(), s);
+    GetName(abstract_die.GetCU(), abstract_die.GetOffset(), s);
   } break;
 
   case DW_AT_type: {
     DWARFDIE type_die = form_value.Reference();
     s.PutCString(" ( ");
-    AppendTypeName(dwarf2Data, type_die.GetCU(), type_die.GetOffset(), s);
+    AppendTypeName(type_die.GetCU(), type_die.GetOffset(), s);
     s.PutCString(" )");
   } break;
 
   case DW_AT_ranges: {
-    if (!dwarf2Data)
-      break;
     lldb::offset_t ranges_offset =
         GetRangesOffset(dwarf2Data->DebugRanges(), form_value);
     dw_addr_t base_addr = cu ? cu->GetBaseAddress() : 0;
     DWARFDebugRanges::Dump(s, dwarf2Data->get_debug_ranges_data(),
                            &ranges_offset, base_addr);
   } break;
 
   default:

 size_t DWARFDebugInfoEntry::GetAttributes(
     const DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFAttributes &attributes, uint32_t curr_depth) const {
   SymbolFileDWARF *dwarf2Data = nullptr;
   const DWARFAbbreviationDeclaration *abbrevDecl = nullptr;
   lldb::offset_t offset = 0;
   if (cu) {
     dwarf2Data = cu->GetSymbolFileDWARF();
-    abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+    abbrevDecl = GetAbbreviationDeclarationPtr(cu, offset);
   }
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data = cu->GetData();
 
     if (fixed_form_sizes.Empty())
       fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(
           cu->GetAddressByteSize());

 
 // GetAttributeValue
 //
 // Get the value of an attribute and return the .debug_info 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(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const dw_attr_t attr, DWARFFormValue &form_value,
+    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, dwo_symbol_file->GetCompileUnit(),
-                             attr, form_value, end_attr_offset_ptr,
+    return GetAttributeValue(dwo_symbol_file->GetCompileUnit(), attr,
+                             form_value, end_attr_offset_ptr,
                              check_specification_or_abstract_origin);
 
   lldb::offset_t offset;
   const DWARFAbbreviationDeclaration *abbrevDecl =
-      GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+      GetAbbreviationDeclarationPtr(cu, offset);
 
   if (abbrevDecl) {
     uint32_t attr_idx = abbrevDecl->FindAttributeIndex(attr);
 
     if (attr_idx != DW_INVALID_INDEX) {
       const DWARFDataExtractor &debug_info_data = cu->GetData();
 
       uint32_t idx = 0;
       while (idx < attr_idx)
         DWARFFormValue::SkipValue(abbrevDecl->GetFormByIndex(idx++),
                                   debug_info_data, &offset, cu);
 
       const dw_offset_t attr_offset = offset;
       form_value.SetUnit(cu);
       form_value.SetForm(abbrevDecl->GetFormByIndex(idx));
       if (form_value.ExtractValue(debug_info_data, &offset)) {
         if (end_attr_offset_ptr)
           *end_attr_offset_ptr = offset;
         return attr_offset;
       }
     }
   }
 
   if (check_specification_or_abstract_origin) {
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value)) {
+    if (GetAttributeValue(cu, DW_AT_specification, form_value)) {
       DWARFDIE die = form_value.Reference();
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
-            die.GetDWARF(), die.GetCU(), attr, form_value, end_attr_offset_ptr,
-            false);
+            die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
         if (die_offset)
           return die_offset;
       }
     }
 
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_abstract_origin, form_value)) {
+    if (GetAttributeValue(cu, DW_AT_abstract_origin, form_value)) {
       DWARFDIE die = form_value.Reference();
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
-            die.GetDWARF(), die.GetCU(), attr, form_value, end_attr_offset_ptr,
-            false);
+            die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
         if (die_offset)
           return die_offset;
       }
     }
   }
 
   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();
   if (!dwo_cu_die.IsValid())
     return 0;
 
   return dwo_cu_die.GetDIE()->GetAttributeValue(
-      dwo_symbol_file, dwo_cu, attr, form_value, end_attr_offset_ptr,
+      dwo_cu, attr, form_value, end_attr_offset_ptr,
       check_specification_or_abstract_origin);
 }
 
 // GetAttributeValueAsString
 //
 // Get the value of an attribute as a string return it. The resulting pointer
 // to the string data exists within the supplied SymbolFileDWARF and will only
 // be available as long as the SymbolFileDWARF is still around and it's content
 // doesn't change.
 const char *DWARFDebugInfoEntry::GetAttributeValueAsString(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const dw_attr_t attr, const char *fail_value,
+    const DWARFUnit *cu, const dw_attr_t attr, const char *fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
-  if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
+  if (GetAttributeValue(cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.AsCString();
   return fail_value;
 }
 
 // GetAttributeValueAsUnsigned
 //
 // Get the value of an attribute as unsigned and return it.
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsUnsigned(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const dw_attr_t attr, uint64_t fail_value,
+    const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
-  if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
+  if (GetAttributeValue(cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Unsigned();
   return fail_value;
 }
 
 // GetAttributeValueAsReference
 //
 // Get the value of an attribute as reference and fix up and compile unit
 // relative offsets as needed.
 DWARFDIE DWARFDebugInfoEntry::GetAttributeValueAsReference(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const dw_attr_t attr,
+    const DWARFUnit *cu, const dw_attr_t attr,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
-  if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
+  if (GetAttributeValue(cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Reference();
   return {};
 }
 
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsAddress(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const dw_attr_t attr, uint64_t fail_value,
+    const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
-  if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
+  if (GetAttributeValue(cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Address();
   return fail_value;
 }
 
 // GetAttributeHighPC
 //
 // Get the hi_pc, adding hi_pc to lo_pc when specified as an <offset-from-low-
 // pc>.
 //
 // Returns the hi_pc or fail_value.
 dw_addr_t DWARFDebugInfoEntry::GetAttributeHighPC(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t lo_pc,
-    uint64_t fail_value, bool check_specification_or_abstract_origin) const {
+    const DWARFUnit *cu, dw_addr_t lo_pc, uint64_t fail_value,
+    bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
-  if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value, nullptr,
+  if (GetAttributeValue(cu, DW_AT_high_pc, form_value, nullptr,
                         check_specification_or_abstract_origin)) {
     dw_form_t form = form_value.Form();
     if (form == DW_FORM_addr || form == DW_FORM_addrx ||
         form == DW_FORM_GNU_addr_index)
       return form_value.Address();
 
     // DWARF4 can specify the hi_pc as an <offset-from-lowpc>
     return lo_pc + form_value.Unsigned();
   }
   return fail_value;
 }
 
 // GetAttributeAddressRange
 //
 // Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified as an <offset-
 // from-low-pc>.
 //
 // Returns true or sets lo_pc and hi_pc to fail_value.
 bool DWARFDebugInfoEntry::GetAttributeAddressRange(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, dw_addr_t &lo_pc,
-    dw_addr_t &hi_pc, uint64_t fail_value,
-    bool check_specification_or_abstract_origin) const {
-  lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc, fail_value,
+    const DWARFUnit *cu, dw_addr_t &lo_pc, dw_addr_t &hi_pc,
+    uint64_t fail_value, bool check_specification_or_abstract_origin) const {
+  lo_pc = GetAttributeValueAsAddress(cu, DW_AT_low_pc, fail_value,
                                      check_specification_or_abstract_origin);
   if (lo_pc != fail_value) {
-    hi_pc = GetAttributeHighPC(dwarf2Data, cu, lo_pc, fail_value,
+    hi_pc = GetAttributeHighPC(cu, lo_pc, fail_value,
                                check_specification_or_abstract_origin);
     if (hi_pc != fail_value)
       return true;
   }
   lo_pc = fail_value;
   hi_pc = fail_value;
   return false;
 }
 
 size_t DWARFDebugInfoEntry::GetAttributeAddressRanges(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    DWARFRangeList &ranges, bool check_hi_lo_pc,
+    const DWARFUnit *cu, DWARFRangeList &ranges, bool check_hi_lo_pc,
     bool check_specification_or_abstract_origin) const {
   ranges.Clear();
 
+  SymbolFileDWARF *dwarf2Data = cu->GetSymbolFileDWARF();
+
   DWARFFormValue form_value;
-  if (GetAttributeValue(dwarf2Data, cu, DW_AT_ranges, form_value)) {
+  if (GetAttributeValue(cu, DW_AT_ranges, form_value)) {
     if (DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges())
       debug_ranges->FindRanges(cu, GetRangesOffset(debug_ranges, form_value),
                                ranges);
   } else if (check_hi_lo_pc) {
     dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
     dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
-    if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
-                                 LLDB_INVALID_ADDRESS,
+    if (GetAttributeAddressRange(cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS,
                                  check_specification_or_abstract_origin)) {
       if (lo_pc < hi_pc)
         ranges.Append(DWARFRangeList::Entry(lo_pc, hi_pc - lo_pc));
     }
   }
   return ranges.GetSize();
 }
 
 // GetName
 //
 // Get value of the DW_AT_name attribute and return it if one exists, else
 // return NULL.
-const char *DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
-                                         const DWARFUnit *cu) const {
-  return GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
+const char *DWARFDebugInfoEntry::GetName(const DWARFUnit *cu) const {
+  return GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
 }
 
 // GetMangledName
 //
 // Get value of the DW_AT_MIPS_linkage_name attribute and return it if one
 // exists, else return the value of the DW_AT_name attribute
 const char *
-DWARFDebugInfoEntry::GetMangledName(SymbolFileDWARF *dwarf2Data,
-                                    const DWARFUnit *cu,
+DWARFDebugInfoEntry::GetMangledName(const DWARFUnit *cu,
                                     bool substitute_name_allowed) const {
   const char *name = nullptr;
 
-  name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name,
-                                   nullptr, true);
+  name = GetAttributeValueAsString(cu, DW_AT_MIPS_linkage_name, nullptr, true);
   if (name)
     return name;
 
-  name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_linkage_name, nullptr,
-                                   true);
+  name = GetAttributeValueAsString(cu, DW_AT_linkage_name, nullptr, true);
   if (name)
     return name;
 
   if (!substitute_name_allowed)
     return nullptr;
 
-  name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
+  name = GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
   return name;
 }
 
 // GetPubname
 //
 // Get value the name for a DIE as it should appear for a .debug_pubnames or
 // .debug_pubtypes section.
-const char *DWARFDebugInfoEntry::GetPubname(SymbolFileDWARF *dwarf2Data,
-                                            const DWARFUnit *cu) const {
+const char *DWARFDebugInfoEntry::GetPubname(const DWARFUnit *cu) const {
   const char *name = nullptr;
-  if (!dwarf2Data)
+  if (!cu)
     return name;
 
-  name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name,
-                                   nullptr, true);
+  name = GetAttributeValueAsString(cu, DW_AT_MIPS_linkage_name, nullptr, true);
   if (name)
     return name;
 
-  name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_linkage_name, nullptr,
-                                   true);
+  name = GetAttributeValueAsString(cu, DW_AT_linkage_name, nullptr, true);
   if (name)
     return name;
 
-  name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
+  name = GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
   return name;
 }
 
 // GetName
 //
 // Get value of the DW_AT_name attribute for a debug information entry that
 // exists at offset "die_offset" and place that value into the supplied stream
 // object. If the DIE is a NULL object "NULL" is placed into the stream, and if
 // no DW_AT_name attribute exists for the DIE then nothing is printed.
-bool DWARFDebugInfoEntry::GetName(SymbolFileDWARF *dwarf2Data,
-                                  const DWARFUnit *cu,
+bool DWARFDebugInfoEntry::GetName(const DWARFUnit *cu,
                                   const dw_offset_t die_offset, Stream &s) {
-  if (dwarf2Data == NULL) {
+  if (cu == NULL) {
     s.PutCString("NULL");
     return false;
   }
 
   DWARFDebugInfoEntry die;
   lldb::offset_t offset = die_offset;
   if (die.Extract(cu, &offset)) {
     if (die.IsNULL()) {
       s.PutCString("NULL");
       return true;
     } else {
-      const char *name = die.GetAttributeValueAsString(
-          dwarf2Data, cu, DW_AT_name, nullptr, true);
+      const char *name =
+          die.GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
       if (name) {
         s.PutCString(name);
         return true;
       }
     }
   }
   return false;
 }
 
 // AppendTypeName
 //
 // Follows the type name definition down through all needed tags to end up with
 // a fully qualified type name and dump the results to the supplied stream.
 // This is used to show the name of types given a type identifier.
-bool DWARFDebugInfoEntry::AppendTypeName(SymbolFileDWARF *dwarf2Data,
-                                         const DWARFUnit *cu,
+bool DWARFDebugInfoEntry::AppendTypeName(const DWARFUnit *cu,
                                          const dw_offset_t die_offset,
                                          Stream &s) {
-  if (dwarf2Data == NULL) {
+  if (cu == NULL) {
     s.PutCString("NULL");
     return false;
   }
 
   DWARFDebugInfoEntry die;
   lldb::offset_t offset = die_offset;
   if (die.Extract(cu, &offset)) {
     if (die.IsNULL()) {
       s.PutCString("NULL");
       return true;
     } else {
-      const char *name = die.GetPubname(dwarf2Data, cu);
+      const char *name = die.GetPubname(cu);
       if (name)
         s.PutCString(name);
       else {
         bool result = true;
         const DWARFAbbreviationDeclaration *abbrevDecl =
-            die.GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+            die.GetAbbreviationDeclarationPtr(cu, offset);
 
         if (abbrevDecl == NULL)
           return false;
 
         switch (abbrevDecl->Tag()) {
         case DW_TAG_array_type:
           break; // print out a "[]" after printing the full type of the element
                  // below
if (die.IsNULL()) {
           s.PutCString("volatile ");
           break;
         default:
           return false;
         }
 
         // Follow the DW_AT_type if possible
         DWARFFormValue form_value;
-        if (die.GetAttributeValue(dwarf2Data, cu, DW_AT_type, form_value)) {
+        if (die.GetAttributeValue(cu, DW_AT_type, form_value)) {
           DWARFDIE next_die = form_value.Reference();
-          result = AppendTypeName(dwarf2Data, next_die.GetCU(),
-                                  next_die.GetOffset(), s);
+          result = AppendTypeName(next_die.GetCU(), next_die.GetOffset(), s);
         }
 
         switch (abbrevDecl->Tag()) {
         case DW_TAG_array_type:
           s.PutCString("[]");
           break;
         case DW_TAG_pointer_type:
           s.PutChar('*');
if (die.IsNULL()) {
       }
     }
   }
   return false;
 }
 
 // BuildAddressRangeTable
 void DWARFDebugInfoEntry::BuildAddressRangeTable(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    DWARFDebugAranges *debug_aranges) const {
+    const DWARFUnit *cu, DWARFDebugAranges *debug_aranges) const {
   if (m_tag) {
     if (m_tag == DW_TAG_subprogram) {
       dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
       dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
-      if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
-                                   LLDB_INVALID_ADDRESS)) {
+      if (GetAttributeAddressRange(cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS)) {
         /// printf("BuildAddressRangeTable() 0x%8.8x: %30s: [0x%8.8x -
         /// 0x%8.8x)\n", m_offset, DW_TAG_value_to_name(tag), lo_pc, hi_pc);
         debug_aranges->AppendRange(cu->GetOffset(), lo_pc, hi_pc);
       }
     }
 
     const DWARFDebugInfoEntry *child = GetFirstChild();
     while (child) {
-      child->BuildAddressRangeTable(dwarf2Data, cu, debug_aranges);
+      child->BuildAddressRangeTable(cu, debug_aranges);
       child = child->GetSibling();
     }
   }
 }
 
 // BuildFunctionAddressRangeTable
 //
 // This function is very similar to the BuildAddressRangeTable function except
 // that the actual DIE offset for the function is placed in the table instead
 // of the compile unit offset (which is the way the standard .debug_aranges
 // section does it).
 void DWARFDebugInfoEntry::BuildFunctionAddressRangeTable(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    DWARFDebugAranges *debug_aranges) const {
+    const DWARFUnit *cu, DWARFDebugAranges *debug_aranges) const {
   if (m_tag) {
     if (m_tag == DW_TAG_subprogram) {
       dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
       dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
-      if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
-                                   LLDB_INVALID_ADDRESS)) {
+      if (GetAttributeAddressRange(cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS)) {
         //  printf("BuildAddressRangeTable() 0x%8.8x: [0x%16.16" PRIx64 " -
         //  0x%16.16" PRIx64 ")\n", m_offset, lo_pc, hi_pc); // DEBUG ONLY
         debug_aranges->AppendRange(GetOffset(), lo_pc, hi_pc);
       }
     }
 
     const DWARFDebugInfoEntry *child = GetFirstChild();
     while (child) {
-      child->BuildFunctionAddressRangeTable(dwarf2Data, cu, debug_aranges);
+      child->BuildFunctionAddressRangeTable(cu, debug_aranges);
       child = child->GetSibling();
     }
   }
 }
 
 std::vector<DWARFDIE>
 DWARFDebugInfoEntry::GetDeclContextDIEs(DWARFUnit *cu) const {
 
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
   return die.GetDeclContextDIEs();
 }
 
 void DWARFDebugInfoEntry::GetDWARFDeclContext(
-    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
-    DWARFDeclContext &dwarf_decl_ctx) const {
+    DWARFUnit *cu, DWARFDeclContext &dwarf_decl_ctx) const {
   const dw_tag_t tag = Tag();
   if (tag != DW_TAG_compile_unit && tag != DW_TAG_partial_unit) {
-    dwarf_decl_ctx.AppendDeclContext(tag, GetName(dwarf2Data, cu));
-    DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(dwarf2Data, cu);
+    dwarf_decl_ctx.AppendDeclContext(tag, GetName(cu));
+    DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(cu);
     if (parent_decl_ctx_die && parent_decl_ctx_die.GetDIE() != this) {
       if (parent_decl_ctx_die.Tag() != DW_TAG_compile_unit &&
           parent_decl_ctx_die.Tag() != DW_TAG_partial_unit)
         parent_decl_ctx_die.GetDIE()->GetDWARFDeclContext(
-            parent_decl_ctx_die.GetDWARF(), parent_decl_ctx_die.GetCU(),
-            dwarf_decl_ctx);
+            parent_decl_ctx_die.GetCU(), dwarf_decl_ctx);
     }
   }
 }
 
 bool DWARFDebugInfoEntry::MatchesDWARFDeclContext(
-    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
-    const DWARFDeclContext &dwarf_decl_ctx) const {
+    DWARFUnit *cu, const DWARFDeclContext &dwarf_decl_ctx) const {
 
   DWARFDeclContext this_dwarf_decl_ctx;
-  GetDWARFDeclContext(dwarf2Data, cu, this_dwarf_decl_ctx);
+  GetDWARFDeclContext(cu, this_dwarf_decl_ctx);
   return this_dwarf_decl_ctx == dwarf_decl_ctx;
 }
 
 DWARFDIE
-DWARFDebugInfoEntry::GetParentDeclContextDIE(SymbolFileDWARF *dwarf2Data,
-                                             DWARFUnit *cu) const {
+DWARFDebugInfoEntry::GetParentDeclContextDIE(DWARFUnit *cu) const {
   DWARFAttributes attributes;
   GetAttributes(cu, DWARFFormValue::FixedFormSizes(), attributes);
-  return GetParentDeclContextDIE(dwarf2Data, cu, attributes);
+  return GetParentDeclContextDIE(cu, attributes);
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(
-    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
-    const DWARFAttributes &attributes) const {
+    DWARFUnit *cu, const DWARFAttributes &attributes) const {
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
 
   while (die) {
     // If this is the original DIE that we are searching for a declaration for,
     // then don't look in the cache as we don't want our own decl context to be
     // our decl context...
     if (die.GetDIE() != this) {
       switch (die.Tag()) {
if (abs_die) {
         return decl_ctx_die;
     }
 
     die = die.GetParent();
   }
   return DWARFDIE();
 }
 
-const char *DWARFDebugInfoEntry::GetQualifiedName(SymbolFileDWARF *dwarf2Data,
-                                                  DWARFUnit *cu,
+const char *DWARFDebugInfoEntry::GetQualifiedName(DWARFUnit *cu,
                                                   std::string &storage) const {
   DWARFAttributes attributes;
   GetAttributes(cu, DWARFFormValue::FixedFormSizes(), attributes);
-  return GetQualifiedName(dwarf2Data, cu, attributes, storage);
+  return GetQualifiedName(cu, attributes, storage);
 }
 
-const char *DWARFDebugInfoEntry::GetQualifiedName(
-    SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
-    const DWARFAttributes &attributes, std::string &storage) const {
+const char *
+DWARFDebugInfoEntry::GetQualifiedName(DWARFUnit *cu,
+                                      const DWARFAttributes &attributes,
+                                      std::string &storage) const {
 
-  const char *name = GetName(dwarf2Data, cu);
+  const char *name = GetName(cu);
 
   if (name) {
-    DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(dwarf2Data, cu);
+    DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(cu);
     storage.clear();
     // TODO: change this to get the correct decl context parent....
     while (parent_decl_ctx_die) {
       const dw_tag_t parent_tag = parent_decl_ctx_die.Tag();
       switch (parent_tag) {
       case DW_TAG_namespace: {
         const char *namespace_name = parent_decl_ctx_die.GetName();
         if (namespace_name) {
DWARFDebugInfoEntry::GetQualifiedName(DWARFUnit *cu,
   }
   if (storage.empty())
     return NULL;
   return storage.c_str();
 }
 
 // LookupAddress
 bool DWARFDebugInfoEntry::LookupAddress(const dw_addr_t address,
-                                        SymbolFileDWARF *dwarf2Data,
                                         const DWARFUnit *cu,
                                         DWARFDebugInfoEntry **function_die,
                                         DWARFDebugInfoEntry **block_die) {
   bool found_address = false;
   if (m_tag) {
     bool check_children = false;
     bool match_addr_range = false;
     //  printf("0x%8.8x: %30s: address = 0x%8.8x - ", m_offset,
case DW_TAG_imported_unit:
       break;
     case DW_TAG_shared_type:
       break;
     default:
       break;
     }
 
     if (match_addr_range) {
-      dw_addr_t lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc,
-                                                   LLDB_INVALID_ADDRESS);
+      dw_addr_t lo_pc =
+          GetAttributeValueAsAddress(cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
       if (lo_pc != LLDB_INVALID_ADDRESS) {
-        dw_addr_t hi_pc =
-            GetAttributeHighPC(dwarf2Data, cu, lo_pc, LLDB_INVALID_ADDRESS);
+        dw_addr_t hi_pc = GetAttributeHighPC(cu, lo_pc, LLDB_INVALID_ADDRESS);
         if (hi_pc != LLDB_INVALID_ADDRESS) {
           //  printf("\n0x%8.8x: %30s: address = 0x%8.8x  [0x%8.8x - 0x%8.8x) ",
           //  m_offset, DW_TAG_value_to_name(tag), address, lo_pc, hi_pc);
           if ((lo_pc <= address) && (address < hi_pc)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {
             case DW_TAG_compile_unit: // File
if (match_addr_range) {
           // are address gaps in subroutines so we must always search
           // if there is no valid high and low PC.
           check_children = (m_tag == DW_TAG_compile_unit ||
                             m_tag == DW_TAG_partial_unit) &&
                            ((function_die != NULL) || (block_die != NULL));
         }
       } else {
         DWARFFormValue form_value;
-        if (GetAttributeValue(dwarf2Data, cu, DW_AT_ranges, form_value)) {
+        if (GetAttributeValue(cu, DW_AT_ranges, form_value)) {
           DWARFRangeList ranges;
+          SymbolFileDWARF *dwarf2Data = cu->GetSymbolFileDWARF();
           DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges();
           debug_ranges->FindRanges(
               cu, GetRangesOffset(debug_ranges, form_value), ranges);
 
           if (ranges.FindEntryThatContains(address)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {
if (match_addr_range) {
         }
       }
     }
 
     if (check_children) {
       //  printf("checking children\n");
       DWARFDebugInfoEntry *child = GetFirstChild();
       while (child) {
-        if (child->LookupAddress(address, dwarf2Data, cu, function_die,
-                                 block_die))
+        if (child->LookupAddress(address, cu, function_die, block_die))
           return true;
         child = child->GetSibling();
       }
     }
   }
   return found_address;
 }
 
 const DWARFAbbreviationDeclaration *
 DWARFDebugInfoEntry::GetAbbreviationDeclarationPtr(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    lldb::offset_t &offset) const {
-  if (dwarf2Data) {
+    const DWARFUnit *cu, lldb::offset_t &offset) const {
+  if (cu) {
     offset = GetOffset();
 
     const DWARFAbbreviationDeclarationSet *abbrev_set = cu->GetAbbreviations();
     if (abbrev_set) {
       const DWARFAbbreviationDeclaration *abbrev_decl =
           abbrev_set->GetAbbreviationDeclaration(m_abbr_idx);
       if (abbrev_decl) {
         // Make sure the abbreviation code still matches. If it doesn't and the
         // DWARF data was mmap'ed, the backing file might have been modified
         // which is bad news.
         const uint64_t abbrev_code = cu->GetData().GetULEB128(&offset);
 
         if (abbrev_decl->Code() == abbrev_code)
           return abbrev_decl;
 
+        SymbolFileDWARF *dwarf2Data = cu->GetSymbolFileDWARF();
+
         dwarf2Data->GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
             "0x%8.8x: the DWARF debug information has been modified (abbrev "
             "code was %u, and is now %u)",
             GetOffset(), (uint32_t)abbrev_decl->Code(), (uint32_t)abbrev_code);
       }
     }
   }
   offset = DW_INVALID_OFFSET;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   dw_addr_t GetBaseAddress() const { return m_base_addr; }
   dw_addr_t GetAddrBase() const { return m_addr_base; }
   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);
-  void BuildAddressRangeTable(SymbolFileDWARF *dwarf,
-                              DWARFDebugAranges *debug_aranges);
+  void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges);
 
   lldb::ByteOrder GetByteOrder() const;
 
   lldb_private::TypeSystem *GetTypeSystem();
 
   const DWARFDebugAranges &GetFunctionAranges();
 
   DWARFFormValue::FixedFormSizes GetFixedFormSizes();

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

static void SetDwoStrOffsetsBase(DWARFUnit *dwo_cu) {
   baseOffset += 2;
 
   dwo_cu->SetStrOffsetsBase(baseOffset);
 }
 
 // m_die_array_mutex must be already held as read/write.
 void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
   dw_addr_t addr_base = cu_die.GetAttributeValueAsUnsigned(
-      m_dwarf, this, DW_AT_addr_base, LLDB_INVALID_ADDRESS);
+      this, DW_AT_addr_base, LLDB_INVALID_ADDRESS);
   if (addr_base != LLDB_INVALID_ADDRESS)
     SetAddrBase(addr_base);
 
   dw_addr_t ranges_base = cu_die.GetAttributeValueAsUnsigned(
-      m_dwarf, this, DW_AT_rnglists_base, LLDB_INVALID_ADDRESS);
+      this, DW_AT_rnglists_base, LLDB_INVALID_ADDRESS);
   if (ranges_base != LLDB_INVALID_ADDRESS)
     SetRangesBase(ranges_base);
 
-  SetStrOffsetsBase(cu_die.GetAttributeValueAsUnsigned(
-      m_dwarf, this, DW_AT_str_offsets_base, 0));
+  SetStrOffsetsBase(
+      cu_die.GetAttributeValueAsUnsigned(this, DW_AT_str_offsets_base, 0));
 
-  uint64_t base_addr = cu_die.GetAttributeValueAsAddress(
-      m_dwarf, this, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
+  uint64_t base_addr = cu_die.GetAttributeValueAsAddress(this, DW_AT_low_pc,
+                                                         LLDB_INVALID_ADDRESS);
   if (base_addr == LLDB_INVALID_ADDRESS)
-    base_addr = cu_die.GetAttributeValueAsAddress(
-        m_dwarf, this, DW_AT_entry_pc, 0);
+    base_addr = cu_die.GetAttributeValueAsAddress(this, DW_AT_entry_pc, 0);
   SetBaseAddress(base_addr);
 
   std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf->GetDwoSymbolFileForCompileUnit(*this, cu_die);
   if (!dwo_symbol_file)
     return;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return; // Can't fetch the compile unit from the dwo file.
 
   DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return; // Can't fetch the compile unit DIE from the dwo file.
 
   uint64_t main_dwo_id =
-      cu_die.GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_GNU_dwo_id, 0);
+      cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_dwo_id, 0);
   uint64_t sub_dwo_id =
       dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0);
   if (main_dwo_id != sub_dwo_id)
     return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to
   // a differectn compilation.
 
   m_dwo_symbol_file = std::move(dwo_symbol_file);
 
   // Here for DWO CU we want to use the address base set in the skeleton unit
   // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
   // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
   // attributes which were applicable to the DWO units. The corresponding
   // DW_AT_* attributes standardized in DWARF v5 are also applicable to the main
   // unit in contrast.
   if (addr_base == LLDB_INVALID_ADDRESS)
-    addr_base = cu_die.GetAttributeValueAsUnsigned(m_dwarf, this,
-                                                   DW_AT_GNU_addr_base, 0);
+    addr_base =
+        cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_addr_base, 0);
   dwo_cu->SetAddrBase(addr_base);
 
   if (ranges_base == LLDB_INVALID_ADDRESS)
-    ranges_base = cu_die.GetAttributeValueAsUnsigned(m_dwarf, this,
-                                                     DW_AT_GNU_ranges_base, 0);
+    ranges_base =
+        cu_die.GetAttributeValueAsUnsigned(this, DW_AT_GNU_ranges_base, 0);
   dwo_cu->SetRangesBase(ranges_base);
 
   dwo_cu->SetBaseObjOffset(GetOffset());
 
   SetDwoStrOffsetsBase(dwo_cu);
 }
 
 DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {

 void DWARFUnit::ClearDIEsRWLocked() {
   m_die_array.clear();
   m_die_array.shrink_to_fit();
 
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->ClearDIEsRWLocked();
 }
 
-void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
-                                       DWARFDebugAranges *debug_aranges) {
+void DWARFUnit::BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) {
   // This function is usually called if there in no .debug_aranges section in
   // order to produce a compile unit level set of address ranges that is
   // accurate.
 
   size_t num_debug_aranges = debug_aranges->GetNumRanges();
 
   // First get the compile unit DIE only and check if it has a DW_AT_ranges
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
 
   const dw_offset_t cu_offset = GetOffset();
   if (die) {
     DWARFRangeList ranges;
     const size_t num_ranges =
-        die->GetAttributeAddressRanges(dwarf, this, ranges, false);
+        die->GetAttributeAddressRanges(this, ranges, false);
     if (num_ranges > 0) {
       // This compile unit has DW_AT_ranges, assume this is correct if it is
       // present since clang no longer makes .debug_aranges by default and it
       // emits DW_AT_ranges for DW_TAG_compile_units. GCC also does this with
       // recent GCC builds.
       for (size_t i = 0; i < num_ranges; ++i) {
         const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
         debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
                                    range.GetRangeEnd());
       }
 
       return; // We got all of our ranges from the DW_AT_ranges attribute
     }
   }
   // We don't have a DW_AT_ranges attribute, so we need to parse the DWARF
 
   // If the DIEs weren't parsed, then we don't want all dies for all compile
   // units to stay loaded when they weren't needed. So we can end up parsing
   // the DWARF and then throwing them all away to keep memory usage down.
   ScopedExtractDIEs clear_dies(ExtractDIEsScoped());
 
   die = DIEPtr();
   if (die)
-    die->BuildAddressRangeTable(dwarf, this, debug_aranges);
+    die->BuildAddressRangeTable(this, debug_aranges);
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
     // situation. Check the line tables and build the arange table from this.
     SymbolContext sc;
-    sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
+    sc.comp_unit = m_dwarf->GetCompUnitForDWARFCompUnit(this);
     if (sc.comp_unit) {
       SymbolFileDWARFDebugMap *debug_map_sym_file =
           m_dwarf->GetDebugMapSymfile();
       if (debug_map_sym_file == NULL) {
         LineTable *line_table = sc.comp_unit->GetLineTable();
 
         if (line_table) {
           LineTable::FileAddressRanges file_ranges;
           const bool append = true;
           const size_t num_ranges =
               line_table->GetContiguousFileAddressRanges(file_ranges, append);
           for (uint32_t idx = 0; idx < num_ranges; ++idx) {
             const LineTable::FileAddressRanges::Entry &range =
                 file_ranges.GetEntryRef(idx);
             debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
                                        range.GetRangeEnd());
           }
         }
       } else
-        debug_map_sym_file->AddOSOARanges(dwarf, debug_aranges);
+        debug_map_sym_file->AddOSOARanges(m_dwarf, debug_aranges);
     }
   }
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
     // situation. Check the line tables and build the arange table from this.
     SymbolContext sc;
-    sc.comp_unit = dwarf->GetCompUnitForDWARFCompUnit(this);
+    sc.comp_unit = m_dwarf->GetCompUnitForDWARFCompUnit(this);
     if (sc.comp_unit) {
       LineTable *line_table = sc.comp_unit->GetLineTable();
 
       if (line_table) {
         LineTable::FileAddressRanges file_ranges;
         const bool append = true;
         const size_t num_ranges =
             line_table->GetContiguousFileAddressRanges(file_ranges, append);
void DWARFUnit::ParseProducerInfo() {
   m_producer_version_major = UINT32_MAX;
   m_producer_version_minor = UINT32_MAX;
   m_producer_version_update = UINT32_MAX;
 
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
   if (die) {
 
     const char *producer_cstr =
-        die->GetAttributeValueAsString(m_dwarf, this, DW_AT_producer, NULL);
+        die->GetAttributeValueAsString(this, DW_AT_producer, NULL);
     if (producer_cstr) {
       RegularExpression llvm_gcc_regex(
           llvm::StringRef("^4\\.[012]\\.[01] \\(Based on Apple "
                           "Inc\\. build [0-9]+\\) \\(LLVM build "
                           "[\\.0-9]+\\)$"));
       if (llvm_gcc_regex.Execute(llvm::StringRef(producer_cstr))) {
         m_producer = eProducerLLVMGCC;
       } else if (strstr(producer_cstr, "clang")) {

 
 LanguageType DWARFUnit::GetLanguageType() {
   if (m_language_type != eLanguageTypeUnknown)
     return m_language_type;
 
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
   if (die)
     m_language_type = LanguageTypeFromDWARF(
-        die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_language, 0));
+        die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0));
   return m_language_type;
 }
 
 bool DWARFUnit::GetIsOptimized() {
   if (m_is_optimized == eLazyBoolCalculate) {
     const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
     if (die) {
       m_is_optimized = eLazyBoolNo;
-      if (die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_APPLE_optimized,
-                                           0) == 1) {
+      if (die->GetAttributeValueAsUnsigned(this, DW_AT_APPLE_optimized, 0) ==
+          1) {
         m_is_optimized = eLazyBoolYes;
       }
     }
   }
   return m_is_optimized == eLazyBoolYes;
 }
 
 FileSpec::Style DWARFUnit::GetPathStyle() {

 
 void DWARFUnit::ComputeCompDirAndGuessPathStyle() {
   m_comp_dir = FileSpec();
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
   if (!die)
     return;
 
   llvm::StringRef comp_dir = removeHostnameFromPathname(
-      die->GetAttributeValueAsString(m_dwarf, this, DW_AT_comp_dir, NULL));
+      die->GetAttributeValueAsString(this, DW_AT_comp_dir, NULL));
   if (!comp_dir.empty()) {
     FileSpec::Style comp_dir_style =
         FileSpec::GuessPathStyle(comp_dir).getValueOr(FileSpec::Style::native);
     m_comp_dir = resolveCompDir(FileSpec(comp_dir, comp_dir_style));
   } else {
     // Try to detect the style based on the DW_AT_name attribute, but just store
     // the detected style in the m_comp_dir field.
-    const char *name =
-        die->GetAttributeValueAsString(m_dwarf, this, DW_AT_name, NULL);
+    const char *name = die->GetAttributeValueAsString(this, DW_AT_name, NULL);
     m_comp_dir = FileSpec(
         "", FileSpec::GuessPathStyle(name).getValueOr(FileSpec::Style::native));
   }
 }
 
 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 == NULL) {
     m_func_aranges_up.reset(new DWARFDebugAranges());
     const DWARFDebugInfoEntry *die = DIEPtr();
     if (die)
-      die->BuildFunctionAddressRangeTable(m_dwarf, this,
-                                          m_func_aranges_up.get());
+      die->BuildFunctionAddressRangeTable(this, m_func_aranges_up.get());
 
     if (m_dwo_symbol_file) {
       DWARFUnit *dwo_cu = m_dwo_symbol_file->GetCompileUnit();
       const DWARFDebugInfoEntry *dwo_die = dwo_cu->DIEPtr();
       if (dwo_die)
-        dwo_die->BuildFunctionAddressRangeTable(m_dwo_symbol_file.get(), dwo_cu,
+        dwo_die->BuildFunctionAddressRangeTable(dwo_cu,
                                                 m_func_aranges_up.get());
     }
 
     const bool minimize = false;
     m_func_aranges_up->Sort(minimize);
   }
   return *m_func_aranges_up;
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
     DWARFUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) {
   // If we are using a dSYM file, we never want the standard DWO files since
   // the -gmodules support uses the same DWO machanism to specify full debug
   // info files for modules.
   if (GetDebugMapSymfile())
     return nullptr;
 
-  const char *dwo_name = cu_die.GetAttributeValueAsString(
-      this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
+  const char *dwo_name =
+      cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
   if (!dwo_name)
     return nullptr;
 
   SymbolFileDWARFDwp *dwp_symfile = GetDwpSymbolFile();
   if (dwp_symfile) {
-    uint64_t dwo_id = cu_die.GetAttributeValueAsUnsigned(this, &dwarf_cu,
-                                                         DW_AT_GNU_dwo_id, 0);
+    uint64_t dwo_id =
+        cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_GNU_dwo_id, 0);
     std::unique_ptr<SymbolFileDWARFDwo> dwo_symfile =
         dwp_symfile->GetSymbolFileForDwoId(&dwarf_cu, dwo_id);
     if (dwo_symfile)
       return dwo_symfile;
   }
 
   FileSpec dwo_file(dwo_name);
   FileSystem::Instance().Resolve(dwo_file);
   if (dwo_file.IsRelative()) {
-    const char *comp_dir = cu_die.GetAttributeValueAsString(
-        this, &dwarf_cu, DW_AT_comp_dir, nullptr);
+    const char *comp_dir =
+        cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_comp_dir, nullptr);
     if (!comp_dir)
       return nullptr;
 
     dwo_file.SetFile(comp_dir, FileSpec::Style::native);
     FileSystem::Instance().Resolve(dwo_file);
     dwo_file.AppendPathComponent(dwo_name);
   }