02/03: Contiguous sections (.debug_info+.debug_types) for D54670==D32167 (.debug_types)

[jankratochvil]

Summary

A different trivial approach is to use the mmapped memory range <.debug_info ... garbage ... .debug_types>, then no dispatching is needed and it has no performance impact.
With this patch one could revert the new GetData() from D46606 but the code may be cleaner with it anyway. It is just no longer needed to be virtual so this patch removes its virtuality.
The core is new SymbolFileDWARF::get_debug_info_data().

It has no regressions.

That new class and inheritance of SectionReader (ObjectFileELF::SectionReaderCompressed, ObjectFileJIT::SectionReaderJIT) copying inheritance of ObjectFile' is there because SectionReader` may have local state (such as Decompressor) which is needed for each Section. Additionally ObjectFileELF may contain both uncompressed and compressed sections so it can choose the proper class for instantiation.

[clayborg]

Overall I am ok with minimal regression in speed if a few percent is all that it is costing us. I am generally ok with this patch. A few questions below.

Is there a reason we need DWARFConcatenatingDataExtractor? Can we just put all functionality into DWARFDataExtractor? Then the only place we need to modify if the place that parses the old CU and the type units from .debug_types.

Also is there a reason we need to pass the block data in code such as:

const DWARFDataExtractor &debug_info_data = die.GetData().GetDWARFDataExtractor(form_value.BlockData());

[jankratochvil]

In D51578#1233518, @clayborg wrote:

Is there a reason we need DWARFConcatenatingDataExtractor? Can we just put all functionality into DWARFDataExtractor?

OK, I will try it that way.

Also is there a reason we need to pass the block data in code such as:

const DWARFDataExtractor &debug_info_data = die.GetData().GetDWARFDataExtractor(form_value.BlockData());

EDIT: This case cannot be solved transparently as DWARFConcatenatingDataExtractor (no matter how it is called) has discontiguous data. Existing code does not expect that:

uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();

What should be GetDataStart() for a discontiguous set of memory data areas?
Still I will try to refactor it named DWARFDataExtractor but this specific change may need to remain there.

I am sorry I will be now for 2 weeks away.

[jankratochvil]

Patch concat = original posting with DWARFConcatenatingDataExtractor used only for .debug_info(+.debug_types) section. download
Patch concat2 = used DWARFDataExtractor with integrated concatenation for all DWARF sections. download

master  real=0.996s user=14.744s sys=1.050s
concat  real=0.994s user=15.524s sys=1.117s
concat2 real=1.001s user=15.580s sys=1.334s

concat vs. concat2 benchmark difference was mostly a measurement error. It is now 5% slowdown compared to trunk - even for former concat which I do not understand now, I will investigate it more as my original measured slowdown was just 1% before.
concat2 sometimes needs to cast DWARFDataExtractor to DataExtractor by .AsDataExtractor() as some functions expected a contiguous block of memory. That is a method applicable only for non-.debug_info sections (it would assert on .debug_info). It needs to be called as DWARFDataExtractor can no longer inherit DataExtractor. I did not use operator DataExtractor & as it could accidentally by applied to .debug_info which may be difficult to catch when not tested with -fdebug-types-section.
DataExtractorConcat is a separate class but it is never used separately without DWARFDataExtractor inheriting it.
Greg, do you mean it somehow way or do I miss something? Personally I may like a bit more concat but then the patch size is almost the same for both.

[jankratochvil]

I got an idea to try making the .debug_info+.debug_types memory contiguous. It cannot be mmapped then but LLDB does not seem to do that now anyway (except maybe MachO but despite some comment I haven't found a mmap() even there). Besides that there could be even .debug_info+gap+.debug_types layout.

[clayborg]

Just a few nits, but _very_ close.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

65 ↗

(On Diff #172549)

Use llvm::DenseMap here?

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

797 ↗

(On Diff #172549)

Should this just be "if (GetUnitDIEOnly().Tag() != DW_TAG_type_unit)"? Partial units and many others can be top level DIEs.

[jankratochvil]

There is a _dwarf -> _dwarf_type_units regression for: -f TestCppTypeLookup.test_namespace_only_dwarf_type_units

./bin/clang -o 1 ../llvm-git/tools/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/main.cpp -g -fdebug-types-section;./bin/lldb -o 'settings set target.experimental.inject-local-vars false' -o 'target create "./1"' -o 'b 66' -o r -o 'p *((in_contains_type *)&i)'

Expected:

(lldb) p *((in_contains_type *)&i)
error: use of undeclared identifier 'in_contains_type'
error: expected expression

Actual:

(lldb) p *((in_contains_type *)&i)
(in_contains_type) $0 = (aaa = 123)

I will check it more.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

65 ↗

(On Diff #172549)

Yes, I agree that is a good idea - changed it (BTW this is your part of the patch).

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

797 ↗

(On Diff #172549)

When you ask then I disagree. Currently GetAsCompileUnit() is used only for checking DW_TAG_partial_unit::DW_AT_name (from D11003) which is never present in files by DWZ tool. DWZ tool never puts DIEs referencing any code into DW_TAG_partial_unit so D11003 should not be needed; although DWZ intentionally sometimes uses DW_TAG_partial_unit::DW_AT_stmt_list but I haven't found when/how it could be useful.
> many others
Top level DIEs can be according to DWARF-5 7.5 just DW_TAG_compile_unit, DW_TAG_partial_unit or DW_TAG_type_unit.
So personally I would keep GetAsCompileUnit() to do what its name exactly says.

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

65 ↗

(On Diff #173535)

yeah, I kept getting people commenting on my patches that told me to use DenseMap and StringMap!

[jankratochvil]

I have left here only the sections concatenation. The .debug_types itself by Greg Clayton is now updated on top of this patch in D32167.

[jankratochvil]

Updated against trunk due to new getSectionType from rL348936.

[jankratochvil]

This update fixes a regression after D52403, the code is simplified - eSectionTypeDWARFDebugInfo is no longer hardcoded in this patch.

OK for check-in with this new code?

[clayborg]

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

707–721

So if we have 3GB of .debug_info and 1GB of .debug_types, we are expecting to allocate a heap based buffer and copy all the data into this? This will fail.

[jankratochvil]

So if we have 3GB of .debug_info and 1GB of .debug_types, we are expecting to allocate a heap based buffer and copy all the data into this? This will fail.

That fallback code path is used only when there is no way to access .debug_info and .debug_types from mmapped area. I was thinking that fallback would be used for example for Linux vDSO which needs to be read by Process::ReadModuleFromMemory() but that has only about 16KB so its size does not matter. But maybe on OSX (or for GDB JIT modules) the data can be bigger so in this patch I have implemented the most effective merging of non-mmapped sections.

[jankratochvil]

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

707–721

replied by: https://reviews.llvm.org/D51578#1400641

[JDevlieghere]

Few comments inline.

lldb/include/lldb/Symbol/ObjectFile.h

781

Please clang-format the patch before landing this.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

3400

Rather than returning 0 when there's no decompressor, why not return llvm::Optional<uint64_t> to differentiate between with an actual size of zero?

3409

I don't think having an expected as a member makes sense. Maybe you want to use an optional? Is the goal to abstract over the decompression not being available? Or should the class assume the the decompressor is there (and itself be wrapped in an expected when that's not the case?). I'm not too familiar with this code but it seems a rather odd design.

3413

Trailing underscore?

3467

You could early return here (return 0;).

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

684

Can we split this up? There's no way I remember the first two clauses by the time I'm reading the third.

lldb/include/lldb/Symbol/ObjectFile.h

public:
   // compressed.
   virtual size_t ReadSectionData(Section *section,
                                  lldb::offset_t section_offset, void *dst,
                                  size_t dst_len);
 
   // This function will transparently decompress section data if the section if
   // compressed. Note that for compressed section the resulting data size may
   // be larger than what Section::GetFileSize reports.
-  virtual size_t ReadSectionData(const SectionPart &section_part,
-                                 DataExtractor &section_data);
+  size_t ReadSectionData(const SectionPart &section_part,
 
   bool IsInMemory() const { return m_memory_addr != LLDB_INVALID_ADDRESS; }
 
   // Strip linker annotations (such as @@VERSION) from symbol names.
   virtual llvm::StringRef
   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
     return symbol_name;
   }
public:
   ///
   /// @param[in] target
   ///     Target where to load.
   ///
   /// @return
   //------------------------------------------------------------------
   virtual std::vector<LoadableData> GetLoadableData(Target &target);
 
+  // Similar to ReadSectionData() but you can ask final (decompressed for
+  // compressed sections) size before really reading the data to an adress.
+  class SectionReader;
+  virtual std::unique_ptr<SectionReader> SectionReaderFactory(
+      const SectionPart &section_part);
+  class SectionReader {
+  public:
+    virtual uint64_t getDecompressedSize();
+    virtual size_t read(DataExtractor &section_data);
+    virtual size_t read(uint8_t *dst);
+    virtual ~SectionReader();
+  protected:
+    friend std::unique_ptr<SectionReader> ObjectFile::SectionReaderFactory(
+  const SectionPart &section_part);
+    SectionReader(const SectionPart &section_part_);
+    const SectionPart &section_part;
+  };
+
+  lldb::ProcessWP &GetProcessWP() { return m_process_wp; }
+
 protected:
   //------------------------------------------------------------------
   // Member variables.
   //------------------------------------------------------------------
   FileSpec m_file;
   Type m_type;
   Strata m_strata;
   lldb::addr_t m_file_offset; ///< The offset in bytes into the file, or the

lldb/include/lldb/lldb-enumerations.h

enum SectionType {
   eSectionTypeOther,
   eSectionTypeDWARFDebugLineStr, // DWARF v5 .debug_line_str
   eSectionTypeDWARFDebugRngLists, // DWARF v5 .debug_rnglists
   eSectionTypeDWARFDebugLocLists, // DWARF v5 .debug_loclists
   eSectionTypeDWARFDebugAbbrevDwo,
   eSectionTypeDWARFDebugInfoDwo,
   eSectionTypeDWARFDebugStrDwo,
   eSectionTypeDWARFDebugStrOffsetsDwo,
+  eSectionTypeDWARFDebugTypesDwo,
 };
 
 FLAGS_ENUM(EmulateInstructionOptions){
     eEmulateInstructionOptionNone = (0u),
     eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
     eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
 
 FLAGS_ENUM(FunctionNameType){

lldb/source/Core/Section.cpp

const char *Section::GetTypeAsCString() const {
   case eSectionTypeDWARFDebugStrDwo:
     return "dwarf-str-dwo";
   case eSectionTypeDWARFDebugStrOffsets:
     return "dwarf-str-offsets";
   case eSectionTypeDWARFDebugStrOffsetsDwo:
     return "dwarf-str-offsets-dwo";
   case eSectionTypeDWARFDebugTypes:
     return "dwarf-types";
+  case eSectionTypeDWARFDebugTypesDwo:
+    return "dwarf-types-dwo";
   case eSectionTypeDWARFDebugNames:
     return "dwarf-names";
   case eSectionTypeELFSymbolTable:
     return "elf-symbol-table";
   case eSectionTypeELFDynamicSymbols:
     return "elf-dynamic-symbols";
   case eSectionTypeELFRelocationEntries:
     return "elf-relocation-entries";

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

public:
   lldb_private::Address GetEntryPointAddress() override;
 
   lldb_private::Address GetBaseAddress() override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
+  using lldb_private::ObjectFile::ReadSectionData;
   size_t ReadSectionData(lldb_private::Section *section,
                          lldb::offset_t section_offset, void *dst,
                          size_t dst_len) override;
 
-  size_t ReadSectionData(const lldb_private::SectionPart &section_part,
-                         lldb_private::DataExtractor &section_data) override;
-
   llvm::ArrayRef<elf::ELFProgramHeader> ProgramHeaders();
   lldb_private::DataExtractor GetSegmentData(const elf::ELFProgramHeader &H);
 
   llvm::StringRef
   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override;
 
   void RelocateSection(lldb_private::Section *section) override;
 
+  std::unique_ptr<SectionReader> SectionReaderFactory(
+      const lldb_private::SectionPart &section_part) override;
+
+  class SectionReaderCompressed;
+
 protected:
 
   std::vector<LoadableData>
   GetLoadableData(lldb_private::Target &target) override;
 
 private:
   ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Decompressor.h"
+#include "llvm/Object/ELF.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/MipsABIFlags.h"
 
 #define CASE_AND_STREAM(s, def, width)                                         \
   case def:                                                                    \
     s->Printf("%-*s", width, #def);                                            \
return llvm::StringSwitch<SectionType>(Name)
       .Case(".debug_pubtypes", eSectionTypeDWARFDebugPubTypes)
       .Case(".debug_ranges", eSectionTypeDWARFDebugRanges)
       .Case(".debug_rnglists", eSectionTypeDWARFDebugRngLists)
       .Case(".debug_str", eSectionTypeDWARFDebugStr)
       .Case(".debug_str.dwo", eSectionTypeDWARFDebugStrDwo)
       .Case(".debug_str_offsets", eSectionTypeDWARFDebugStrOffsets)
       .Case(".debug_str_offsets.dwo", eSectionTypeDWARFDebugStrOffsetsDwo)
       .Case(".debug_types", eSectionTypeDWARFDebugTypes)
+      .Case(".debug_types.dwo", eSectionTypeDWARFDebugTypesDwo)
       .Case(".eh_frame", eSectionTypeEHFrame)
       .Case(".gnu_debugaltlink", eSectionTypeDWARFGNUDebugAltLink)
       .Case(".gosymtab", eSectionTypeGoSymtab)
       .Case(".text", eSectionTypeCode)
       .Default(eSectionTypeOther);
 }
 
 SectionType ObjectFileELF::GetSectionType(const ELFSectionHeaderInfo &H) const {
size_t ObjectFileELF::ReadSectionData(Section *section,
 
   // For compressed sections we need to read to full data to be able to
   // decompress.
   DataExtractor data;
   ReadSectionData(section, data);
   return data.CopyData(section_offset, dst_len, dst);
 }
 
-size_t ObjectFileELF::ReadSectionData(const SectionPart &section_part,
-                                      DataExtractor &section_data) {
-  Section *section = section_part.GetSection();
-  // If some other objectfile owns this data, pass this to them.
-  if (section->GetObjectFile() != this)
-    return section->GetObjectFile()->ReadSectionData(
-        section_part, section_data);
+class ObjectFileELF::SectionReaderCompressed
+    : public ObjectFile::SectionReader {
+public:
+  SectionReaderCompressed(const SectionPart &section_part_);
+  uint64_t getDecompressedSize() override;
+  size_t read(DataExtractor &section_data) override;
+  size_t read(uint8_t *dst) override;
+  ~SectionReaderCompressed();
+private:
+  static llvm::Expected<llvm::object::Decompressor> Initialize(
+      const SectionPart &section_part, DataExtractor &compressed_data);
+  DataExtractor compressed_data;
+  // 'decompressor' Initialize() requires already initialized 'compressed_data'.
+  llvm::Expected<llvm::object::Decompressor> decompressor;
+};
 
-  size_t result = ObjectFile::ReadSectionData(section, section_data);
-  if (result == 0 || !section->Test(SHF_COMPRESSED))
-    return result;
+ObjectFileELF::SectionReaderCompressed::SectionReaderCompressed(
+    const SectionPart &section_part_)
+    : ObjectFile::SectionReader(section_part_),
+    decompressor(Initialize(section_part_, compressed_data)) {}
+
+ObjectFileELF::SectionReaderCompressed::~SectionReaderCompressed() {
+  if (decompressor.takeError()) {}
+}
 
+llvm::Expected<llvm::object::Decompressor>
+ObjectFileELF::SectionReaderCompressed::Initialize(
+    const SectionPart &section_part, DataExtractor &compressed_data) {
+  Section *section = section_part.GetSection();
+  ObjectFile *obj_file = section->GetObjectFile();
   if (section_part.GetOffsetInSection() != 0
       || section_part.GetLength() != section->GetFileSize()) {
-    GetModule()->ReportWarning(
+    obj_file->GetModule()->ReportWarning(
         "Unable to read only part %" PRIu64 "+%" PRIu64
         " of compressed section '%s'",
         section_part.GetOffsetInSection(), section_part.GetLength(),
         section->GetName().GetCString());
-    section_data.Clear();
-    return 0;
+    return llvm::object::createError(
+        "Unable to read only part of compressed section");
   }
-
-  auto Decompressor = llvm::object::Decompressor::create(
+  {
+    auto reader_up = obj_file->ObjectFile::SectionReaderFactory(section_part);
+    if (!reader_up
+        || reader_up->read(compressed_data) != section->GetFileSize())
+      return llvm::object::createError("ReadSectionData failed");
+  }
+  auto decompressor = llvm::object::Decompressor::create(
       section->GetName().GetStringRef(),
-      {reinterpret_cast<const char *>(section_data.GetDataStart()),
-       size_t(section_data.GetByteSize())},
-      GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8);
-  if (!Decompressor) {
-    GetModule()->ReportWarning(
+      {reinterpret_cast<const char *>(compressed_data.GetDataStart()),
+       size_t(compressed_data.GetByteSize())},
+      obj_file->GetByteOrder() == eByteOrderLittle,
+      obj_file->GetAddressByteSize() == 8);
+  if (!decompressor)
+    obj_file->GetModule()->ReportWarning(
         "Unable to initialize decompressor for section '%s': %s",
         section->GetName().GetCString(),
-        llvm::toString(Decompressor.takeError()).c_str());
-    section_data.Clear();
+        llvm::toString(decompressor.takeError()).c_str());
+  return decompressor;
+}
+
+uint64_t ObjectFileELF::SectionReaderCompressed::getDecompressedSize() {
+  if (!decompressor)
     return 0;
-  }
+  return decompressor->getDecompressedSize();
+}
+
+size_t ObjectFileELF::SectionReaderCompressed::read(
+    DataExtractor &section_data) {
+  auto buffer_sp = std::make_shared<DataBufferHeap>(getDecompressedSize(), 0);
+  size_t retval = read(buffer_sp->GetBytes());
+  if (retval == 0)
+    section_data.Clear();
+  else {
+    Section *section = section_part.GetSection();
+    ObjectFile *obj_file = section->GetObjectFile();
+
+    section_data.SetData(buffer_sp);
+    section_data.SetByteOrder(obj_file->GetByteOrder());
+    section_data.SetAddressByteSize(obj_file->GetAddressByteSize());
+  }
+  return retval;
 
-  auto buffer_sp =
-      std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0);
-  if (auto error = Decompressor->decompress(
-          {reinterpret_cast<char *>(buffer_sp->GetBytes()),
-           size_t(buffer_sp->GetByteSize())})) {
-    GetModule()->ReportWarning(
+size_t ObjectFileELF::SectionReaderCompressed::read(uint8_t *dst) {
+  if (!decompressor)
+    return 0;
+  if (auto error = decompressor->decompress(
+          {reinterpret_cast<char *>(dst), size_t(getDecompressedSize())})) {
+    Section *section = section_part.GetSection();
+    ObjectFile *obj_file = section->GetObjectFile();
+    obj_file->GetModule()->ReportWarning(
         "Decompression of section '%s' failed: %s",
         section->GetName().GetCString(),
         llvm::toString(std::move(error)).c_str());
-    section_data.Clear();
     return 0;
   }
+  return getDecompressedSize();
+}
 
-  section_data.SetData(buffer_sp);
-  return buffer_sp->GetByteSize();
+std::unique_ptr<ObjectFile::SectionReader>
+ObjectFileELF::SectionReaderFactory(const SectionPart &section_part) {
+  if (!section_part)
+    return ObjectFile::SectionReaderFactory(section_part);
+  Section *section = section_part.GetSection();
+  if (section->GetFileSize() == 0 || !section->Test(SHF_COMPRESSED))
+    return ObjectFile::SectionReaderFactory(section_part);
+  return llvm::make_unique<SectionReaderCompressed>(section_part);
 }
 
 llvm::ArrayRef<ELFProgramHeader> ObjectFileELF::ProgramHeaders() {
   ParseProgramHeaders();
   return m_program_headers;
 }
 
 DataExtractor ObjectFileELF::GetSegmentData(const ELFProgramHeader &H) {

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

public:
   lldb_private::UUID GetUUID() override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
   size_t ReadSectionData(lldb_private::Section *section,
                          lldb::offset_t section_offset, void *dst,
                          size_t dst_len) override;
 
-  size_t
-  ReadSectionData(const lldb_private::SectionPart &section_part,
-                  lldb_private::DataExtractor &section_data) override;
+  std::unique_ptr<SectionReader> SectionReaderFactory(
+      const lldb_private::SectionPart &section_part) override;
+
+  class SectionReaderJIT;
 
   lldb_private::Address GetEntryPointAddress() override;
 
   lldb_private::Address GetBaseAddress() override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

const uint8_t *src =
         ((uint8_t *)(uintptr_t)section->GetFileOffset()) + section_offset;
 
     memcpy(dst, src, src_len);
     return src_len;
   }
   return 0;
 }
 
-size_t ObjectFileJIT::ReadSectionData(
-    const lldb_private::SectionPart &section_part,
-    lldb_private::DataExtractor &section_data) {
-  if (section_part.GetLength()) {
-    const void *src = (void *)(uintptr_t)section_part.GetOffsetInFile();
+class ObjectFileJIT::SectionReaderJIT : public ObjectFile::SectionReader {
+public:
+  SectionReaderJIT(const SectionPart &section_part_);
+  size_t read(DataExtractor &section_data) override;
+  size_t read(uint8_t *dst) override;
+};
+
+ObjectFileJIT::SectionReaderJIT::SectionReaderJIT(
+    const SectionPart &section_part_)
+    : ObjectFile::SectionReader(section_part_) {
+  assert(section_part.GetLength());
+}
+
+size_t ObjectFileJIT::SectionReaderJIT::read(DataExtractor &section_data) {
 
-    DataBufferSP data_sp(
-        new lldb_private::DataBufferHeap(src, section_part.GetLength()));
-    if (data_sp) {
-      section_data.SetData(data_sp, 0, data_sp->GetByteSize());
-      section_data.SetByteOrder(GetByteOrder());
-      section_data.SetAddressByteSize(GetAddressByteSize());
-      return section_data.GetByteSize();
-    }
-  }
+  DataBufferSP data_sp(new DataBufferHeap(src, section_part.GetLength()));
+    Section *section = section_part.GetSection();
+    ObjectFile *obj_file = section->GetObjectFile();
+
+    section_data.SetByteOrder(obj_file->GetByteOrder());
+    section_data.SetAddressByteSize(obj_file->GetAddressByteSize());
   section_data.Clear();
   return 0;
 }
+
+size_t ObjectFileJIT::SectionReaderJIT::read(uint8_t *dst) {
+  Section *section = section_part.GetSection();
+  ObjectFile *obj_file = section->GetObjectFile();
+  return obj_file->ReadSectionData(section, section_part.GetOffsetInSection(),
+      dst, section_part.GetLength());
+}
+
+std::unique_ptr<ObjectFile::SectionReader>
+ObjectFileJIT::SectionReaderFactory(const SectionPart &section_part) {
+  return llvm::make_unique<SectionReaderJIT>(section_part);
+}

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (symbol) {
           case eSectionTypeDWARFDebugPubTypes:
           case eSectionTypeDWARFDebugRanges:
           case eSectionTypeDWARFDebugRngLists:
           case eSectionTypeDWARFDebugStr:
           case eSectionTypeDWARFDebugStrDwo:
           case eSectionTypeDWARFDebugStrOffsets:
           case eSectionTypeDWARFDebugStrOffsetsDwo:
           case eSectionTypeDWARFDebugTypes:
+          case eSectionTypeDWARFDebugTypesDwo:
           case eSectionTypeDWARFAppleNames:
           case eSectionTypeDWARFAppleTypes:
           case eSectionTypeDWARFAppleNamespaces:
           case eSectionTypeDWARFAppleObjC:
           case eSectionTypeDWARFGNUDebugAltLink:
             return AddressClass::eDebug;
 
           case eSectionTypeEHFrame:

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

 class DWARFCompileUnit : public DWARFUnit {
 public:
   static DWARFUnitSP Extract(SymbolFileDWARF *dwarf2Data,
                              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);
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

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

uint32_t DWARFCompileUnit::GetHeaderByteSize() const {
   case llvm::dwarf::DW_UT_split_compile:
     return 20;
   case llvm::dwarf::DW_UT_type:
   case llvm::dwarf::DW_UT_split_type:
     return 24;
   }
   llvm_unreachable("invalid UnitType.");
 }
-
-const lldb_private::DWARFDataExtractor &DWARFCompileUnit::GetData() const {
-  return m_dwarf->get_debug_info_data();
-}

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

 }
 
 void DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() {
   if (m_compile_units.empty()) {
     if (m_dwarf2Data != NULL) {
       lldb::offset_t offset = 0;
       DWARFUnitSP cu_sp;
       const auto &debug_info_data = m_dwarf2Data->get_debug_info_data();
-      while ((cu_sp = DWARFCompileUnit::Extract(m_dwarf2Data, debug_info_data,
+      while (offset < m_dwarf2Data->get_debug_info_size()
+          && (cu_sp = DWARFCompileUnit::Extract(m_dwarf2Data, debug_info_data,
                                                 &offset))) {
         m_compile_units.push_back(cu_sp);
 
         offset = cu_sp->GetNextCompileUnitOffset();
       }
     }
   }
 }

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

public:
   ///
   /// This will return the correct bytes that contain the data for
   /// this DWARFUnit. It could be .debug_info or .debug_types
   /// depending on where the data for this unit originates.
   ///
   /// @return
   ///   The correct data for the DIE information in this unit.
   //------------------------------------------------------------------
-  virtual const lldb_private::DWARFDataExtractor &GetData() const = 0;
+  const lldb_private::DWARFDataExtractor &GetData() const;
   //------------------------------------------------------------------
   /// Get the size in bytes of the compile unit header.
   ///
   /// @return
   ///     Byte size of the compile unit header
   //------------------------------------------------------------------
   virtual uint32_t GetHeaderByteSize() const = 0;
   // Offset of the initial length field.

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

if (m_func_aranges_up == NULL) {
     }
 
     const bool minimize = false;
     m_func_aranges_up->Sort(minimize);
   }
   return *m_func_aranges_up;
 }
 
+const lldb_private::DWARFDataExtractor &DWARFUnit::GetData() const {
+  return m_dwarf->get_debug_info_data();
+}

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

public:
   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_info_data();
+  virtual lldb_private::SectionPart get_debug_info_section_part();
   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();
+  virtual lldb_private::SectionPart get_debug_types_section_part();
   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();
 
public:
 
   std::vector<lldb_private::CallEdge>
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
+  uint64_t get_debug_info_size() const {
+    return m_debug_info_concatenated_info_size;
+  }
+  uint64_t get_debug_types_offset() const {
+    return m_debug_info_concatenated_types_offset;
+  }
+
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
protected:
   std::unique_ptr<SymbolFileDWARFDwp> m_dwp_symfile;
 
   lldb_private::DWARFDataExtractor m_dwarf_data;
 
   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;
   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;
 
+  llvm::once_flag m_concatenated_data_once;
+  // For get_debug_info_data() containing both '.debug_info' and '.debug_types'.
+  lldb_private::DWARFDataExtractor m_data_debug_info_concatenated;
+  // First part of m_data_debug_info_concatenated containing '.debug_info'.
+  uint64_t m_debug_info_concatenated_info_size;
+  // Start of second part of m_data_debug_info_concatenated containing
+  // '.debug_types'.  There may be a gap between those two sections.
+  uint64_t m_debug_info_concatenated_types_offset;
+
   // 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/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 //===-- SymbolFileDWARF.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 "SymbolFileDWARF.h"
 
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.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_data_debug_abbrev(),
-      m_data_debug_aranges(), m_data_debug_frame(), m_data_debug_info(),
+      m_data_debug_aranges(), m_data_debug_frame(),
       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() {}
SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
   return data_segment.m_data;
 }
 
 SectionPart SymbolFileDWARF::GetSectionPart(lldb::SectionType sect_type) const {
   ModuleSP module_sp(m_obj_file->GetModule());
   const SectionList *section_list = module_sp->GetSectionList();
   if (section_list) {
     Section *section = section_list->FindSectionByType(sect_type, true).get();
-    if (section)
+    // The size check is just a performance optimization.
+    if (section && (section->GetByteSize() || section->GetFileSize()))
       return section;
   }
   return SectionPart();
 }
 
 void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
                                       DWARFDataExtractor &data) {
   LoadSectionData(GetSectionPart(sect_type), data);
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);
+SectionPart SymbolFileDWARF::get_debug_info_section_part() {
+  return GetSectionPart(eSectionTypeDWARFDebugInfo);
 }
 
 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_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);
+SectionPart SymbolFileDWARF::get_debug_types_section_part() {
+  return GetSectionPart(eSectionTypeDWARFDebugTypes);
 }
 
 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);
 }
 
+const DWARFDataExtractor &SymbolFileDWARF::get_debug_info_data() {
+  llvm::call_once(m_concatenated_data_once, [&] {
+    const SectionPart debug_info_part = get_debug_info_section_part();
+    const SectionPart debug_types_part = get_debug_types_section_part();
+    if (!debug_info_part && !debug_types_part)
+      return;
+    // For this optimization of mmapped sections we do not handle .debug_types
+    // present without .debug_info as that should not happen.
+    if (!m_obj_file->IsInMemory() && debug_info_part
+        && !debug_info_part.GetSection()->Test(llvm::ELF::SHF_COMPRESSED)
+        && (!debug_types_part
+            || (!debug_types_part.GetSection()->Test(llvm::ELF::SHF_COMPRESSED)
+                && debug_info_part.GetOffsetInFile()
+                        + debug_info_part.GetLength()
+                    <= debug_types_part.GetOffsetInFile()))) {
+      m_debug_info_concatenated_info_size = debug_info_part.GetLength();
+      uint64_t length;
+      if (debug_types_part) {
+        m_debug_info_concatenated_types_offset =
+            debug_types_part.GetOffsetInFile()
+            - debug_info_part.GetOffsetInFile();
+        length = debug_types_part.GetOffsetInFile()
+            + debug_types_part.GetLength() - debug_info_part.GetOffsetInFile();
+      } else {
+        m_debug_info_concatenated_types_offset = debug_info_part.GetLength();
+        length = debug_info_part.GetLength();
+      }
+      if (m_dwarf_data.GetByteSize())
+        m_data_debug_info_concatenated.SetData(m_dwarf_data,
+            debug_info_part.GetOffsetInParentSection(), length);
+      else
+        m_obj_file->GetData(debug_info_part.GetOffsetInFile(),
+            length, m_data_debug_info_concatenated);
+      if (m_data_debug_info_concatenated.GetByteSize() != length)
+        m_data_debug_info_concatenated.Clear();
+      return;
+    }
+    auto debug_info_reader = m_obj_file->SectionReaderFactory(debug_info_part);
+    auto debug_types_reader = m_obj_file->SectionReaderFactory(
+        debug_types_part);
+    const auto info_len = debug_info_reader->getDecompressedSize();
+    const auto types_len = debug_types_reader->getDecompressedSize();
+    DataBufferSP databuffer = DataBufferSP(
+        new DataBufferHeap(info_len + types_len, 0));
+    if (debug_info_reader->read(databuffer->GetBytes()) != info_len
+        || debug_types_reader->read(databuffer->GetBytes() + info_len)
+            != types_len)
+      return;
+    m_debug_info_concatenated_info_size = info_len;
+    m_debug_info_concatenated_types_offset = info_len;
+    m_data_debug_info_concatenated.SetData(databuffer);
+    m_data_debug_info_concatenated.SetByteOrder(m_obj_file->GetByteOrder());
+    m_data_debug_info_concatenated.SetAddressByteSize(
+        m_obj_file->GetAddressByteSize());
+  });
+  return m_data_debug_info_concatenated;
+}
+
 DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
   if (m_abbr == NULL) {
     const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data();
     if (debug_abbrev_data.GetByteSize() > 0) {
       m_abbr.reset(new DWARFDebugAbbrev());
       if (m_abbr)
         m_abbr->Parse(debug_abbrev_data);
     }

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

GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die) override {
     return nullptr;
   }
 
   DWARFUnit *GetBaseCompileUnit() override;
 
   const lldb_private::DWARFDataExtractor &get_debug_abbrev_data() override;
   const lldb_private::DWARFDataExtractor &get_debug_addr_data() override;
-  const lldb_private::DWARFDataExtractor &get_debug_info_data() override;
+  lldb_private::SectionPart get_debug_info_section_part() override;
   const lldb_private::DWARFDataExtractor &get_debug_str_data() override;
   const lldb_private::DWARFDataExtractor &get_debug_str_offsets_data() override;
+  lldb_private::SectionPart get_debug_types_section_part() override;
 
 protected:
   lldb_private::SectionPart GetSectionPart(
       lldb::SectionType sect_type) const override;
 
   DIEToTypePtr &GetDIEToType() override;
 
   DIEToVariableSP &GetDIEToVariable() override;

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

const DWARFDataExtractor &SymbolFileDWARFDwo::get_debug_addr_data() {
   // .debug_addr, so we would always fall back to such lookup anyways.
   llvm::call_once(m_data_debug_addr.m_flag, [this] {
     LoadSectionData(SymbolFileDWARF::GetSectionPart(eSectionTypeDWARFDebugAddr),
                     std::ref(m_data_debug_addr.m_data));
   });
   return m_data_debug_addr.m_data;
 }
 
-const DWARFDataExtractor &SymbolFileDWARFDwo::get_debug_info_data() {
-  return GetCachedSectionData(eSectionTypeDWARFDebugInfoDwo, m_data_debug_info);
+SectionPart SymbolFileDWARFDwo::get_debug_info_section_part() {
+  return GetSectionPart(eSectionTypeDWARFDebugInfoDwo);
 }
 
 const DWARFDataExtractor &SymbolFileDWARFDwo::get_debug_str_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugStrDwo, m_data_debug_str);
 }
 
 const DWARFDataExtractor &SymbolFileDWARFDwo::get_debug_str_offsets_data() {
   return GetCachedSectionData(eSectionTypeDWARFDebugStrOffsetsDwo,
                               m_data_debug_str_offsets);
 }
 
+SectionPart SymbolFileDWARFDwo::get_debug_types_section_part() {
+  return GetSectionPart(eSectionTypeDWARFDebugTypesDwo);
+}
+
 SymbolFileDWARF *SymbolFileDWARFDwo::GetBaseSymbolFile() {
   return m_base_dwarf_cu->GetSymbolFileDWARF();
 }
 
 DWARFExpression::LocationListFormat
 SymbolFileDWARFDwo::GetLocationListFormat() const {
   return DWARFExpression::SplitDwarfLocationList;
 }

lldb/source/Symbol/ObjectFile.cpp

if (symbol) {
           case eSectionTypeDWARFDebugPubTypes:
           case eSectionTypeDWARFDebugRanges:
           case eSectionTypeDWARFDebugRngLists:
           case eSectionTypeDWARFDebugStr:
           case eSectionTypeDWARFDebugStrDwo:
           case eSectionTypeDWARFDebugStrOffsets:
           case eSectionTypeDWARFDebugStrOffsetsDwo:
           case eSectionTypeDWARFDebugTypes:
+          case eSectionTypeDWARFDebugTypesDwo:
           case eSectionTypeDWARFAppleNames:
           case eSectionTypeDWARFAppleTypes:
           case eSectionTypeDWARFAppleNamespaces:
           case eSectionTypeDWARFAppleObjC:
           case eSectionTypeDWARFGNUDebugAltLink:
             return AddressClass::eDebug;
           case eSectionTypeEHFrame:
           case eSectionTypeARMexidx:
if (section_offset < section_file_size) {
         memset(dst, 0, section_dst_len);
         return section_dst_len;
       }
     }
   }
   return 0;
 }
 
-//----------------------------------------------------------------------
-// Get the section data the file on disk
-//----------------------------------------------------------------------
-size_t ObjectFile::ReadSectionData(
-    const SectionPart &section_part, DataExtractor &section_data) {
+size_t ObjectFile::ReadSectionData(const SectionPart &section_part,
+                                   DataExtractor &section_data) {
   Section *section = section_part.GetSection();
   // If some other objectfile owns this data, pass this to them.
   if (section->GetObjectFile() != this)
     return section->GetObjectFile()->ReadSectionData(
         section_part, section_data);
 
-  if (IsInMemory()) {
-    ProcessSP process_sp(m_process_wp.lock());
+  auto reader_up = SectionReaderFactory(section_part);
+  if (!reader_up)
+    return 0;
+  return reader_up->read(section_data);
+}
+
+ObjectFile::SectionReader::SectionReader(const SectionPart &section_part_)
+    : section_part(section_part_) {}
+
+std::unique_ptr<ObjectFile::SectionReader>
+ObjectFile::SectionReaderFactory(const SectionPart &section_part) {
+  // llvm::make_unique() is not a friend like we are.
+  return std::unique_ptr<SectionReader>(new SectionReader(section_part));
+}
+
+ObjectFile::SectionReader::~SectionReader() {}
+
+uint64_t ObjectFile::SectionReader::getDecompressedSize() {
+  return !section_part ? 0 : section_part.GetSection()->GetFileSize();
+}
+
+size_t ObjectFile::SectionReader::read(uint8_t *dst) {
+  if (!section_part)
+    return 0;
+  Section *section = section_part.GetSection();
+  return section->GetObjectFile()->ObjectFile::ReadSectionData(section,
+      section_part.GetOffsetInSection(), dst, section_part.GetLength());
+}
+
+//----------------------------------------------------------------------
+// Get the section data the file on disk
+//----------------------------------------------------------------------
+size_t ObjectFile::SectionReader::read(DataExtractor &section_data) {
+  if (!section_part)
+    return 0;
+  Section *section = section_part.GetSection();
+  ObjectFile *obj_file = section->GetObjectFile();
+
+  if (obj_file->IsInMemory()) {
+    ProcessSP process_sp(obj_file->GetProcessWP().lock());
     if (process_sp) {
       const addr_t base_load_addr =
           section->GetLoadBaseAddress(&process_sp->GetTarget());
       if (base_load_addr != LLDB_INVALID_ADDRESS) {
         DataBufferSP data_sp(
             ReadMemory(process_sp,
                 base_load_addr + section_part.GetOffsetInSection(),
                 section_part.GetLength()));
         if (data_sp) {
           section_data.SetData(data_sp, 0, data_sp->GetByteSize());
           section_data.SetByteOrder(process_sp->GetByteOrder());
           section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
           return section_data.GetByteSize();
         }
       }
     }
   } else {
     // The object file now contains a full mmap'ed copy of the object file
     // data, so just use this
     if (!section->IsRelocated())
-      RelocateSection(section);
+      obj_file->RelocateSection(section);
   }
-  return GetData(section_part.GetOffsetInFile(), section_part.GetLength(),
-                 section_data);
+  return obj_file->GetData(section_part.GetOffsetInFile(),
+      section_part.GetLength(), section_data);
 }
 
 bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
                                             FileSpec &archive_file,
                                             ConstString &archive_object,
                                             bool must_exist) {
   RegularExpression g_object_regex(llvm::StringRef("(.*)\\(([^\\)]+)\\)$"));
   RegularExpression::Match regex_match(2);