[SymbolFileDWARF] Introduce DWARFContext

[zturner]

Summary

LLVM's DWARF parsing library has a class called DWARFContext which holds all of the various DWARF data sections and lots of other information. LLDB's on the other hand stores all of this directly in SymbolFileDWARF / SymbolFileDWARFDwo and passes this interface around through the parsing library. Obviously this is incompatible with a world where the low level interface does not depend on the high level interface, so we need to move towards a model similar to LLVM's - i.e. all of the context needed for low level parsing should be in a single class, and that class gets passed around.

This patch is a small incremental step towards achieving this. The interface and internals deviate from LLVM's for technical reasons, but the high level idea is the same. The goal is, eventually, to remove all occurrences of SymbolFileDWARF from the low level parsing code.

For now I've chosen a very simple section - the .debug_aranges section to move into DWARFContext while leaving everything else unchanged. In the short term this is a bit confusing because now the information you need might come from either of 2 different locations. But it's a huge refactor to do this all at once and runs a much higher risk of breaking things. So I think it would be wise to do this in very small pieces.

TL;DR - No functional change

[JDevlieghere]

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

30 ↗

(On Diff #191393)

Why do we need these two methods? I presume it's because one does work and the other doesn't? If I understand the code correctly, LoadOrGetSection will initialize the optional, so could you just check the optional to determine where we should try to do work or not?

[zturner]

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

30 ↗

(On Diff #191393)

It's because one of them is const and a const version of the function cannot do any work. It's possible we won't ever need this, and we'll always want a "get or create" function, but i can imagine scenarios where we have a const reference or const pointer.

This is always a problem with these lazy type interfaces, because in that case should you actually use const_cast or should you just fail and return nullptr? It's a tough call. I chose to explicitly embed into the name whether the function was doing work (e.g. maybeLoad) versus being purely a getter that will never do work (e.g. get).

[JDevlieghere]

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

30 ↗

(On Diff #191393)

Aha, I missed that. nit about the name: how about getArangesData and getOrLoadArangesData

[zturner]

I went ahead and just removed the const get version entirely, while changing the other function name to getOrLoad as you suggested. I have another patch while I'll upload after this one that converts all of the rest of the functions (except for the virtual ones required for DWO support), and the const version of the function was literally never needed, except in one place that was itself dead code. So, in the spirit of YAGNI, it's gone until it demonstrates a need.

[JDevlieghere]

LGTM!

[probinson]

I remember LLVM's DWARFContext being irritating to deal with when I was doing the DWARF 5 stuff. The exact details have been swapped out of my memory, but I suspect it had something to do with needing to know whether I was in DWO mode or normal mode in order to snag the right section for some sort of cross-section lookup. This is because DWARFContext is the dumping ground for all the sections, regardless of what kind of file we're looking at, and it's up to the user of its interfaces to know what mode it's in.
I will admit that having one dumping ground is convenient in some ways, especially when we were looking at object files that contained a mix of both normal and .dwo sections, but IIRC we don't emit mixed-mode object files anymore.

Not objecting to this patch, but it was the most convenient place to raise this particular grump, and something to think about as you progress.

[labath]

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

28 ↗

(On Diff #191421)

Don't want to block progress here over this, but I just wanted to say that my impression was that this DwarfData business was a relict from the time when we re not mmapping the input object files. These days, we always mmap the input, and so I don't believe that should be necessary because ObjectFileMachO will automatically perform the DataBuffer slicing that you're doing here manually as a part of ReadSectionData.

Maybe one of the Apple folks could check whether this is really needed, because if it isn't, it will make your job easier here, as well as produce an API that is more similar to its llvm counterpart.

[clayborg]

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

17 ↗

(On Diff #191421)

is "mapped_dwarf_data" actually the entire file mmap'ed? If so rename this to "mapped_file_data"?

40 ↗

(On Diff #191421)

Use:

lldb::offset_t Section::GetSectionData(DataExtractor &data);

We might want to make the ObjectFile::ReadSectionData private so people don't use it and add a doxygen comment to use the above API in Section?

46–49 ↗

(On Diff #191421)

Again, is this the entire file that is mapped?

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

21 ↗

(On Diff #191421)

What does m_dwarf_data contain? The entire file? Just the __DWARF segment for mach-o?

28 ↗

(On Diff #191421)

We don't always mmap. We mmap if the file is local. We read the entire file if the file is on a network drive. If we don't do this and we mmap a NFS file, and that mount goes away, we crash the next time we access a page that hasn't been paged in. So we don't know if stuff is actually mmap'ed or not.

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

41 ↗

(On Diff #191421)

Store as a reference maybe? We must assume that the DWARFContext will be alive as long as this class is around. We would need to supply this in the constructor then. Is that possible?

70 ↗

(On Diff #191421)

Be nice if this can be a reference and be set in the ctor

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

690–691 ↗

(On Diff #191421)

m_info.reset(new DWARFDebugInfo(m_dwarf_context));

693 ↗

(On Diff #191421)

revert

[labath]

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

28 ↗

(On Diff #191421)

Yeah, I wasn't being fully correct here, but this distinction does not really matter here. Even if we don't mmap, we will end up with a full image of the file in memory, so anybody can slice any chunk of that file as he sees fit. Since ObjectFileMachO::ReadSectionData already implements this slicing, there's no advantage in slicing manually here.

[zturner]

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

17 ↗

(On Diff #191421)

It's the contents of the __DWARF segment on MachO, unless my reading of the old code is wrong.

In the old code, SymbolFileDWARF would try to read this segment, and if it existed set it to SymbolFileDWARF::m_dwarf_data. Then, the ReadCachedSectionData function would first check if this member had data in it, and if so read the data from there instead of from the ObjectFile.

In this modified version of the patch, I call SetDwarfData with the contents of this section, then pass it through to this function so that we can perform the same logic.

40 ↗

(On Diff #191421)

Yes, I like that better. Thanks for pointing it out.

46–49 ↗

(On Diff #191421)

As mentioned elsewhere, this is the contents of __DWARF, which I didn't understand the purpose of, so I was hesitant to make any drastic changes. Perhaps you could clarify the significance of it now though and perhaps suggest an alternative approach to what we're doing here.

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

28 ↗

(On Diff #191421)

The parameter here represents the content of the __DWARF data segment on MachO. I don't really know what this is for or the implications of removing it, so for now I left it identical to the original code with NFC, and planned on addressing this in the future.

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

70 ↗

(On Diff #191421)

Fair enough, I kept it as a pointer for parity with SymbolFileDWARF* m_dwarf2Data, but a reference is definitely better.

[clayborg]

We can get rid of the m_dwarf_data all together. As Pavel suggested, we used to not mmap the entire file, and now we do most of the time. The Section::GetSectionData() will ref count the mmap data in the data extractor and use the mmap already, so we should only support grabbing the contents via the Section::GetSectionData() and don't propagate this legacy code in the new DWARFContext.

[clayborg]

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

17 ↗

(On Diff #191421)

remove "mapped_dwarf_data" arg

34–38 ↗

(On Diff #191421)

remove

46–49 ↗

(On Diff #191421)

remove

50 ↗

(On Diff #191421)

rename to "getArangesData()"? Would it be better to return an Optional<DWARFDataExtractor>?

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

21 ↗

(On Diff #191421)

Remove this now that we don't need it since Section::GetSectionData() will do the right thing already.

28 ↗

(On Diff #191421)

We can get rid of this after thinking about this.

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

404–407 ↗

(On Diff #191421)

Get rid of m_dwarf_data now that we don't need it? That will make subsequent patches easier.

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

461 ↗

(On Diff #191421)

"m_dwarf_ctx" to keep it shorter? Or just "m_ctx"?

[zturner]

Updated based on suggestions, including removal of the m_dwarf_data member variable which holds the contents of the __DWARF segment on MachO.

[clayborg]

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

24 ↗

(On Diff #191510)

Don't we want to put an empty DWARFDataExtractor in here? Maybe this code should be:

const SectionList *section_list = module.GetSectionList();
  if (!section_list)
    return nullptr;

  auto section_sp = section_list->FindSectionByType(section_type, true);
  if (!section_sp)
    return nullptr;

  extractor.emplace();
  if (section_sp->GetSectionData(*extractor) == 0)
    extractor = llvm::None;
  return extractor.getPointer();

40 ↗

(On Diff #191510)

Why do we care about "getOrLoadArangesData()"? What not just "getArangesData()"?

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

552 ↗

(On Diff #191510)

if (m_obj_file->ReadSectionData(section_sp.get(), data) == 0)
  data.Clear();

[clayborg]

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

24 ↗

(On Diff #191510)

Or use a local DWARFDataExtractor and move it into "extractor" if we succeed?

DWARFDataExtractor data;
if (section_sp->GetSectionData(data) > 0)
    extractor = std::move(data);

[zturner]

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

50 ↗

(On Diff #191421)

I actually prefer to keep the name as getOrLoad. get functions often sound like they don't modify anything, but this way it's clear that lazy evaluation will occur, which might be important to the caller for some reason or another.

24 ↗

(On Diff #191510)

The suggested code here has a bug. If you say

extractor = llvm::None;
return extractor.getPointer();

it will assert, because there is no pointer, it's uninitialized. When i write extractor.emplace(); it initializes it with a default constructed DataExtractor, the idea being that if we try this function and it fails for any reason, we should not try the function again, because it already failed once, and so we should just "cache" the fact that it failed and immediately return. By having a default constructed DataExtractor and changing the fast path exit condition to also return null in the case where the size is 0, we ensure that we only ever do work once, regardless of whether that work fails or succeeds.

40 ↗

(On Diff #191510)

I like to emphasize in the name that the function might do work. People are trained to think of get functions as read-only, but it's not the case here and so the idea is to make sure that nobody can misinterpret the behavior.

[clayborg]

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

552 ↗

(On Diff #191510)

What do you think about this one? This is my last nit

[zturner]

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

552 ↗

(On Diff #191510)

I did see that one, but I was having trouble figuring out how the behavior is different from what I already wrote. The only way I could see it being different is if ReadSectionData would actually write data there even when it failed. That would be strange though, do you know if it can happen?

The way I wrote it, it clears first, and then if the function fails / returns 0, I would expect it to be unchanged.

Happy to change it if there's actually a difference I'm overlooking, but if they're the same then I think the branchless version is slightly easier to read.

[clayborg]

The suggestion just avoids the Clear() call at the expense of a branch. No big deal. Fine either way.

lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   AppleDWARFIndex.cpp
   DebugNamesDWARFIndex.cpp
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFAttribute.cpp
   DWARFBaseDIE.cpp
   DWARFCompileUnit.cpp
+  DWARFContext.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugAranges.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugInfo.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugMacro.cpp

lldb/trunk/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>
+
+namespace lldb_private {
+class DWARFContext {
+private:
+  Module &m_module;
+  llvm::Optional<DWARFDataExtractor> m_data_debug_aranges;
+
+public:
+  explicit DWARFContext(Module &module);
+
+  const DWARFDataExtractor *getOrLoadArangesData();
+};
+} // 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 *
+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();
+
+  const SectionList *section_list = module.GetSectionList();
+  if (!section_list)
+    return nullptr;
+
+  auto section_sp = section_list->FindSectionByType(section_type, true);
+  if (!section_sp)
+    return nullptr;
+
+  section_sp->GetSectionData(*extractor);
+  return extractor.getPointer();
+}
+
+DWARFContext::DWARFContext(Module &module) : m_module(module) {}
+
+const DWARFDataExtractor *DWARFContext::getOrLoadArangesData() {
+  return LoadOrGetSection(m_module, eSectionTypeDWARFDebugAranges,
+                          m_data_debug_aranges);
+}

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

 
 #include "DWARFDIE.h"
 #include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 #include "lldb/Core/STLUtils.h"
 #include "lldb/lldb-private.h"
 #include "llvm/Support/Error.h"
 
+namespace lldb_private {
+class DWARFContext;
+}
+
 typedef std::multimap<const char *, dw_offset_t, CStringCompareFunctionObject>
     CStringToDIEMap;
 typedef CStringToDIEMap::iterator CStringToDIEMapIter;
 typedef CStringToDIEMap::const_iterator CStringToDIEMapConstIter;
 
 class DWARFDebugInfo {
 public:
   typedef dw_offset_t (*Callback)(SymbolFileDWARF *dwarf2Data,
                                   DWARFUnit *cu,
                                   DWARFDebugInfoEntry *die,
                                   const dw_offset_t next_offset,
                                   const uint32_t depth, void *userData);
 
-  DWARFDebugInfo();
+  explicit DWARFDebugInfo(lldb_private::DWARFContext &context);
   void SetDwarfData(SymbolFileDWARF *dwarf2Data);
 
   size_t GetNumCompileUnits();
   DWARFUnit *GetCompileUnitAtIndex(uint32_t idx);
   DWARFUnit *GetCompileUnit(dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
   DWARFUnit *GetCompileUnitContainingDIEOffset(dw_offset_t die_offset);
   DWARFUnit *GetCompileUnit(const DIERef &die_ref);
   DWARFDIE GetDIEForDIEOffset(dw_offset_t die_offset);
static bool OffsetLessThanCompileUnitOffset(dw_offset_t offset,
                                               const DWARFUnitSP &cu_sp);
 
   typedef std::vector<DWARFUnitSP> CompileUnitColl;
 
   //----------------------------------------------------------------------
   // Member variables
   //----------------------------------------------------------------------
   SymbolFileDWARF *m_dwarf2Data;
+  lldb_private::DWARFContext &m_context;
   CompileUnitColl m_compile_units;
   std::unique_ptr<DWARFDebugAranges>
       m_cu_aranges_up; // A quick address to compile unit table
 
 private:
   // All parsing needs to be done partially any managed by this class as
   // accessors are called.
   void ParseCompileUnitHeadersIfNeeded();
 
   DISALLOW_COPY_AND_ASSIGN(DWARFDebugInfo);
 };
 
 #endif // SymbolFileDWARF_DWARFDebugInfo_h_

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

 #include <set>
 
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 
 #include "DWARFCompileUnit.h"
-#include "DWARFDebugAranges.h"
+#include "DWARFContext.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFFormValue.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
-DWARFDebugInfo::DWARFDebugInfo()
-    : m_dwarf2Data(NULL), m_compile_units(), m_cu_aranges_up() {}
+DWARFDebugInfo::DWARFDebugInfo(lldb_private::DWARFContext &context)
+    : m_dwarf2Data(NULL), m_context(context), m_compile_units(),
+      m_cu_aranges_up() {}
 
 //----------------------------------------------------------------------
 // SetDwarfData
 //----------------------------------------------------------------------
 void DWARFDebugInfo::SetDwarfData(SymbolFileDWARF *dwarf2Data) {
   m_dwarf2Data = dwarf2Data;
   m_compile_units.clear();
 }
 
 llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
   if (m_cu_aranges_up)
     return *m_cu_aranges_up;
 
   assert(m_dwarf2Data);
 
   m_cu_aranges_up = llvm::make_unique<DWARFDebugAranges>();
-  const DWARFDataExtractor &debug_aranges_data =
-      m_dwarf2Data->get_debug_aranges_data();
-  if (debug_aranges_data.GetByteSize() > 0) {
-    llvm::Error error = m_cu_aranges_up->extract(debug_aranges_data);
+  const DWARFDataExtractor *debug_aranges_data =
+      m_context.getOrLoadArangesData();
+  if (debug_aranges_data) {
+    llvm::Error error = m_cu_aranges_up->extract(*debug_aranges_data);
     if (error)
       return std::move(error);
   }
 
   // Make a list of all CUs represented by the arange data in the file.
   std::set<dw_offset_t> cus_with_data;
   for (size_t n = 0; n < m_cu_aranges_up->GetNumRanges(); n++) {
     dw_offset_t offset = m_cu_aranges_up->OffsetAtIndex(n);

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

 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
 
+#include "DWARFContext.h"
 #include "DWARFDataExtractor.h"
 #include "DWARFDefines.h"
 #include "DWARFIndex.h"
 #include "UniqueDWARFASTType.h"
 
 //----------------------------------------------------------------------
 // Forward Declarations for this DWARF plugin
 //----------------------------------------------------------------------
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_aranges_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();
protected:
   SymbolFileDWARFDwp *GetDwpSymbolFile();
 
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::unique_ptr<SymbolFileDWARFDwp> m_dwp_symfile;
 
-  lldb_private::DWARFDataExtractor m_dwarf_data;
+  lldb_private::DWARFContext m_context;
 
   DWARFDataSegment m_data_debug_abbrev;
   DWARFDataSegment m_data_debug_addr;
-  DWARFDataSegment m_data_debug_aranges;
   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;

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

SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) {
   return DWARFDIE();
 }
 
 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_data_debug_abbrev(),
-      m_data_debug_aranges(), 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_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_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;
if (debug_map_symfile) {
     if (type_system)
       type_system->SetSymbolFile(this);
   }
   return type_system;
 }
 
 void SymbolFileDWARF::InitializeObject() {
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
-  ModuleSP module_sp(m_obj_file->GetModule());
-  if (module_sp) {
-    const SectionList *section_list = module_sp->GetSectionList();
-    Section *section =
-        section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
-
-    if (section)
-      m_obj_file->ReadSectionData(section, m_dwarf_data);
-  }
 
   if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
     DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
     LoadSectionData(eSectionTypeDWARFAppleNames, apple_names);
     LoadSectionData(eSectionTypeDWARFAppleNamespaces, apple_namespaces);
     LoadSectionData(eSectionTypeDWARFAppleTypes, apple_types);
     LoadSectionData(eSectionTypeDWARFAppleObjC, apple_objc);
 
SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
   });
   return data_segment.m_data;
 }
 
 void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
                                       DWARFDataExtractor &data) {
   ModuleSP module_sp(m_obj_file->GetModule());
   const SectionList *section_list = module_sp->GetSectionList();
-  if (section_list) {
-    SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
-    if (section_sp) {
-      // See if we memory mapped the DWARF segment?
-      if (m_dwarf_data.GetByteSize()) {
-        data.SetData(m_dwarf_data, section_sp->GetOffset(),
-                     section_sp->GetFileSize());
-      } else {
-        if (m_obj_file->ReadSectionData(section_sp.get(), data) == 0)
-          data.Clear();
-      }
-    }
-  }
+  if (!section_list)
+    return;
+
+  if (!section_sp)
+    return;
+
+  m_obj_file->ReadSectionData(section_sp.get(), data);
 }
 
 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_aranges_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugAranges,
-                              m_data_debug_aranges);
-}
-
 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);
 }
 

 }
 
 DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
   if (m_info == 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_info_data().GetByteSize() > 0) {
-      m_info.reset(new DWARFDebugInfo());
-      if (m_info) {
-        m_info->SetDwarfData(this);
-      }
-    }
-  }
+      m_info = llvm::make_unique<DWARFDebugInfo>(m_context);
   return m_info.get();
 }
 
 const DWARFDebugInfo *SymbolFileDWARF::DebugInfo() const {
   return m_info.get();
 }
 
 DWARFUnit *

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

 
 void SymbolFileDWARFDwo::LoadSectionData(lldb::SectionType sect_type,
                                          DWARFDataExtractor &data) {
   const SectionList *section_list =
       m_obj_file->GetSectionList(false /* update_module_section_list */);
   if (section_list) {
     SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
     if (section_sp) {
-      // See if we memory mapped the DWARF segment?
-      if (m_dwarf_data.GetByteSize()) {
-        data.SetData(m_dwarf_data, section_sp->GetOffset(),
-                     section_sp->GetFileSize());
-        return;
-      }
 
       if (m_obj_file->ReadSectionData(section_sp.get(), data) != 0)
         return;
 
       data.Clear();
     }
   }