Move the rest of the section loading over to DWARFContext

[zturner]

Summary

This gets all of the remaining sections except those that are DWO-dependent. That will be a bit harder to do since we'll somehow have to get knowledge of DWO-ness into the DWARFContext.

This is mostly mechanical now after D59562.

[clayborg]

Use reference to DWARFContext instead of pointers? Apply to entire patch and good to go

[zturner]

In D59611#1437044, @clayborg wrote:

Use reference to DWARFContext instead of pointers? Apply to entire patch and good to go

Done. Since you conditionally LGTM'ed it based on that and I made that change I'll go ahead and submit

[labath]

This broke the DWO flavours of some tests:

lldb-Suite :: lang/c/const_variables/TestConstVariables.py
lldb-Suite :: lang/c/local_variables/TestLocalVariables.py
lldb-Suite :: lang/c/vla/TestVLA.py

I believe the problem is that DWARFContext::LoadOrGetSection does not take DWO files into account. It was modelled based on SymbolFileDWARF's notion of loading sections, but you probably missed the fact that SymbolFileDWARFDwo overrides LoadSectionData to load the data from a different object file https://github.com/llvm-mirror/lldb/blob/master/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp#L32. The DWARFContext does not have that, and so it always loads the sections from the main module object file, which results in things going south.

I think the fix for this should be relatively simple. We just need to give SymbolFileDWARFDwo the opportunity to initialize the DWARFContext with a different set of sections. However, since this will require changing it's constructor to not accept a Module object (since dwo files do not have one -- the next best thing might be to take a SectionList), and change the DWARFContext ownership model (so that subclasses can customize it's initialization), I did not want to try make a hasty unreviewed fix for that. Instead I just reverted this patch for now. (The problem was kind of already introduced by the previous patch in this series, but I believe that one is fine to keep because there is no DWO flavour of debug_aranges).

Let me know if you have trouble reproducing these failures on your side.

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

 //===-- DWARFCompileUnit.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_DWARFCompileUnit_h_
 #define SymbolFileDWARF_DWARFCompileUnit_h_
 
 #include "DWARFUnit.h"
 #include "llvm/Support/Error.h"
 
+namespace lldb_private {
+class DWARFContext;
+}
+
 class DWARFCompileUnit : public DWARFUnit {
 public:
   static llvm::Expected<DWARFUnitSP>
   extract(SymbolFileDWARF *dwarf2Data,
+          lldb_private::DWARFContext &dwarf_context,
           const lldb_private::DWARFDataExtractor &debug_info,
           lldb::offset_t *offset_ptr);
   void Dump(lldb_private::Stream *s) const override;
 
   //------------------------------------------------------------------
   /// Get the data that contains the DIE information for this unit.
   ///
   /// \return
   ///   The correct data (.debug_types for DWARF 4 and earlier, and
   ///   .debug_info for DWARF 5 and later) for the DIE information in
   ///   this unit.
   //------------------------------------------------------------------
   const lldb_private::DWARFDataExtractor &GetData() const override;
 
   //------------------------------------------------------------------
   /// Get the size in bytes of the header.
   ///
   /// \return
   ///     Byte size of the compile unit header
   //------------------------------------------------------------------
   uint32_t GetHeaderByteSize() const override;
 
 private:
-  DWARFCompileUnit(SymbolFileDWARF *dwarf2Data);
+  DWARFCompileUnit(SymbolFileDWARF *dwarf2Data,
+                   lldb_private::DWARFContext &dwarf_context);
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

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

 
 #include "SymbolFileDWARF.h"
 #include "lldb/Utility/Stream.h"
 #include "llvm/Object/Error.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
-    : DWARFUnit(dwarf2Data) {}
-
-llvm::Expected<DWARFUnitSP>
-DWARFCompileUnit::extract(SymbolFileDWARF *dwarf2Data,
-                          const DWARFDataExtractor &debug_info,
-                          lldb::offset_t *offset_ptr) {
+DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data,
+                                   DWARFContext &dwarf_context)
+    : DWARFUnit(dwarf2Data, dwarf_context) {}
+
+llvm::Expected<DWARFUnitSP> DWARFCompileUnit::extract(
+    SymbolFileDWARF *dwarf2Data, DWARFContext &dwarf_context,
+    const DWARFDataExtractor &debug_info, lldb::offset_t *offset_ptr) {
   assert(debug_info.ValidOffset(*offset_ptr));
 
   // std::make_shared would require the ctor to be public.
-  std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));
+  std::shared_ptr<DWARFCompileUnit> cu_sp(
+      new DWARFCompileUnit(dwarf2Data, dwarf_context));
 
   cu_sp->m_offset = *offset_ptr;
 
   dw_offset_t abbr_offset;
   const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
   if (!abbr)
     return llvm::make_error<llvm::object::GenericBinaryError>(
         "No debug_abbrev data");

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

 #include "llvm/ADT/Optional.h"
 #include <memory>
 
 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;
 
 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();
 };
 } // namespace lldb_private
 
 #endif

lldb/trunk/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 "lldb/Core/Section.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const DWARFDataExtractor *
+GetPointerOrNull(const llvm::Optional<DWARFDataExtractor> &extractor) {
+  if (!extractor.hasValue())
+    return nullptr;
+  return extractor.getPointer();
+}
+
+static const DWARFDataExtractor *
 LoadOrGetSection(Module &module, SectionType section_type,
                  llvm::Optional<DWARFDataExtractor> &extractor) {
   if (extractor.hasValue())
     return extractor->GetByteSize() > 0 ? extractor.getPointer() : nullptr;
 
   // Initialize to an empty extractor so that we always take the fast path going
   // forward.
   extractor.emplace();

 }
 
 DWARFContext::DWARFContext(Module &module) : m_module(module) {}
 
 const DWARFDataExtractor *DWARFContext::getOrLoadArangesData() {
   return LoadOrGetSection(m_module, eSectionTypeDWARFDebugAranges,
                           m_data_debug_aranges);
 }
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugLineData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugLine,
+                          m_data_debug_line);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugLineStrData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugLineStr,
+                          m_data_debug_line_str);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugMacroData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugMacro,
+                          m_data_debug_macro);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugLocData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugLoc,
+                          m_data_debug_loc);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugLoclistData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugLocLists,
+                          m_data_debug_loclists);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugRangesData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugRanges,
+                          m_data_debug_ranges);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugRnglistsData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugRngLists,
+                          m_data_debug_rnglists);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugFrameData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugFrame,
+                          m_data_debug_frame);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadDebugTypesData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugTypes,
+                          m_data_debug_types);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadGnuDebugAltlinkData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFGNUDebugAltLink,
+                          m_data_gnu_debug_altlink);
+}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadBestDebugLocData() {
+  const DWARFDataExtractor *loc = getOrLoadDebugLocData();
+  if (loc)
+    return loc;
+
+  return getOrLoadDebugLoclistData();
+}

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

 
 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);
+        GetDWARF(), GetDWARF()->GetDWARFContext(), 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

if (!m_compile_units.empty())
     return;
   if (!m_dwarf2Data)
     return;
 
   lldb::offset_t offset = 0;
   const auto &debug_info_data = m_dwarf2Data->get_debug_info_data();
 
   while (debug_info_data.ValidOffset(offset)) {
-    llvm::Expected<DWARFUnitSP> cu_sp =
-        DWARFCompileUnit::extract(m_dwarf2Data, debug_info_data, &offset);
+    llvm::Expected<DWARFUnitSP> cu_sp = DWARFCompileUnit::extract(
+        m_dwarf2Data, m_context, debug_info_data, &offset);
 
     if (!cu_sp) {
       // FIXME: Propagate this error up.
       llvm::consumeError(cu_sp.takeError());
       return;
     }
 
     // If it didn't return an error, then it should be returning a valid

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

public:
   const char *GetQualifiedName(SymbolFileDWARF *dwarf2Data,
                                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,
+  void Dump(SymbolFileDWARF *dwarf2Data,
+            lldb_private::DWARFContext &dwarf_context, const DWARFUnit *cu,
             lldb_private::Stream &s, uint32_t recurse_depth) const;
 
   static void
-  DumpAttribute(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
+  DumpAttribute(SymbolFileDWARF *dwarf2Data,
+                lldb_private::DWARFContext &dwarf_context, 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,
-                       lldb_private::DWARFExpression *frame_base = NULL) const;
+  bool GetDIENamesAndRanges(
+      SymbolFileDWARF *dwarf2Data, lldb_private::DWARFContext &dwarf_context,
+      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,
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclarationPtr(SymbolFileDWARF *dwarf2Data,
                                 const DWARFUnit *cu,
                                 lldb::offset_t &offset) const;
 
   dw_tag_t Tag() const { return m_tag; }
 

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

 
 //----------------------------------------------------------------------
 // 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 {
+    SymbolFileDWARF *dwarf2Data, DWARFContext &dwarf_context,
+    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;
 
   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, dwarf_context, 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 =
for (uint32_t i = 0; i < numAttributes; ++i) {
           if (frame_base) {
             if (form_value.BlockData()) {
               uint32_t block_offset =
                   form_value.BlockData() - debug_info_data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
               frame_base->SetOpcodeData(module, debug_info_data, block_offset,
                                         block_length);
             } else {
-              const DWARFDataExtractor &debug_loc_data =
-                  dwarf2Data->DebugLocData();
+              const DWARFDataExtractor *debug_loc =
+                  dwarf_context.getOrLoadBestDebugLocData();
+              if (!debug_loc)
+                break;
+
               const dw_offset_t debug_loc_offset = form_value.Unsigned();
 
               size_t loc_list_length = DWARFExpression::LocationListSize(
-                  cu, debug_loc_data, debug_loc_offset);
+                  cu, *debug_loc, debug_loc_offset);
               if (loc_list_length > 0) {
-                frame_base->SetOpcodeData(module, debug_loc_data,
-                                          debug_loc_offset, loc_list_length);
+                frame_base->SetOpcodeData(module, *debug_loc, debug_loc_offset,
+                                          loc_list_length);
                 if (lo_pc != LLDB_INVALID_ADDRESS) {
                   assert(lo_pc >= cu->GetBaseAddress());
                   frame_base->SetLocationListSlide(lo_pc -
                                                    cu->GetBaseAddress());
                 } else {
                   set_frame_base_loclist_addr = true;
                 }
               }
bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
   }
 
   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.GetDWARF(), die.GetDWARF()->GetDWARFContext(), 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,
+                               lldb_private::DWARFContext &dwarf_context,
                                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);
 
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(dwarf2Data, dwarf_context, 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(dwarf2Data, dwarf_context, 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) {
+    SymbolFileDWARF *dwarf2Data, lldb_private::DWARFContext &dwarf_context,
+    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 (blockData) {
                                       form_value.Unsigned());
       DWARFExpression::PrintDWARFExpression(
           s, locationData, DWARFUnit::GetAddressByteSize(cu), 4, false);
     } else {
       // We have a location list offset as the value that is the offset into
       // the .debug_loc section that describes the value over it's lifetime
       uint64_t debug_loc_offset = form_value.Unsigned();
       if (dwarf2Data) {
-        DWARFExpression::PrintDWARFLocationList(
-            s, cu, dwarf2Data->DebugLocData(), debug_loc_offset);
+        const DWARFDataExtractor *debug_loc_data =
+            dwarf_context.getOrLoadBestDebugLocData();
+        if (!debug_loc_data)
+          break;
+
+        DWARFExpression::PrintDWARFLocationList(s, cu, *debug_loc_data,
+                                                debug_loc_offset);
       }
     }
   } break;
 
   case DW_AT_abstract_origin:
   case DW_AT_specification: {
     uint64_t abstract_die_offset = form_value.Reference();
     form_value.Dump(s);
void DWARFDebugInfoEntry::DumpAttribute(
   } 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);
+    const DWARFDataExtractor *debug_ranges =
+        dwarf_context.getOrLoadDebugRangesData();
+    if (!debug_ranges)
+      break;
+
+    DWARFDebugRanges::Dump(s, *debug_ranges, &ranges_offset, base_addr);
   } break;
 
   default:
     break;
   }
 
   s.PutCString(" )\n");
 }

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

 //===-- DWARFDebugRanges.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_DWARFDebugRanges_h_
 #define SymbolFileDWARF_DWARFDebugRanges_h_
 
 #include "DWARFDIE.h"
 #include "SymbolFileDWARF.h"
 
 #include <map>
 
+namespace lldb_private {
+class DWARFContext;
+}
+
 class DWARFDebugRangesBase {
 public:
   virtual ~DWARFDebugRangesBase(){};
 
-  virtual void Extract(SymbolFileDWARF *dwarf2Data) = 0;
+  virtual void Extract(SymbolFileDWARF *dwarf2Data,
+                       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) override;
+  void Extract(SymbolFileDWARF *dwarf2Data,
+               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::offset_t *offset_ptr,
-               DWARFRangeList &range_list);
+  bool Extract(SymbolFileDWARF *dwarf2Data,
+               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) override;
+  void Extract(SymbolFileDWARF *dwarf2Data,
+               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/trunk/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) {
+void DWARFDebugRanges::Extract(SymbolFileDWARF *dwarf2Data,
+                               lldb_private::DWARFContext &dwarf_context) {
   DWARFRangeList range_list;
   lldb::offset_t offset = 0;
   dw_offset_t debug_ranges_offset = offset;
-  while (Extract(dwarf2Data, &offset, range_list)) {
+  while (Extract(dwarf2Data, 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,
                                lldb::offset_t *offset_ptr,
                                DWARFRangeList &range_list) {
   range_list.Clear();
 
   lldb::offset_t range_offset = *offset_ptr;
-  const DWARFDataExtractor &debug_ranges_data =
-      dwarf2Data->get_debug_ranges_data();
-  uint32_t addr_size = debug_ranges_data.GetAddressByteSize();
+  const DWARFDataExtractor *debug_ranges =
+      dwarf_context.getOrLoadDebugRangesData();
+  if (!debug_ranges)
+    return false;
+
+  uint32_t addr_size = debug_ranges->GetAddressByteSize();
   dw_addr_t base_addr = 0;
   dw_addr_t base_addr_marker = GetBaseAddressMarker(addr_size);
 
-  while (
-      debug_ranges_data.ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size)) {
-    dw_addr_t begin = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
-    dw_addr_t end = debug_ranges_data.GetMaxU64(offset_ptr, addr_size);
+  while (debug_ranges->ValidOffsetForDataOfSize(*offset_ptr, 2 * addr_size)) {
+    dw_addr_t begin = debug_ranges->GetMaxU64(offset_ptr, addr_size);
+    dw_addr_t end = debug_ranges->GetMaxU64(offset_ptr, addr_size);
 
     if (!begin && !end) {
       // End of range list
       break;
     }
 
     if (begin == base_addr_marker) {
       base_addr = end;
for (const RngListEntry &E : pos->second) {
         llvm_unreachable("unexpected encoding");
       }
     }
     return true;
   }
   return false;
 }
 
-void DWARFDebugRngLists::Extract(SymbolFileDWARF *dwarf2Data) {
-  const DWARFDataExtractor &data = dwarf2Data->get_debug_rnglists_data();
+void DWARFDebugRngLists::Extract(SymbolFileDWARF *dwarf2Data,
+                                 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);
+  uint64_t length = data->GetU32(&offset);
   // FIXME: Handle DWARF64.
   lldb::offset_t end = offset + length;
 
   // Check version.
-  if (data.GetU16(&offset) < 5)
+  if (data->GetU16(&offset) < 5)
     return;
 
-  uint8_t addrSize = data.GetU8(&offset);
+  uint8_t addrSize = data->GetU8(&offset);
 
   // We do not support non-zero segment selector size.
-  if (data.GetU8(&offset) != 0) {
+  if (data->GetU8(&offset) != 0) {
     lldbassert(0 && "not implemented");
     return;
   }
 
-  uint32_t offsetsAmount = data.GetU32(&offset);
+  uint32_t offsetsAmount = data->GetU32(&offset);
   for (uint32_t i = 0; i < offsetsAmount; ++i)
-    Offsets.push_back(data.GetMaxU64(&offset, 4));
+    Offsets.push_back(data->GetMaxU64(&offset, 4));
 
   lldb::offset_t listOffset = offset;
   std::vector<RngListEntry> rangeList;
-  while (offset < end && ExtractRangeList(data, addrSize, &offset, rangeList)) {
+  while (offset < end &&
+         ExtractRangeList(*data, addrSize, &offset, rangeList)) {
     m_range_map[listOffset] = rangeList;
     listOffset = offset;
   }
 }
 
 uint64_t DWARFDebugRngLists::GetOffset(size_t Index) const {
   return Offsets[Index];
 }

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

void DWARFFormValue::Dump(Stream &s) const {
   if (cu_relative_offset) {
     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
                   // unit relative or we will get this wrong
     s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset());
   }
 }
 
 const char *DWARFFormValue::AsCString() const {
-  SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
-
-  if (m_form == DW_FORM_string) {
+  if (m_form == DW_FORM_string)
     return m_value.value.cstr;
-  } else if (m_form == DW_FORM_strp) {
-    if (!symbol_file)
-      return nullptr;
 
+  DWARFContext &context = m_cu->GetDWARFContext();
+  SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
+
+  if (m_form == DW_FORM_strp)
     return symbol_file->get_debug_str_data().PeekCStr(m_value.value.uval);
-  } else if (m_form == DW_FORM_GNU_str_index) {
+
+  if (m_form == DW_FORM_GNU_str_index) {
     if (!symbol_file)
       return nullptr;
 
     uint32_t index_size = 4;
     lldb::offset_t offset = m_value.value.uval * index_size;
     dw_offset_t str_offset =
         symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset,
                                                             index_size);
if (m_form == DW_FORM_strx || m_form == DW_FORM_strx1 ||
     uint32_t indexSize = 4;
     lldb::offset_t offset =
         m_cu->GetStrOffsetsBase() + m_value.value.uval * indexSize;
     dw_offset_t strOffset =
         symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset, indexSize);
     return symbol_file->get_debug_str_data().PeekCStr(strOffset);
   }
 
-  if (m_form == DW_FORM_line_strp)
-    return symbol_file->get_debug_line_str_data().PeekCStr(m_value.value.uval);
+  if (m_form == DW_FORM_line_strp) {
+    const DWARFDataExtractor *extractor = context.getOrLoadDebugLineStrData();
+    if (!extractor)
+      return nullptr;
+
+    return extractor->PeekCStr(m_value.value.uval);
+  }
 
   return nullptr;
 }
 
 dw_addr_t DWARFFormValue::Address() const {
   SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_addr)

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

 #include <atomic>
 
 class DWARFUnit;
 class DWARFCompileUnit;
 class NameToDIE;
 class SymbolFileDWARF;
 class SymbolFileDWARFDwo;
 
+namespace lldb_private {
+class DWARFContext;
+}
+
 typedef std::shared_ptr<DWARFUnit> DWARFUnitSP;
 
 enum DWARFProducer {
   eProducerInvalid = 0,
   eProducerClang,
   eProducerGCC,
   eProducerLLVMGCC,
   eProcucerOther
public:
 
   bool Supports_DW_AT_APPLE_objc_complete_type();
 
   bool DW_AT_decl_file_attributes_are_invalid();
 
   bool Supports_unnamed_objc_bitfields();
 
   SymbolFileDWARF *GetSymbolFileDWARF() const;
+  lldb_private::DWARFContext &GetDWARFContext() const;
 
   DWARFProducer GetProducer();
 
   uint32_t GetProducerVersionMajor();
 
   uint32_t GetProducerVersionMinor();
 
   uint32_t GetProducerVersionUpdate();
public:
   dw_offset_t GetBaseObjOffset() const;
 
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
 protected:
-  DWARFUnit(SymbolFileDWARF *dwarf);
+  DWARFUnit(SymbolFileDWARF *dwarf, lldb_private::DWARFContext &dwarf_context);
 
   SymbolFileDWARF *m_dwarf = nullptr;
+  lldb_private::DWARFContext &m_dwarf_context;
   std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
   const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
   void *m_user_data = nullptr;
   // The compile unit debug information entry item
   DWARFDebugInfoEntry::collection m_die_array;
   mutable llvm::sys::RWMutex m_die_array_mutex;
   // It is used for tracking of ScopedExtractDIEs instances.
   mutable llvm::sys::RWMutex m_die_array_scoped_mutex;

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

 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 extern int g_verbose;
 
-DWARFUnit::DWARFUnit(SymbolFileDWARF *dwarf)
-    : m_dwarf(dwarf), m_cancel_scopes(false) {}
+DWARFUnit::DWARFUnit(SymbolFileDWARF *dwarf, DWARFContext &dwarf_context)
+    : m_dwarf(dwarf), m_dwarf_context(dwarf_context), m_cancel_scopes(false) {}
 
 DWARFUnit::~DWARFUnit() {}
 
 //----------------------------------------------------------------------
 // Parses first DIE of a compile unit.
 //----------------------------------------------------------------------
 void DWARFUnit::ExtractUnitDIEIfNeeded() {
   {
if (GetProducer() == eProducerClang) {
     return major_version > 425 ||
            (major_version == 425 && GetProducerVersionUpdate() >= 13);
   }
   return true; // Assume all other compilers didn't have incorrect ObjC bitfield
                // info
 }
 
 SymbolFileDWARF *DWARFUnit::GetSymbolFileDWARF() const { return m_dwarf; }
+DWARFContext &DWARFUnit::GetDWARFContext() const { return m_dwarf_context; }
 
 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) {

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

public:
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   virtual const lldb_private::DWARFDataExtractor &get_debug_abbrev_data();
   virtual const lldb_private::DWARFDataExtractor &get_debug_addr_data();
-  const lldb_private::DWARFDataExtractor &get_debug_frame_data();
   virtual const lldb_private::DWARFDataExtractor &get_debug_info_data();
-  const lldb_private::DWARFDataExtractor &get_debug_line_data();
-  const lldb_private::DWARFDataExtractor &get_debug_line_str_data();
-  const lldb_private::DWARFDataExtractor &get_debug_macro_data();
-  const lldb_private::DWARFDataExtractor &get_debug_loc_data();
-  const lldb_private::DWARFDataExtractor &get_debug_loclists_data();
-  const lldb_private::DWARFDataExtractor &get_debug_ranges_data();
-  const lldb_private::DWARFDataExtractor &get_debug_rnglists_data();
   virtual const lldb_private::DWARFDataExtractor &get_debug_str_data();
   virtual const lldb_private::DWARFDataExtractor &get_debug_str_offsets_data();
-  const lldb_private::DWARFDataExtractor &get_debug_types_data();
-  const lldb_private::DWARFDataExtractor &get_apple_names_data();
-  const lldb_private::DWARFDataExtractor &get_apple_types_data();
-  const lldb_private::DWARFDataExtractor &get_apple_namespaces_data();
-  const lldb_private::DWARFDataExtractor &get_apple_objc_data();
-  const lldb_private::DWARFDataExtractor &get_gnu_debugaltlink();
 
   DWARFDebugAbbrev *DebugAbbrev();
 
   const DWARFDebugAbbrev *DebugAbbrev() const;
 
   DWARFDebugInfo *DebugInfo();
 
   const DWARFDebugInfo *DebugInfo() const;
 
   DWARFDebugRangesBase *DebugRanges();
 
   const DWARFDebugRangesBase *DebugRanges() const;
 
-  const lldb_private::DWARFDataExtractor &DebugLocData();
-
   static bool SupportedVersion(uint16_t version);
 
   DWARFDIE
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
public:
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 
   static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die);
 
   virtual lldb::CompUnitSP ParseCompileUnit(DWARFUnit *dwarf_cu,
                                             uint32_t cu_idx);
 
   virtual lldb_private::DWARFExpression::LocationListFormat
-  GetLocationListFormat() const;
+  GetLocationListFormat();
 
   lldb::ModuleSP GetDWOModule(lldb_private::ConstString name);
 
   typedef std::map<lldb_private::ConstString, lldb::ModuleSP>
       ExternalTypeModuleMap;
 
   /// Return the list of Clang modules imported by this SymbolFile.
   const ExternalTypeModuleMap& getExternalTypeModules() const {
       return m_external_type_modules;
   }
 
   virtual DWARFDIE GetDIE(const DIERef &die_ref);
 
   virtual std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
+  lldb_private::DWARFContext &GetDWARFContext();
 
   // 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 DWARFUnit *GetBaseCompileUnit();
 
   static bool
   DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
protected:
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::unique_ptr<SymbolFileDWARFDwp> m_dwp_symfile;
 
   lldb_private::DWARFContext m_context;
 
   DWARFDataSegment m_data_debug_abbrev;
   DWARFDataSegment m_data_debug_addr;
-  DWARFDataSegment m_data_debug_frame;
   DWARFDataSegment m_data_debug_info;
-  DWARFDataSegment m_data_debug_line;
-  DWARFDataSegment m_data_debug_line_str;
-  DWARFDataSegment m_data_debug_macro;
-  DWARFDataSegment m_data_debug_loc;
-  DWARFDataSegment m_data_debug_loclists;
-  DWARFDataSegment m_data_debug_ranges;
-  DWARFDataSegment m_data_debug_rnglists;
   DWARFDataSegment m_data_debug_str;
   DWARFDataSegment m_data_debug_str_offsets;
-  DWARFDataSegment m_data_debug_types;
-  DWARFDataSegment m_data_apple_names;
-  DWARFDataSegment m_data_apple_types;
-  DWARFDataSegment m_data_apple_namespaces;
-  DWARFDataSegment m_data_apple_objc;
-  DWARFDataSegment m_data_gnu_debugaltlink;
 
   // The unique pointer items below are generated on demand if and when someone
   // accesses
   // them through a non const version of this class.
   std::unique_ptr<DWARFDebugAbbrev> m_abbr;
   std::unique_ptr<DWARFDebugInfo> m_info;
   std::unique_ptr<DWARFDebugLine> m_line;
   std::unique_ptr<GlobalVariableMap> m_global_aranges_up;

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

 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 
 #include "AppleDWARFIndex.h"
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
+#include "DWARFContext.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"

 
 SymbolFileDWARF::SymbolFileDWARF(ObjectFile *objfile)
     : SymbolFile(objfile), UserID(uint64_t(DW_INVALID_OFFSET)
                                   << 32), // Used by SymbolFileDWARFDebugMap to
                                           // when this class parses .o files to
                                           // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(NULL),
       m_context(*objfile->GetModule()), m_data_debug_abbrev(),
-      m_data_debug_frame(), m_data_debug_info(), m_data_debug_line(),
-      m_data_debug_macro(), m_data_debug_loc(), m_data_debug_ranges(),
-      m_data_debug_rnglists(), m_data_debug_str(), m_data_apple_names(),
-      m_data_apple_types(), m_data_apple_namespaces(), m_abbr(), m_info(),
-      m_line(), m_fetched_external_modules(false),
+      m_data_debug_info(), m_data_debug_str(), m_abbr(), m_info(), m_line(),
+      m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(),
       m_unique_ast_type_map() {}
 
 SymbolFileDWARF::~SymbolFileDWARF() {}
 
 static ConstString GetDWARFMachOSegmentName() {
   static ConstString g_dwarf_section_name("__DWARF");
   return g_dwarf_section_name;
const DWARFDataExtractor &SymbolFileDWARF::get_debug_abbrev_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugAbbrev,
                               m_data_debug_abbrev);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_addr_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugAddr, m_data_debug_addr);
 }
 
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_frame_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugFrame, m_data_debug_frame);
-}
-
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_info_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugInfo, m_data_debug_info);
 }
 
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugLine, m_data_debug_line);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_str_data() {
- return GetCachedSectionData(eSectionTypeDWARFDebugLineStr, m_data_debug_line_str);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_macro_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugMacro, m_data_debug_macro);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::DebugLocData() {
-  const DWARFDataExtractor &debugLocData = get_debug_loc_data();
-  if (debugLocData.GetByteSize() > 0)
-    return debugLocData;
-  return get_debug_loclists_data();
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_loc_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugLoc, m_data_debug_loc);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_loclists_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugLocLists,
-                              m_data_debug_loclists);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_ranges_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugRanges,
-                              m_data_debug_ranges);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_rnglists_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugRngLists,
-                              m_data_debug_rnglists);
-}
-
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_str_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugStr, m_data_debug_str);
 }
 
 const DWARFDataExtractor &SymbolFileDWARF::get_debug_str_offsets_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugStrOffsets,
                               m_data_debug_str_offsets);
 }
 
-const DWARFDataExtractor &SymbolFileDWARF::get_debug_types_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugTypes, m_data_debug_types);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_apple_names_data() {
-  return GetCachedSectionData(eSectionTypeDWARFAppleNames, m_data_apple_names);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_apple_types_data() {
-  return GetCachedSectionData(eSectionTypeDWARFAppleTypes, m_data_apple_types);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_apple_namespaces_data() {
-  return GetCachedSectionData(eSectionTypeDWARFAppleNamespaces,
-                              m_data_apple_namespaces);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_apple_objc_data() {
-  return GetCachedSectionData(eSectionTypeDWARFAppleObjC, m_data_apple_objc);
-}
-
-const DWARFDataExtractor &SymbolFileDWARF::get_gnu_debugaltlink() {
-  return GetCachedSectionData(eSectionTypeDWARFGNUDebugAltLink,
-                              m_data_gnu_debugaltlink);
-}
-
 DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
   if (m_abbr)
     return m_abbr.get();
 
   const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data();
   if (debug_abbrev_data.GetByteSize() == 0)
     return nullptr;
 

 }
 
 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 (get_debug_ranges_data().GetByteSize() > 0)
-      m_ranges.reset(new DWARFDebugRanges());
-    else if (get_debug_rnglists_data().GetByteSize() > 0)
-      m_ranges.reset(new DWARFDebugRngLists());
+    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_ranges->Extract(this, m_context);
   }
   return m_ranges.get();
 }
 
 const DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() const {
   return m_ranges.get();
 }
 
size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
   // FixupTypes();
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
                                         FileSpecList &support_files) {
   ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
-  if (dwarf_cu) {
-    const DWARFBaseDIE cu_die = dwarf_cu->GetUnitDIEOnly();
+  if (!dwarf_cu)
+    return false;
 
-    if (cu_die) {
-      const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
-          DW_AT_stmt_list, DW_INVALID_OFFSET);
-      if (stmt_list != DW_INVALID_OFFSET) {
-        // All file indexes in DWARF are one based and a file of index zero is
-        // supposed to be the compile unit itself.
-        support_files.Append(comp_unit);
-        return DWARFDebugLine::ParseSupportFiles(
-            comp_unit.GetModule(), get_debug_line_data(), stmt_list,
-            support_files, dwarf_cu);
-      }
-    }
-  }
+  if (!cu_die)
+    return false;
+
+  const dw_offset_t stmt_list =
+      cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET);
+  if (stmt_list == DW_INVALID_OFFSET)
+    return false;
+  const DWARFDataExtractor *debug_line = m_context.getOrLoadDebugLineData();
+  if (!debug_line)
     return false;
+
+  return DWARFDebugLine::ParseSupportFiles(comp_unit.GetModule(), *debug_line,
+                                           stmt_list, support_files, dwarf_cu);
 }
 
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;

 }
 
 bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   if (comp_unit.GetLineTable() != NULL)
     return true;
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
-  if (dwarf_cu) {
-    const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
-    if (dwarf_cu_die) {
-      const dw_offset_t cu_line_offset =
-          dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
-                                                   DW_INVALID_OFFSET);
-      if (cu_line_offset != DW_INVALID_OFFSET) {
-        std::unique_ptr<LineTable> line_table_up(new LineTable(&comp_unit));
-        if (line_table_up) {
-          ParseDWARFLineTableCallbackInfo info;
-          info.line_table = line_table_up.get();
+  if (!dwarf_cu)
+    return false;
+
+    const dw_offset_t cu_line_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(
+        DW_AT_stmt_list, DW_INVALID_OFFSET);
+    if (cu_line_offset == DW_INVALID_OFFSET)
+      return false;
+
+    if (!line_table_up)
+      return false;
+
 
-          /*
-           * MIPS:
-           * The SymbolContext may not have a valid target, thus we may not be
-           * able
-           * to call Address::GetOpcodeLoadAddress() which would clear the bit
-           * #0
-           * for MIPS. Use ArchSpec to clear the bit #0.
-          */
-          switch (GetObjectFile()->GetArchitecture().GetMachine()) {
-          case llvm::Triple::mips:
-          case llvm::Triple::mipsel:
-          case llvm::Triple::mips64:
-          case llvm::Triple::mips64el:
-            info.addr_mask = ~((lldb::addr_t)1);
-            break;
-          default:
-            info.addr_mask = ~((lldb::addr_t)0);
-            break;
-          }
 
-          lldb::offset_t offset = cu_line_offset;
-          DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset,
-                                              ParseDWARFLineTableCallback,
-                                              &info, dwarf_cu);
-          SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
-          if (debug_map_symfile) {
-            // We have an object file that has a line table with addresses that
-            // are not linked. We need to link the line table and convert the
-            // addresses that are relative to the .o file into addresses for
-            // the main executable.
-            comp_unit.SetLineTable(
-                debug_map_symfile->LinkOSOLineTable(this, line_table_up.get()));
-          } else {
-            comp_unit.SetLineTable(line_table_up.release());
-            return true;
-          }
-        }
-      }
-    }
-  }
+    const DWARFDataExtractor *debug_line = m_context.getOrLoadDebugLineData();
+    if (!debug_line)
+      return false;
+
+    DWARFDebugLine::ParseStatementTable(
+        *debug_line, &offset, ParseDWARFLineTableCallback, &info, dwarf_cu);
+
   return false;
 }
 
 lldb_private::DebugMacrosSP
 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
   auto iter = m_debug_macros_map.find(*offset);
   if (iter != m_debug_macros_map.end())
     return iter->second;
 
-  const DWARFDataExtractor &debug_macro_data = get_debug_macro_data();
-  if (debug_macro_data.GetByteSize() == 0)
-    return DebugMacrosSP();
+  const DWARFDataExtractor *debug_macro_data =
+      m_context.getOrLoadDebugMacroData();
+  if (!debug_macro_data)
+    return nullptr;
 
   lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
   m_debug_macros_map[*offset] = debug_macros_sp;
 
   const DWARFDebugMacroHeader &header =
-      DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
-  DWARFDebugMacroEntry::ReadMacroEntries(debug_macro_data, get_debug_str_data(),
-                                         header.OffsetIs64Bit(), offset, this,
-                                         debug_macros_sp);
+      DWARFDebugMacroHeader::ParseHeader(*debug_macro_data, offset);
+  DWARFDebugMacroEntry::ReadMacroEntries(
+      *debug_macro_data, get_debug_str_data(), header.OffsetIs64Bit(), offset,
+      this, debug_macros_sp);
 
   return debug_macros_sp;
 }
 
 bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
       FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,
       dwo_file_data_offset);
   if (dwo_obj_file == nullptr)
     return nullptr;
 
   return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu);
 }
 
+DWARFContext &SymbolFileDWARF::GetDWARFContext() { return m_context; }
+
 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
   if (m_fetched_external_modules)
     return;
   m_fetched_external_modules = true;
 
   DWARFDebugInfo *debug_info = DebugInfo();
 
   const uint32_t num_compile_units = GetNumCompileUnits();
if (num_attributes > 0) {
             if (DWARFFormValue::IsBlockForm(form_value.Form())) {
               auto data = die.GetData();
 
               uint32_t block_offset =
                   form_value.BlockData() - data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
               location.CopyOpcodeData(module, data, block_offset, block_length);
             } else {
-              const DWARFDataExtractor &debug_loc_data = DebugLocData();
+              const DWARFDataExtractor *debug_loc_data =
+                  m_context.getOrLoadBestDebugLocData();
+              if (!debug_loc_data)
+                break;
+
               const dw_offset_t debug_loc_offset = form_value.Unsigned();
 
               size_t loc_list_length = DWARFExpression::LocationListSize(
-                  die.GetCU(), debug_loc_data, debug_loc_offset);
+                  die.GetCU(), *debug_loc_data, debug_loc_offset);
               if (loc_list_length > 0) {
-                location.CopyOpcodeData(module, debug_loc_data,
+                location.CopyOpcodeData(module, *debug_loc_data,
                                         debug_loc_offset, loc_list_length);
                 assert(func_low_pc != LLDB_INVALID_ADDRESS);
                 location.SetLocationListSlide(
                     func_low_pc -
                     attributes.CompileUnitAtIndex(i)->GetBaseAddress());
               }
             }
           } break;
if (module_sp) {
       if (sym_vendor)
         m_debug_map_symfile =
             (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
     }
   }
   return m_debug_map_symfile;
 }
 
-DWARFExpression::LocationListFormat
-SymbolFileDWARF::GetLocationListFormat() const {
-  if (m_data_debug_loclists.m_data.GetByteSize() > 0)
+DWARFExpression::LocationListFormat SymbolFileDWARF::GetLocationListFormat() {
+  if (m_context.getOrLoadDebugLoclistData())
     return DWARFExpression::LocLists;
   return DWARFExpression::RegularLocationList;
 }
 
 SymbolFileDWARFDwp *SymbolFileDWARF::GetDwpSymbolFile() {
   llvm::call_once(m_dwp_symfile_once_flag, [this]() {
     ModuleSpec module_spec;
     module_spec.GetFileSpec() = m_obj_file->GetFileSpec();

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

lldb::CompUnitSP ParseCompileUnit(DWARFUnit *dwarf_cu,
                                     uint32_t cu_idx) override;
 
   DWARFUnit *GetCompileUnit();
 
   DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
 
   lldb_private::DWARFExpression::LocationListFormat
-  GetLocationListFormat() const override;
+  GetLocationListFormat() override;
 
   size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                  DIEArray &method_die_offsets) override;
 
   lldb_private::TypeSystem *
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE

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

return GetCachedSectionData(eSectionTypeDWARFDebugStrOffsetsDwo,
                               m_data_debug_str_offsets);
 }
 
 SymbolFileDWARF *SymbolFileDWARFDwo::GetBaseSymbolFile() {
   return m_base_dwarf_cu->GetSymbolFileDWARF();
 }
 
 DWARFExpression::LocationListFormat
-SymbolFileDWARFDwo::GetLocationListFormat() const {
+SymbolFileDWARFDwo::GetLocationListFormat() {
   return DWARFExpression::SplitDwarfLocationList;
 }
 
 TypeSystem *
 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
   return GetBaseSymbolFile()->GetTypeSystemForLanguage(language);
 }
 
 DWARFDIE
 SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
   lldbassert(m_base_dwarf_cu->GetOffset() == die_ref.cu_offset);
   return DebugInfo()->GetDIEForDIEOffset(die_ref.die_offset);
 }