ObjectFileELF: Add support for compressed sections

[labath]

Summary

We use the llvm decompressor to decompress SHF_COMPRESSED sections. This enables
us to read data from debug info sections, which are sometimes compressed,
particuarly in the split-dwarf case. This functionality is only available if
llvm is compiled with zlib support.

[zturner]

It's too bad this has to be written as a unit test, because this would be the perfect candidate for a FileCheck style test.

Probably a long shot, but have you tried the llvm-lit project? Last time I tried it, it basically worked, but there were only a handful of tests in it. It might be possible to write a test in such a way that it invokes lldb with a .lldbinit file which enables logging to a file, ends with the quit command, and then FileChecks the log file.

[clayborg]

Why would we text scrape when we can test the API?

[zturner]

For the same reason that the entire rest of the LLVM project and all other subprojects do it, when it makes sense and the nature of the test lends itself to it.

[zturner]

Note that there's no interactivity here. This is "feed some input, get some output, make sure the output is correct". That's exactly what FileCheck is designed for. This isn't even testing the public API, it's testing the private API. We should prefer testing the actual program in this case.

[davide]

This one is a little weird when written as unittest. Not the worst thing, but I agree it should use llvm-lit.
Can you give it a shot, Pavel? If that doesn't work, we should at least evaluate the amount of work needed to get llvm-lit to run with lldb before dismissing it entirely.
BTW, nice to see lldb getting more and more tests, regardless :)

[davide]

Another very good reason for writing a FileCheck test rather than a unittest is that writing unittest is tedious :)
In particular for new contributors, FileCheck tests are much easier to write and in this case testing the API surface doesn't seem to add much value.

[jingham]

It does look a little weird as a unit test, but to me this is mostly because it would been much simpler to write it as a regular SB API test.

Anyway, I really don't want the details of the text output of lldb commands to become API. Our experience with gdb was that over time as you write more and more tests that scrape text output, you end up not being able to change command output because the burden of fixing up all the tests becomes too onerous. You can use text scraping in the current lldb testsuite. We discourage that for the reasons above, and try to isolate the tests that do so by having lldbutils interfaces to do the explicit scraping. But it is just as easy, and quite often much easier, to examine objects directly in the lldb testsuite, so this mechanism encourages virtue, even though it doesn't enforce it.

OTOH adding a test mechanism that explicitly relies only on command output scraping leads us down the path that ended up being a real PITN for the gdb testsuite. So for that reason I am not in favor of going this way.

[labath]

This rewrites the test in terms on the new lldb-test utility. It should be applied on top of D40636.

While doing that, I noticed a discrepancy in the data presented by the object
file interface -- for GetFileSize(), it would return the compressed size, but,
when reading the data, it would return the decompressed size. This seemed odd
and unwanted.

So now I fetch the decompressed size when constructing the Section object, and
make sure GetFileSize result matches what the GetSectionData returns. This is
slightly odd as well, because now if someone looks at individual section file
offsets and sizes, it will seem that multiple sections overlap. While
unfortunate, this is a situation that can arise in without the presence of
compressed sections (no linker will produce a file like that, but you can
certainly hand-craft one), and our elf parser will hapily accept these files.

[labath]

lit/Modules/compressed-sections.yaml

1

It's right here. (I'm open to suggestions where to place it).

[zturner]

lit/Modules/compressed-sections.yaml

1

I see. I think part of the reason I didn't notice it is because it has a .yaml extension just like the old one, so I didn't notice this was really a test.

LLVM is a little inconsistent here (it has tests that end in .ll and .s, but not for most other file extensions), so can you rename this to compressed-sections.test?

At some point I think we should inject another directory in this hierarchy (i.e. lit/test/Modules), but since this is not going to be the first directory here, I guess it doesn't need to happen now.

12–13

Can you separate the CHECK lines and the YAML content? I think it makes it easier to follow this way, and it gives a consistent paradigm (checks first, then input, or vice versa). Interspersing them doesn't always work (for example if the tool doesn't output things in the same order as the input description).

17–18

Can you use CHECK-NEXT for these two? As it stands, if we output:

Name: .hello_elf
File size: -1
Data: -1

Name: .hello_coff
File size: 8
Data: 2030405060708090

It would pass, as written.

20

You should probably put this as the very first check statement. Each successfully matching CHECK line will update an internal position and subsequent checks will only start from that position, so here you're only checking that after .bogus does not occur after .hello_elf, but this test would pass if .bogus occurred before .hello_elf. But putting the CHECK-NOT first, both will fail (this is also a good reason not to intersperse the check lines).

[labath]

lit/Modules/compressed-sections.yaml

1

llvm (and lld) also have plenty of tests ending in .yaml. Since this is a yaml file, and plenty of editors have syntax highlighting for yaml, it seems a pitty not to take advantage of that.

20

Putting CHECK-NOT first will just make sure that .bogus does not appear *before* the first CHECK match. I put it last as it this is the place it is likely to be if it did we did end up outputting it, but if we want to be safe, I guess we have two options:

• put it both at the front *and* back
• have two FileCheck invocations

I chose the latter.

[labath]

Rebase on master and update the test.

[zturner]

lit/Modules/compressed-sections.yaml

20

I don't believe this is correct, and if it is then someone has introduced a bug in FileCheck. matches do not succeed or fail based on what check lines come after. They only succeed or fail based on the current file position. If the file position is 0, and you say CHECK-NOT, then you are checking that it does not appear anywhere in the file (i.e. anywhere starting at position 0). Assuming the test passes (i.e. it does not find it), the file position is not updated and then the CHECK line continues by making sure that it does appear. And so on and so forth.

[zturner]

lit/Modules/compressed-sections.yaml

1

I don't feel too strongly about this, but I do have a mild preference for having it end in .test. Another alternative to still get syntax highlighting is to have a Inputs folder and put the .yaml file there adn have the test file reference it. I'll defer to davide for a second opinion. If he's ok with the .yaml extension, I guess that's fine.

[labath]

lit/Modules/compressed-sections.yaml

20

I don't know what you're basing your claim on, but this behavior is consistent with FileCheck documentation here https://llvm.org/docs/CommandGuide/FileCheck.html:

The “CHECK-NOT:” directive is used to verify that a string doesn’t occur between two matches (or before the first match, or after the last match).

[zturner]

lit/Modules/compressed-sections.yaml

20

Well I guess the best way to be sure is to test it, and... you're right. Weird. I've been using it wrong all this time.

I almost feel like we need a CHECK-NOT-DAG or something. Anyway, your solution looks fine.

[labath]

@davide: Any thoughts on .yaml as a test file suffix?

@clayborg: What do you think about my comment about GetFileSize() of compressed sections

In D40616#940408, @labath wrote:

This rewrites the test in terms on the new lldb-test utility. It should be applied on top of D40636.

While doing that, I noticed a discrepancy in the data presented by the object
file interface -- for GetFileSize(), it would return the compressed size, but,
when reading the data, it would return the decompressed size. This seemed odd
and unwanted.

So now I fetch the decompressed size when constructing the Section object, and
make sure GetFileSize result matches what the GetSectionData returns. This is
slightly odd as well, because now if someone looks at individual section file
offsets and sizes, it will seem that multiple sections overlap. While
unfortunate, this is a situation that can arise in without the presence of
compressed sections (no linker will produce a file like that, but you can
certainly hand-craft one), and our elf parser will hapily accept these files.

[clayborg]

I think GetFileSize() should remain the number of bytes of the section on disk and we should add new API if we need to figure out the decompressed size. Or maybe when we get bytes from a compressed section we are expected to always just get the raw bytes, then we check of the section is compressed, and if so, then we call another API on ObjectFile to decompress the data. So I would prefer GetFileSize() to return the file size of the section size in the file and not the decompressed size. Is there a way to make this work?

[davide]

In D40616#951256, @labath wrote:

@davide: Any thoughts on .yaml as a test file suffix?

I think this is fine.

[labath]

In D40616#951324, @clayborg wrote:

I think GetFileSize() should remain the number of bytes of the section on disk and we should add new API if we need to figure out the decompressed size. Or maybe when we get bytes from a compressed section we are expected to always just get the raw bytes, then we check of the section is compressed, and if so, then we call another API on ObjectFile to decompress the data. So I would prefer GetFileSize() to return the file size of the section size in the file and not the decompressed size. Is there a way to make this work?

Yes, that's possible. The first version of this patch had GetFileSize return the on-disk size, but it was weird because then GetSectionData returned a different size. I guess it would stop being "weird" if we add an extra GetDecompressedSize method and document that GetSectionData returns decompressed data. I don't think we can use GetByteSize to return the decompressed size, as we use this value to denote the size in the process memory, and expect it to be zero for non-loadable sections. It is true that the elf spec says no loadable section can be compressed, so we theoretically wouldn't have a conflict here, but I don't think we will be doing anyone a favour by overloading GetByteSize this way.

I don't like the idea of needing to do an extra call to decompress data, as it will complicate clients and I think all clients will want to use the data in the decompressed form.

[clayborg]

Sounds good,. So the solution will be:

• Section::GetFileSize() will return the size in bytes of the section data as it appears in the file
• Section::GetByteSize() will return the size in bytes for when this section is loaded into process memory (we might consider renaming this to "GetLoadSize()" then?)
• Getting section data might return more data that GetByteSize() if it needs to be decompressed and decompression will happen automatically

Does that sound right?

[labath]

In D40616#952432, @clayborg wrote:

Does that sound right?

Yes, I'll get on it.

[labath]

The version where Section::GetFileSize reports the on-disk (compressed) size. I
also like the idea of renaming Section::GetByteSize to something more
descriptive, and I'll make a follow-up patch to do that.

[clayborg]

Move #include of "llvm/Object/Decompressor.h" into CPP file and this is good to go.

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

24

Move to .cpp file? Nothing in header file seems like it is needed.

[tzik]

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

3496 ↗

(On Diff #127120)

This adds new dependency to LLVM Object component.
Could you add it into LINK_COMPONENTS section of CMakeLists.txt in this directory?

[labath]

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

3496 ↗

(On Diff #127120)

Done in r320967. Thanks for pointing this out.

lit/CMakeLists.txt

 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
   ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
   )
 
 set(LLDB_TEST_DEPS
   LLDBUnitTests
   lldb
+  lldb-test
   )
 
 if(NOT LLDB_BUILT_STANDALONE)
-  list(APPEND LLDB_TEST_DEPS FileCheck not)
+  list(APPEND LLDB_TEST_DEPS FileCheck not yaml2obj)
 endif()
   
 # lldb-server is not built on every platform.
 if (TARGET lldb-server)
   list(APPEND LLDB_TEST_DEPS lldb-server)
 endif()
   
 if(APPLE)

lit/Modules/compressed-sections.yaml

+# REQUIRES: zlib
+# RUN: yaml2obj %s > %t
+# RUN: lldb-test module %t | FileCheck %s
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_386
+Sections:
+  - Name:            .hello_elf
+# CHECK: Section 1
+# CHECK: Name: .hello_elf
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_COMPRESSED ]
+    Content:         010000000800000001000000789c5330700848286898000009c802c1
+# CHECK: File size: 8
+# CHECK: Data: 2030405060708090
+  - Name:            .bogus
+# CHECK-NOT: .bogus
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_COMPRESSED ]
+    Content:         deadbeefbaadf00d

lit/Modules/lit.local.cfg

+config.suffixes = ['.yaml']

lit/lit.cfg

 # -*- Python -*-
 
 import os
 import platform
 import re
 import subprocess
 import locale
 
 import lit.formats
 import lit.util
 
+def binary_feature(on, feature, off_prefix):
+  return feature if on else off_prefix + feature
+
 # Configuration file for the 'lit' test runner.
 
 # name: The name of this test suite.
 config.name = 'lldb'
 
 # testFormat: The test format to use to interpret tests.
 #
 # For now we require '&&' between commands, until they get globally killed and

 config.substitutions.append(('%cxx', config.cxx))
 
 config.substitutions.append(('%lldb', lldb))
 
 if debugserver is not None:
     config.substitutions.append(('%debugserver', debugserver))
 
 for pattern in [r"\bFileCheck\b",
+                r"\blldb-test\b",
+                r"\byaml2obj\b",
                 r"\| \bnot\b"]:
     tool_match = re.match(r"^(\\)?((\| )?)\W+b([0-9A-Za-z-_]+)\\b\W*$",
                           pattern)
     tool_pipe = tool_match.group(2)
     tool_name = tool_match.group(4)
     tool_path = lit.util.which(tool_name, config.llvm_tools_dir)
     if not tool_path:
         # Warn, but still provide a substitution.
if re.match(r'icc', config.cc):
     config.available_features.add("compiler-icc")
 elif re.match(r'clang', config.cc):
     config.available_features.add("compiler-clang")
 elif re.match(r'gcc', config.cc):
     config.available_features.add("compiler-gcc")
 elif re.match(r'cl', config.cc):
     config.available_features.add("compiler-msvc")
 
+config.available_features.add(binary_feature(config.have_zlib, "zlib", "no"))
+
 # llvm-config knows whether it is compiled with asserts (and)
 # whether we are operating in release/debug mode.
 import subprocess
 try:
     llvm_config_cmd = \
      subprocess.Popen([os.path.join(llvm_tools_dir, 'llvm-config'),
                      '--build-mode', '--assertion-mode', '--targets-built'],
                       stdout = subprocess.PIPE)

lit/lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.llvm_src_root = "@LLVM_SOURCE_DIR@"
 config.llvm_obj_root = "@LLVM_BINARY_DIR@"
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.lldb_obj_root = "@LLDB_BINARY_DIR@"
 config.lldb_libs_dir = "@LLVM_LIBRARY_OUTPUT_INTDIR@"
 config.lldb_tools_dir = "@LLVM_RUNTIME_OUTPUT_INTDIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.cc = "@LLDB_TEST_C_COMPILER@"
 config.cxx = "@LLDB_TEST_CXX_COMPILER@"
+config.have_zlib = @HAVE_LIBZ@
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
 except KeyError as e:
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LLDB_SOURCE_DIR@/lit/lit.cfg")

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

 // C++ Includes
 #include <vector>
 
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
+#include "llvm/Object/Decompressor.h"
 
 #include "ELFHeader.h"
 
 struct ELFNote {
   elf::elf_word n_namesz;
   elf::elf_word n_descsz;
   elf::elf_word n_type;
 
public:
   GetImageInfoAddress(lldb_private::Target *target) override;
 
   lldb_private::Address GetEntryPointAddress() override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
+  size_t ReadSectionData(lldb_private::Section *section,
+                         lldb_private::DataExtractor &section_data) override;
+
   // Returns number of program headers found in the ELF file.
   size_t GetProgramHeaderCount();
 
   // Returns the program header with the given index.
   const elf::ELFProgramHeader *GetProgramHeaderByIndex(lldb::user_id_t id);
 
   // Returns segment data for the given index.
   lldb_private::DataExtractor GetSegmentDataByIndex(lldb::user_id_t id);
private:
   /// Returns the number of headers parsed.
   size_t ParseProgramHeaders();
 
   /// Parses all section headers present in this object file and populates
   /// m_section_headers.  This method will compute the header list only once.
   /// Returns the number of headers parsed.
   size_t ParseSectionHeaders();
 
+  llvm::Expected<llvm::object::Decompressor>
+  GetSectionDecompressor(const ELFSectionHeaderInfo &sect);
+
+  llvm::Expected<uint64_t> GetSectionFileSize(const ELFSectionHeaderInfo &sect);
+
   static void ParseARMAttributes(lldb_private::DataExtractor &data,
                                  uint64_t length,
                                  lldb_private::ArchSpec &arch_spec);
 
   /// Parses the elf section headers and returns the uuid, debug link name, crc,
   /// archspec.
   static size_t GetSectionHeaderInfo(SectionHeaderColl &section_headers,
                                      lldb_private::DataExtractor &object_data,

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
   if (!name || !name[0] || !ParseSectionHeaders())
     return 0;
   for (size_t i = 1; i < m_section_headers.size(); ++i)
     if (m_section_headers[i].section_name == ConstString(name))
       return i;
   return 0;
 }
 
+llvm::Expected<llvm::object::Decompressor>
+ObjectFileELF::GetSectionDecompressor(const ELFSectionHeaderInfo &sect) {
+  const uint8_t *start = m_data.PeekData(sect.sh_offset, sect.sh_size);
+  if (!start)
+    return llvm::make_error<llvm::StringError>(
+        "Invalid section file address or size.",
+        llvm::inconvertibleErrorCode());
+  llvm::StringRef data(reinterpret_cast<const char *>(start), sect.sh_size);
+
+  return llvm::object::Decompressor::create(
+      sect.section_name.GetStringRef(), data,
+      GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8);
+}
+
+llvm::Expected<uint64_t>
+ObjectFileELF::GetSectionFileSize(const ELFSectionHeaderInfo &sect) {
+  if (sect.sh_type == SHT_NOBITS)
+    return 0;
+
+  if (!(sect.sh_flags & SHF_COMPRESSED))
+    return sect.sh_size;
+
+  auto Decompressor = GetSectionDecompressor(sect);
+  if (!Decompressor)
+    return Decompressor.takeError();
+
+  return Decompressor->getDecompressedSize();
+}
+
 void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES);
+
   if (!m_sections_ap.get() && ParseSectionHeaders()) {
     m_sections_ap.reset(new SectionList());
 
     // Object files frequently have 0 for every section address, meaning we
     // need to compute synthetic addresses in order for "file addresses" from
     // different sections to not overlap
     bool synthaddrs = (CalculateType() == ObjectFile::Type::eTypeObjectFile);
     uint64_t nextaddr = 0;
 
     for (SectionHeaderCollIter I = m_section_headers.begin();
          I != m_section_headers.end(); ++I) {
       const ELFSectionHeaderInfo &header = *I;
 
       ConstString &name = I->section_name;
-      const uint64_t file_size =
-          header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
+      auto file_size = GetSectionFileSize(header);
+      if (!file_size) {
+        LLDB_LOG(log, "Ignoring section {0}: {1}", name,
+                 llvm::toString(file_size.takeError()));
+        continue;
+      }
       const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0;
 
       static ConstString g_sect_name_text(".text");
       static ConstString g_sect_name_data(".data");
       static ConstString g_sect_name_bss(".bss");
       static ConstString g_sect_name_tdata(".tdata");
       static ConstString g_sect_name_tbss(".tbss");
       static ConstString g_sect_name_dwarf_debug_abbrev(".debug_abbrev");
for (SectionHeaderCollIter I = m_section_headers.begin();
           this, // ObjectFile to which this section belongs and should read
                 // section data from.
           SectionIndex(I),     // Section ID.
           name,                // Section name.
           sect_type,           // Section type.
           addr,                // VM address.
           vm_size,             // VM size in bytes of this section.
           header.sh_offset,    // Offset of this section in the file.
-          file_size,           // Size of the section as found in the file.
+          *file_size,          // Size of the section as found in the file.
           log2align,           // Alignment of the section
           header.sh_flags,     // Flags for this section.
           target_bytes_size)); // Number of host bytes per target byte
 
       section_sp->SetPermissions(permissions);
       if (is_thread_specific)
         section_sp->SetIsThreadSpecific(is_thread_specific);
       m_sections_ap->AddSection(section_sp);
case ET_CORE:
     // headers, symbols, or any other flag bits???
     return eStrataUnknown;
 
   default:
     break;
   }
   return eStrataUnknown;
 }
+
+size_t ObjectFileELF::ReadSectionData(Section *section,
+                                      DataExtractor &section_data) {
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES);
+
+  if (section->GetObjectFile() != this)
+    return section->GetObjectFile()->ReadSectionData(section, section_data);
+  if (section->GetFileSize() == 0)
+    return 0;
+  if (!section->Test(SHF_COMPRESSED))
+    return ObjectFile::ReadSectionData(section, section_data);
+
+  const ELFSectionHeaderInfo *info = GetSectionHeaderByIndex(section->GetID());
+  // Decompressor construction checked in GetSectionFileSize. Only valid
+  // sections are created.
+  auto Decompressor = llvm::cantFail(GetSectionDecompressor(*info));
+  auto buffer_sp =
+      std::make_shared<DataBufferHeap>(Decompressor.getDecompressedSize(), 0);
+  if (auto Error = Decompressor.decompress(
+          {reinterpret_cast<char *>(buffer_sp->GetBytes()),
+           buffer_sp->GetByteSize()})) {
+    LLDB_LOG(log, "Decompression of section {0} failed: {1}",
+             section->GetName(), llvm::toString(std::move(Error)));
+    return 0;
+  }
+
+  section_data.SetData(buffer_sp);
+  return buffer_sp->GetByteSize();
+}

tools/lldb-test/lldb-test.cpp

for (const auto &File : opts::module::InputFilenames) {
 
     size_t Count = Sections->GetNumSections(0);
     llvm::outs() << "Showing " << Count << " sections\n";
     for (size_t I = 0; I < Count; ++I) {
       auto S = Sections->GetSectionAtIndex(I);
       assert(S);
       llvm::outs() << "  Section " << I << "\n";
       llvm::outs() << "  Name: " << S->GetName().GetStringRef() << "\n";
-      llvm::outs() << "  Length: " << S->GetByteSize() << "\n";
+      llvm::outs() << "  VM size: " << S->GetByteSize() << "\n";
+      llvm::outs() << "  File size: " << S->GetFileSize() << "\n";
 
-      lldb::offset_t Offset = 0;
       DataExtractor Data;
       S->GetSectionData(Data);
-      llvm::outs() << "  Data: " << Data.GetCStr(&Offset) << "\n\n";
+      llvm::outs() << "  Data: ";
+      for (const uint8_t *B = Data.GetDataStart(); B < Data.GetDataEnd(); ++B)
+        llvm::outs() << llvm::hexdigit(*B >> 4, true)
+                     << llvm::hexdigit(*B & 0xf, true);
+      llvm::outs() << "\n\n";
     }
   }
 }
 
 int main(int argc, const char *argv[]) {
   StringRef ToolName = argv[0];
   sys::PrintStackTraceOnErrorSignal(ToolName);
   PrettyStackTraceProgram X(argc, argv);

unittests/ObjectFile/ELF/TestObjectFileELF.cpp

 //===-- TestObjectFileELF.cpp -----------------------------------*- C++ -*-===//
 //
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
+#include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/HostInfo.h"
-#include "TestingSupport/TestUtilities.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 using namespace lldb;