Move DebugRanges() function from SymbolFileDWARF to DWARFContext

[zturner]

Summary

This should be the last non-dwo dependent piece to get over to DWARFContext. After this there will need to be some careful refactoring to get all knowledge of DWO-ness into the DWARFContext, ultimately culminating in probably deleting SymbolFileDWARFDwo and friends. That's for later though, just trying to give a preview into where this is going.

Eventually the goal is that SymbolFileDWARF depends on the low level parser, but not the other way around, at which point we can start the real process of merging with LLVM's.

[clayborg]

Be nice to move DWARFContext out of the lldb_private namespace at some point, but I didn't catch this on other patches so this won't hold up this patch.

lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h

23–26

Why are we defining DWARFContext in the lldb_private namespace? I missed prior patches doing this, but we should start putting plug-in code in plug-in specific namespace at some point.

lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h

 struct DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
 
+namespace lldb_private {
+class DWARFContext;
+}
+
 class DWARFBaseDIE {
 public:
   DWARFBaseDIE() : m_cu(nullptr), m_die(nullptr) {}
 
   DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(die) {}
 
   DWARFBaseDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
public:
   bool HasChildren() const;
 
   bool Supports_DW_AT_APPLE_objc_complete_type() const;
 
   //----------------------------------------------------------------------
   // Accessors
   //----------------------------------------------------------------------
   SymbolFileDWARF *GetDWARF() const;
+  lldb_private::DWARFContext &GetDWARFContext() const;
 
   DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
   DIERef GetDIERef() const;
 
   lldb_private::TypeSystem *GetTypeSystem() const;

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

 
 SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
   if (m_cu)
     return m_cu->GetSymbolFileDWARF();
   else
     return nullptr;
 }
 
+DWARFContext &DWARFBaseDIE::GetDWARFContext() const {
+  return m_cu->GetDWARFContext();
+}
+
 lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const {
   if (m_cu)
     return m_cu->GetTypeSystem();
   else
     return nullptr;
 }
 
 DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const {

lldb/source/Plugins/SymbolFile/DWARF/DWARFContext.h

 //===-- DWARFContext.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_PLUGINS_SYMBOLFILE_DWARF_DWARFCONTEXT_H
 #define LLDB_PLUGINS_SYMBOLFILE_DWARF_DWARFCONTEXT_H
 
 #include "DWARFDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "llvm/ADT/Optional.h"
 #include <memory>
 
+class DWARFDebugRangesBase;
+
 namespace lldb_private {
 class DWARFContext {
 private:
   Module &m_module;
   llvm::Optional<DWARFDataExtractor> m_data_debug_aranges;
   llvm::Optional<DWARFDataExtractor> m_data_debug_frame;
   llvm::Optional<DWARFDataExtractor> m_data_debug_line;
   llvm::Optional<DWARFDataExtractor> m_data_debug_line_str;
   llvm::Optional<DWARFDataExtractor> m_data_debug_macro;
   llvm::Optional<DWARFDataExtractor> m_data_debug_loc;
   llvm::Optional<DWARFDataExtractor> m_data_debug_loclists;
   llvm::Optional<DWARFDataExtractor> m_data_debug_ranges;
   llvm::Optional<DWARFDataExtractor> m_data_debug_rnglists;
   llvm::Optional<DWARFDataExtractor> m_data_debug_types;
   llvm::Optional<DWARFDataExtractor> m_data_gnu_debug_altlink;
 
+  llvm::Optional<std::unique_ptr<DWARFDebugRangesBase>> m_ranges;
+
 public:
   explicit DWARFContext(Module &module);
 
   const DWARFDataExtractor *getOrLoadArangesData();
   const DWARFDataExtractor *getOrLoadDebugLineData();
   const DWARFDataExtractor *getOrLoadDebugLineStrData();
   const DWARFDataExtractor *getOrLoadDebugMacroData();
   const DWARFDataExtractor *getOrLoadDebugLocData();
   const DWARFDataExtractor *getOrLoadDebugLoclistData();
   const DWARFDataExtractor *getOrLoadDebugRangesData();
   const DWARFDataExtractor *getOrLoadDebugRnglistsData();
   const DWARFDataExtractor *getOrLoadDebugFrameData();
   const DWARFDataExtractor *getOrLoadDebugTypesData();
   const DWARFDataExtractor *getOrLoadGnuDebugAltlinkData();
 
   const DWARFDataExtractor *getOrLoadBestDebugLocData();
+
+  const DWARFDebugRangesBase *getOrLoadRangeInfo();
 };
 } // namespace lldb_private
 
 #endif

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

 //===-- DWARFContext.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 "DWARFContext.h"
+#include "DWARFDebugRanges.h"
 
 #include "lldb/Core/Section.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const DWARFDataExtractor *
 GetPointerOrNull(const llvm::Optional<DWARFDataExtractor> &extractor) {

 
 const DWARFDataExtractor *DWARFContext::getOrLoadBestDebugLocData() {
   const DWARFDataExtractor *loc = getOrLoadDebugLocData();
   if (loc)
     return loc;
 
   return getOrLoadDebugLoclistData();
 }
+
+const DWARFDebugRangesBase *DWARFContext::getOrLoadRangeInfo() {
+
+  if (m_ranges.hasValue())
+    return m_ranges->get();
+
+  m_ranges.emplace();
+
+  if (getOrLoadDebugRangesData())
+    m_ranges = llvm::make_unique<DWARFDebugRanges>();
+  else if (getOrLoadDebugRnglistsData())
+    m_ranges = llvm::make_unique<DWARFDebugRngLists>();
+  else
+    return nullptr;
+
+  (*m_ranges)->Extract(*this);
+  return m_ranges->get();
+}
 No newline at end of file

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

DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   }
   return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
   if (IsValid()) {
     SymbolFileDWARF *dwarf = GetDWARF();
+    DWARFContext &context = GetDWARFContext();
     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, dwarf, context, 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()->GetCompileUnit(
                               DIERef(cu->GetOffset(), block_die->GetOffset())),
                           block_die);
       }

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

 typedef UInt32ToDIEMap::iterator UInt32ToDIEMapIter;
 typedef UInt32ToDIEMap::const_iterator UInt32ToDIEMapConstIter;
 
 typedef std::multimap<uint32_t, const DWARFDebugInfoEntry *> UInt32ToDIEMMap;
 typedef UInt32ToDIEMMap::iterator UInt32ToDIEMMapIter;
 typedef UInt32ToDIEMMap::const_iterator UInt32ToDIEMMapConstIter;
 
 class DWARFDeclContext;
+namespace lldb_private {
+class DWARFContext;
+}
 
 #define DIE_SIBLING_IDX_BITSIZE 31
 
 class DWARFDebugInfoEntry {
 public:
   typedef std::vector<DWARFDebugInfoEntry> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
public:
   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,
+                     lldb_private::DWARFContext &context, 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!!!
GetAttributeHighPC(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                      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,
       bool check_specification_or_abstract_origin = false) const;
 
   size_t GetAttributeAddressRanges(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-      DWARFRangeList &ranges, bool check_hi_lo_pc,
+      SymbolFileDWARF *dwarf2Data, lldb_private::DWARFContext &context,
+      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 *GetMangledName(SymbolFileDWARF *dwarf2Data,
                              const DWARFUnit *cu,
                              bool substitute_name_allowed = true) const;

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

for (uint32_t i = 0; i < numAttributes; ++i) {
               do_offset = hi_pc != LLDB_INVALID_ADDRESS;
             else
               hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save
                               // on relocations
           }
           break;
 
         case DW_AT_ranges: {
-          const DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges();
+          const DWARFDebugRangesBase *debug_ranges =
+              dwarf_context.getOrLoadRangeInfo();
           if (debug_ranges)
             debug_ranges->FindRanges(cu, GetRangesOffset(debug_ranges, form_value), ranges);
           else
             cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
                 "{0x%8.8x}: DIE has DW_AT_ranges(0x%" PRIx64
                 ") attribute yet DWARF has no .debug_ranges, please file a bug "
                 "and attach the file at the start of this error message",
                 m_offset, form_value.Unsigned());
case DW_AT_type: {
     AppendTypeName(dwarf2Data, cu, type_die_offset, s);
     s.PutCString(" )");
   } break;
 
   case DW_AT_ranges: {
     if (!dwarf2Data)
       break;
     lldb::offset_t ranges_offset =
-        GetRangesOffset(dwarf2Data->DebugRanges(), form_value);
+        GetRangesOffset(dwarf_context.getOrLoadRangeInfo(), form_value);
     dw_addr_t base_addr = cu ? cu->GetBaseAddress() : 0;
     const DWARFDataExtractor *debug_ranges =
         dwarf_context.getOrLoadDebugRangesData();
     if (!debug_ranges)
       break;
 
     DWARFDebugRanges::Dump(s, *debug_ranges, &ranges_offset, base_addr);
   } break;
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,
+    SymbolFileDWARF *dwarf2Data, DWARFContext &context, const DWARFUnit *cu,
     DWARFRangeList &ranges, bool check_hi_lo_pc,
     bool check_specification_or_abstract_origin) const {
   ranges.Clear();
 
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, DW_AT_ranges, form_value)) {
-    if (DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges())
+    if (const DWARFDebugRangesBase *debug_ranges = context.getOrLoadRangeInfo())
       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,
                                  check_specification_or_abstract_origin)) {
const char *DWARFDebugInfoEntry::GetQualifiedName(
   return storage.c_str();
 }
 
 //----------------------------------------------------------------------
 // LookupAddress
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::LookupAddress(const dw_addr_t address,
                                         SymbolFileDWARF *dwarf2Data,
+                                        DWARFContext &context,
                                         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,
if (match_addr_range) {
           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)) {
           DWARFRangeList ranges;
-          DWARFDebugRangesBase *debug_ranges = dwarf2Data->DebugRanges();
+          const DWARFDebugRangesBase *debug_ranges =
+              context.getOrLoadRangeInfo();
           debug_ranges->FindRanges(
               cu, GetRangesOffset(debug_ranges, form_value), ranges);
 
           if (ranges.FindEntryThatContains(address)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {
             case DW_TAG_compile_unit: // File
if (match_addr_range) {
         }
       }
     }
 
     if (check_children) {
       //  printf("checking children\n");
       DWARFDebugInfoEntry *child = GetFirstChild();
       while (child) {
-        if (child->LookupAddress(address, dwarf2Data, cu, function_die,
+        if (child->LookupAddress(address, dwarf2Data, context, cu, function_die,
                                  block_die))
           return true;
         child = child->GetSibling();
       }
     }
   }
   return found_address;
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.h

 namespace lldb_private {
 class DWARFContext;
 }
 
 class DWARFDebugRangesBase {
 public:
   virtual ~DWARFDebugRangesBase(){};
 
-  virtual void Extract(SymbolFileDWARF *dwarf2Data,
-                       lldb_private::DWARFContext &dwarf_context) = 0;
+  virtual void Extract(lldb_private::DWARFContext &dwarf_context) = 0;
   virtual bool FindRanges(const DWARFUnit *cu, dw_offset_t debug_ranges_offset,
                           DWARFRangeList &range_list) const = 0;
   virtual uint64_t GetOffset(size_t Index) const = 0;
 };
 
 class DWARFDebugRanges final : public DWARFDebugRangesBase {
 public:
   DWARFDebugRanges();
 
-  void Extract(SymbolFileDWARF *dwarf2Data,
-               lldb_private::DWARFContext &dwarf_context) override;
+  void Extract(lldb_private::DWARFContext &dwarf_context) override;
   bool FindRanges(const DWARFUnit *cu, dw_offset_t debug_ranges_offset,
                   DWARFRangeList &range_list) const override;
   uint64_t GetOffset(size_t Index) const override;
 
   static void Dump(lldb_private::Stream &s,
                    const lldb_private::DWARFDataExtractor &debug_ranges_data,
                    lldb::offset_t *offset_ptr, dw_addr_t cu_base_addr);
 
 protected:
-  bool Extract(SymbolFileDWARF *dwarf2Data,
-               lldb_private::DWARFContext &dwarf_context,
+  bool Extract(lldb_private::DWARFContext &dwarf_context,
                lldb::offset_t *offset_ptr, DWARFRangeList &range_list);
 
   typedef std::map<dw_offset_t, DWARFRangeList> range_map;
   typedef range_map::iterator range_map_iterator;
   typedef range_map::const_iterator range_map_const_iterator;
   range_map m_range_map;
 };
 
 // DWARF v5 .debug_rnglists section.
 class DWARFDebugRngLists final : public DWARFDebugRangesBase {
   struct RngListEntry {
     uint8_t encoding;
     uint64_t value0;
     uint64_t value1;
   };
 
 public:
-  void Extract(SymbolFileDWARF *dwarf2Data,
-               lldb_private::DWARFContext &dwarf_context) override;
+  void Extract(lldb_private::DWARFContext &dwarf_context) override;
   bool FindRanges(const DWARFUnit *cu, dw_offset_t debug_ranges_offset,
                   DWARFRangeList &range_list) const override;
   uint64_t GetOffset(size_t Index) const override;
 
 protected:
   bool ExtractRangeList(const lldb_private::DWARFDataExtractor &data,
                         uint8_t addrSize, lldb::offset_t *offset_ptr,
                         std::vector<RngListEntry> &list);
 
   std::vector<uint64_t> Offsets;
   std::map<dw_offset_t, std::vector<RngListEntry>> m_range_map;
 };
 
 #endif // SymbolFileDWARF_DWARFDebugRanges_h_

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

switch(addr_size) {
     case 8:
       return 0xffffffffffffffff;
   }
   llvm_unreachable("GetBaseAddressMarker unsupported address size.");
 }
 
 DWARFDebugRanges::DWARFDebugRanges() : m_range_map() {}
 
-void DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data,
-                               lldb_private::DWARFContext &dwarf_context) {
+void DWARFDebugRanges::Extract(lldb_private::DWARFContext &dwarf_context) {
   DWARFRangeList range_list;
   lldb::offset_t offset = 0;
   dw_offset_t debug_ranges_offset = offset;
-  while (Extract(dwarf2Data, dwarf_context, &offset, range_list)) {
+  while (Extract(dwarf_context, &offset, range_list)) {
     range_list.Sort();
     m_range_map[debug_ranges_offset] = range_list;
     debug_ranges_offset = offset;
   }
 }
 
-bool DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data,
-                               DWARFContext &dwarf_context,
+bool DWARFDebugRanges::Extract(DWARFContext &dwarf_context,
                                lldb::offset_t *offset_ptr,
                                DWARFRangeList &range_list) {
   range_list.Clear();
 
   lldb::offset_t range_offset = *offset_ptr;
   const DWARFDataExtractor *debug_ranges =
       dwarf_context.getOrLoadDebugRangesData();
   if (!debug_ranges)
for (const RngListEntry &E : pos->second) {
         llvm_unreachable("unexpected encoding");
       }
     }
     return true;
   }
   return false;
 }
 
-void DWARFDebugRngLists::Extract(SymbolFileDWARF *dwarf2Data,
-                                 lldb_private::DWARFContext &dwarf_context) {
+void DWARFDebugRngLists::Extract(lldb_private::DWARFContext &dwarf_context) {
   const DWARFDataExtractor *data = dwarf_context.getOrLoadDebugRnglistsData();
   if (!data)
     return;
 
   lldb::offset_t offset = 0;
 
   uint64_t length = data->GetU32(&offset);
   // FIXME: Handle DWARF64.

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

void DWARFUnit::BuildAddressRangeTable(SymbolFileDWARF *dwarf,
   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);
+    const size_t num_ranges = die->GetAttributeAddressRanges(
+        dwarf, GetDWARFContext(), 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(),

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   DWARFDebugAbbrev *DebugAbbrev();
 
   const DWARFDebugAbbrev *DebugAbbrev() const;
 
   DWARFDebugInfo *DebugInfo();
 
   const DWARFDebugInfo *DebugInfo() const;
 
-  DWARFDebugRangesBase *DebugRanges();
-
-  const DWARFDebugRangesBase *DebugRanges() const;
-
   static bool SupportedVersion(uint16_t version);
 
   DWARFDIE
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 

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

DWARFUnit *dwarf_cu =
         info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }
 
-DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() {
-  if (m_ranges == NULL) {
-    static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
-    Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
-                       static_cast<void *>(this));
-
-    if (m_context.getOrLoadDebugRangesData())
-      m_ranges = llvm::make_unique<DWARFDebugRanges>();
-    else if (m_context.getOrLoadDebugRnglistsData())
-      m_ranges = llvm::make_unique<DWARFDebugRngLists>();
-
-    if (m_ranges)
-      m_ranges->Extract(this, m_context);
-  }
-  return m_ranges.get();
-}
-
-const DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() const {
-  return m_ranges.get();
-}
-
 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFUnit *dwarf_cu,
                                                    uint32_t cu_idx) {
   CompUnitSP cu_sp;
   if (dwarf_cu) {
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
     if (comp_unit) {
       // We already parsed this compile unit, had out a shared pointer to it
       cu_sp = comp_unit->shared_from_this();
if (num_attributes > 0) {
             }
           } break;
           case DW_AT_specification:
             spec_die = GetDIE(DIERef(form_value));
             break;
           case DW_AT_start_scope: {
             if (form_value.Form() == DW_FORM_sec_offset) {
               DWARFRangeList dwarf_scope_ranges;
-              const DWARFDebugRangesBase *debug_ranges = DebugRanges();
+              const DWARFDebugRangesBase *debug_ranges =
+                  m_context.getOrLoadRangeInfo();
               debug_ranges->FindRanges(die.GetCU(),
                                        form_value.Unsigned(),
                                        dwarf_scope_ranges);
             } else {
               // TODO: Handle the case when DW_AT_start_scope have form
               // constant. The
               // dwarf spec is a bit ambiguous about what is the expected
               // behavior in case the enclosing block have a non coninious