[llvm-readobj] Add -hex-dump (-x) option

[paulsemel]

Summary

This follows the same behavior as GNU objcopy --hex-dump option.

[dblaikie]

Could you add a test case?

[paulsemel]

In D48281#1135274, @dblaikie wrote:

Could you add a test case?

You're totally right. Plus, there is a little bug in the code, will fix it and upload the tests in the same time today !

[paulsemel]

Fixed overflow on section when section end is inbetween rows.
Added test.

[dblaikie]

Could/should this be format-agnostic? (looks like this change only implements the functionality for ELF - but I'd imagine the existence of sections and their contents might be general enough to allow for different object file formats to support this without each format having custom handling)

[paulsemel]

In D48281#1138290, @dblaikie wrote:

Could/should this be format-agnostic? (looks like this change only implements the functionality for ELF - but I'd imagine the existence of sections and their contents might be general enough to allow for different object file formats to support this without each format having custom handling)

Well, I think it is actually feasable. I'm not really familiar with all the formats handled by readobj, but I can give it a shot !

[paulsemel]

Added other binary formats handling.

[dblaikie]

include/llvm/Object/MachO.h

307–309 ↗

(On Diff #152467)

Is there really no suitable existing API for getting the contents of a section? (like the ones above that use DataRefImpl?)

& these two APIs using different schemes (one returning Expected<SectionRef> the other returning error_code and taking a SectionRef out parameter) seem unnecessarily inconsistent - can they use a matching approach (I'd favor the Expected<SectionRef> option)?

Maybe @echristo has some ideas/familiarity here.

tools/llvm-readobj/COFFDumper.cpp

665 ↗

(On Diff #152467)

Is there a need for bounds checking before casting that long down to an integer? (what's the intended behavior when the value is too large to fit in an integer? Is that tested?)

697 ↗

(On Diff #152467)

Typo 'Least' -> 'Last' (or Lastly)?

tools/llvm-readobj/ELFDumper.cpp

153 ↗

(On Diff #152467)

Does this need support in each format explicitly - or is there a way to generalize it over all formats in one place? (ie: could all formats support the ability to retrieve the section contents, and then the printing would be generalized over that)

Certainly looks like there's a lot of duplication in the different dumper function implementations - at least would be good to pull a lot of that out into a generalized helper even if there is some format-specific stuff to be handled (though I'm not sure if there should be any format-specific stuff to handle).

[echristo]

include/llvm/Object/MachO.h

307–309 ↗

(On Diff #152467)

In particular, I'd have thought we wanted getSectionContents here?

tools/llvm-readobj/ELFDumper.cpp

153 ↗

(On Diff #152467)

+1

[paulsemel]

include/llvm/Object/MachO.h

307–309 ↗

(On Diff #152467)

Well, there is an API for getting section content, but it requires to have to so called section.
Here I want to get the section either by index or by name, so I don't see any problem with the two functions. (this scheme was already present for the ELF and COFF files, just added it to MachO)

Yes I agree about the two different schemes, I'm gonna change it right now :)

tools/llvm-readobj/COFFDumper.cpp

665 ↗

(On Diff #152467)

Well, that's not a problem related to this patch, that's a more general problem about this function taking an integer..

697 ↗

(On Diff #152467)

Yes, sorry about it :/

tools/llvm-readobj/ELFDumper.cpp

153 ↗

(On Diff #152467)

I actually didn't see any generic helper in this project, so I duplicated. I definitely think that it is doable.
Do you have an idea where I can write generic functions with this architecture ?

[paulsemel]

Refactor code to create a generic function.
Applied David and Eric' suggestions.

[dblaikie]

Perhaps generalized further still - if every format has the ability to retrieve a section by name or by index and return a generic llvm::object::SectionRef - then the code can be written in general over that, query the SectionRef for the name and contents, etc?

[paulsemel]

In D48281#1150111, @dblaikie wrote:

Perhaps generalized further still - if every format has the ability to retrieve a section by name or by index and return a generic llvm::object::SectionRef - then the code can be written in general over that, query the SectionRef for the name and contents, etc?

Well, I thought about it, but the problem is that the interface are a bit different.. I tried to change the interface COFF (which is the only one that needs changes), but it would break too much things if I do so..

[paulsemel]

In D48281#1150535, @paulsemel wrote:

In D48281#1150111, @dblaikie wrote:

Perhaps generalized further still - if every format has the ability to retrieve a section by name or by index and return a generic llvm::object::SectionRef - then the code can be written in general over that, query the SectionRef for the name and contents, etc?

Well, I thought about it, but the problem is that the interface are a bit different.. I tried to change the interface COFF (which is the only one that needs changes), but it would break too much things if I do so..

Just to add one more argument to this. I think that getting the sections by Index/Name is not implemented as virtual method in ObjectFile. Thus, we might better do this way not to get confused on what can (for the moment) be generic and what can't be.
So what do you think ?

[paulsemel]

ping @dblaikie :)
I'd really like to go forward on this one, to be able to refact the -p option :)

[dblaikie]

OK

[paulsemel]

Ok I'm going to land this one, so that I can refactor the (-p) option, with the helpers created in this patch !

llvm/trunk/include/llvm/Object/COFF.h

if (!PE32Header && !PE32PlusHeader)
       return nullptr;
     return reinterpret_cast<const dos_header *>(base());
   }
   std::error_code getPE32Header(const pe32_header *&Res) const;
   std::error_code getPE32PlusHeader(const pe32plus_header *&Res) const;
   std::error_code getDataDirectory(uint32_t index,
                                    const data_directory *&Res) const;
   std::error_code getSection(int32_t index, const coff_section *&Res) const;
+  std::error_code getSection(StringRef SectionName,
+                             const coff_section *&Res) const;
 
   template <typename coff_symbol_type>
   std::error_code getSymbol(uint32_t Index,
                             const coff_symbol_type *&Res) const {
     if (Index >= getNumberOfSymbols())
       return object_error::parse_failed;
 
     Res = reinterpret_cast<coff_symbol_type *>(getSymbolTable()) + Index;

llvm/trunk/include/llvm/Object/MachO.h

public:
   std::error_code getSectionName(DataRefImpl Sec,
                                  StringRef &Res) const override;
   uint64_t getSectionAddress(DataRefImpl Sec) const override;
   uint64_t getSectionIndex(DataRefImpl Sec) const override;
   uint64_t getSectionSize(DataRefImpl Sec) const override;
   std::error_code getSectionContents(DataRefImpl Sec,
                                      StringRef &Res) const override;
   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
+  Expected<SectionRef> getSection(unsigned SectionIndex) const;
+  Expected<SectionRef> getSection(StringRef SectionName) const;
   bool isSectionCompressed(DataRefImpl Sec) const override;
   bool isSectionText(DataRefImpl Sec) const override;
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
   bool isSectionBitcode(DataRefImpl Sec) const override;
 
   /// When dsymutil generates the companion file, it strips all unnecessary

llvm/trunk/lib/Object/COFFObjectFile.cpp

std::error_code COFFObjectFile::getSection(int32_t Index,
   if (static_cast<uint32_t>(Index) <= getNumberOfSections()) {
     // We already verified the section table data, so no need to check again.
     Result = SectionTable + (Index - 1);
     return std::error_code();
   }
   return object_error::parse_failed;
 }
 
+std::error_code COFFObjectFile::getSection(StringRef SectionName,
+                                           const coff_section *&Result) const {
+  Result = nullptr;
+  StringRef SecName;
+  for (const SectionRef &Section : sections()) {
+    if (std::error_code E = Section.getName(SecName))
+      return E;
+    if (SecName == SectionName) {
+      Result = getCOFFSection(Section);
+      return std::error_code();
+    }
+  }
+  return object_error::parse_failed;
+}
+
 std::error_code COFFObjectFile::getString(uint32_t Offset,
                                           StringRef &Result) const {
   if (StringTableSize <= 4)
     // Tried to get a string from an empty string table.
     return object_error::parse_failed;
   if (Offset >= StringTableSize)
     return object_error::unexpected_eof;
   Result = StringRef(StringTable + Offset);

llvm/trunk/lib/Object/MachOObjectFile.cpp

uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
   } else {
     MachO::section Sect = getSection(Sec);
     Align = Sect.align;
   }
 
   return uint64_t(1) << Align;
 }
 
+Expected<SectionRef> MachOObjectFile::getSection(unsigned SectionIndex) const {
+  if (SectionIndex < 1 || SectionIndex > Sections.size())
+    return malformedError("bad section index: " + Twine((int)SectionIndex));
+
+  DataRefImpl DRI;
+  DRI.d.a = SectionIndex - 1;
+  return SectionRef(DRI, this);
+}
+
+Expected<SectionRef> MachOObjectFile::getSection(StringRef SectionName) const {
+  StringRef SecName;
+  for (const SectionRef &Section : sections()) {
+    if (std::error_code E = Section.getName(SecName))
+      return errorCodeToError(E);
+    if (SecName == SectionName) {
+      return Section;
+    }
+  }
+  return errorCodeToError(object_error::parse_failed);
+}
+
 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const {
   return false;
 }
 
 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
   uint32_t Flags = getSectionFlags(*this, Sec);
   return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
 }

llvm/trunk/test/tools/llvm-readobj/print-hex.test

+RUN: llvm-readobj -x .strtab %p/Inputs/trivial.obj.elf-x86-64 \
+RUN:     | FileCheck %s --check-prefix ELF
+
+ELF: 0x00000000 00747269 7669616c 2e6c6c00 6d61696e .trivial.ll.main
+ELF: 0x00000010 002e4c2e 73747200 70757473 00536f6d ..L.str.puts.Som
+ELF: 0x00000020 654f7468 65724675 6e637469 6f6e005f eOtherFunction._
+ELF: 0x00000030 474c4f42 414c5f4f 46465345 545f5441 GLOBAL_OFFSET_TA
+ELF: 0x00000040 424c455f 00                         BLE_.
+
+RUN: llvm-readobj -x 1 %p/Inputs/trivial.obj.coff-x86-64 \
+RUN:     | FileCheck %s --check-prefix COFF
+
+COFF: 0x00000000 4883ec28 488d0d00 000000e8 00000000 H..(H...........
+COFF: 0x00000010 e8000000 0031c048 83c428c3          .....1.H..(.
+
+RUN: llvm-readobj -x 1 %p/Inputs/trivial.obj.macho-x86-64 \
+RUN:     | FileCheck %s --check-prefix MACHO
+
+MACHO: 0x00000000 50488d3d 00000000 e8000000 00e80000 PH.=............
+MACHO: 0x00000010 000031c0 5ac3                       ..1.Z.

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj), Writer(Writer), Types(100) {}
 
   void printFileHeaders() override;
   void printSections() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
+  void printSectionAsHex(StringRef StringName) override;
 
   void printNeededLibraries() override;
 
   void printCOFFImports() override;
   void printCOFFExports() override;
   void printCOFFDirectives() override;
   void printCOFFBaseReloc() override;
   void printCOFFDebugDirectory() override;
void COFFDumper::printFileHeaders() {
   error(Obj->getPE32PlusHeader(PEPlusHeader));
   if (PEPlusHeader)
     printPEHeader<pe32plus_header>(PEPlusHeader);
 
   if (const dos_header *DH = Obj->getDOSHeader())
     printDOSHeader(DH);
 }
 
+void COFFDumper::printSectionAsHex(StringRef SectionName) {
+  char *StrPtr;
+  long SectionIndex = strtol(SectionName.data(), &StrPtr, 10);
+  const coff_section *Sec;
+  if (*StrPtr)
+    error(Obj->getSection(SectionName, Sec));
+  else {
+    error(Obj->getSection((int)SectionIndex, Sec));
+    if (!Sec)
+      return error(object_error::parse_failed);
+  }
+
+  StringRef SecName;
+  error(Obj->getSectionName(Sec, SecName));
+
+  ArrayRef<uint8_t> Content;
+  error(Obj->getSectionContents(Sec, Content));
+  const uint8_t *SecContent = Content.data();
+
+  SectionHexDump(SecName, SecContent, Content.size());
+}
+
 void COFFDumper::printDOSHeader(const dos_header *DH) {
   DictScope D(W, "DOSHeader");
   W.printString("Magic", StringRef(DH->Magic, sizeof(DH->Magic)));
   W.printNumber("UsedBytesInTheLastPage", DH->UsedBytesInTheLastPage);
   W.printNumber("FileSizeInPages", DH->FileSizeInPages);
   W.printNumber("NumberOfRelocationItems", DH->NumberOfRelocationItems);
   W.printNumber("HeaderSizeInParagraphs", DH->HeaderSizeInParagraphs);
   W.printNumber("MinimumExtraParagraphs", DH->MinimumExtraParagraphs);

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

public:
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders() override;
   void printSectionAsString(StringRef StringName) override;
+  void printSectionAsHex(StringRef StringName) override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
   void printVersionInfo() override;
   void printGroupSections() override;
 
   void printAttributes() override;
   void printMipsPLTGOT() override;
public:
   const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; }
   const DynRegionInfo &getDynRelrRegion() const { return DynRelrRegion; }
   const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; }
   const Elf_Hash *getHashTable() const { return HashTable; }
   const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; }
 };
 
 template <class ELFT>
+void ELFDumper<ELFT>::printSectionAsHex(StringRef SectionName) {
+  char *StrPtr;
+  long SectionIndex = strtol(SectionName.data(), &StrPtr, 10);
+  const Elf_Shdr *Sec;
+  if (*StrPtr)
+    Sec = unwrapOrError(Obj->getSection(SectionName));
+  else
+    Sec = unwrapOrError(Obj->getSection((unsigned int)SectionIndex));
+
+  StringRef SecName = unwrapOrError(Obj->getSectionName(Sec));
+  const uint8_t *SecContent =
+      reinterpret_cast<const uint8_t *>(Obj->base() + Sec->sh_offset);
+
+  SectionHexDump(SecName, SecContent, Sec->sh_size);
+}
+
+template <class ELFT>
 void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
   StringRef StrTable, SymtabName;
   size_t Entries = 0;
   Elf_Sym_Range Syms(nullptr, nullptr);
   if (IsDynamic) {
     StrTable = DynamicStringTable;
     Syms = dynamic_symbols();
     SymtabName = DynSymtabName;

llvm/trunk/tools/llvm-readobj/MachODumper.cpp

public:
 
   void printFileHeaders() override;
   void printSections() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
+  void printSectionAsHex(StringRef SectionName) override;
 
   void printNeededLibraries() override;
 
   // MachO-specific.
   void printMachODataInCode() override;
   void printMachOVersionMin() override;
   void printMachODysymtab() override;
   void printMachOSegment() override;
void MachODumper::printStackMap() const {
   if (Obj->isLittleEndian())
     prettyPrintStackMap(
         W, StackMapV2Parser<support::little>(StackMapContentsArray));
   else
     prettyPrintStackMap(W,
                         StackMapV2Parser<support::big>(StackMapContentsArray));
 }
 
+void MachODumper::printSectionAsHex(StringRef SectionName) {
+  char *StrPtr;
+  long SectionIndex = strtol(SectionName.data(), &StrPtr, 10);
+  SectionRef SecTmp;
+  const SectionRef *Sec = &SecTmp;
+  if (*StrPtr)
+    SecTmp = unwrapOrError(Obj->getSection(SectionName));
+  else
+    SecTmp = unwrapOrError(Obj->getSection((unsigned int)SectionIndex));
+
+  StringRef SecName;
+  error(Sec->getName(SecName));
+
+  StringRef Data;
+  error(Sec->getContents(Data));
+  const uint8_t *SecContent = reinterpret_cast<const uint8_t *>(Data.data());
+
+  SectionHexDump(SecName, SecContent, Data.size());
+}
+
 void MachODumper::printNeededLibraries() {
   ListScope D(W, "NeededLibraries");
 
   using LibsTy = std::vector<StringRef>;
   LibsTy Libs;
 
   for (const auto &Command : Obj->load_commands()) {
     if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||

llvm/trunk/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }
   virtual void printNeededLibraries() { }
   virtual void printProgramHeaders() { }
   virtual void printSectionAsString(StringRef SectionName) {}
+  virtual void printSectionAsHex(StringRef SectionName) {}
   virtual void printHashTable() { }
   virtual void printGnuHashTable() { }
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistogram() {}
   virtual void printCGProfile() {}
   virtual void printNotes() {}
public:
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }
 
   virtual void printStackMap() const = 0;
 
 protected:
   ScopedPrinter &W;
+  void SectionHexDump(StringRef SecName, const uint8_t *Section, size_t Size);
 };
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,
                                  ScopedPrinter &Writer,
                                  std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 ScopedPrinter &Writer,

llvm/trunk/tools/llvm-readobj/ObjDumper.cpp

 
 namespace llvm {
 
 ObjDumper::ObjDumper(ScopedPrinter &Writer) : W(Writer) {}
 
 ObjDumper::~ObjDumper() {
 }
 
+void ObjDumper::SectionHexDump(StringRef SecName, const uint8_t *Section,
+                               size_t Size) {
+  const uint8_t *SecContent = Section;
+  const uint8_t *SecEnd = Section + Size;
+  W.startLine() << "Hex dump of section '" << SecName << "':\n";
+
+  for (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
+    const uint8_t *TmpSecPtr = SecPtr;
+    uint8_t i;
+    uint8_t k;
+
+    W.startLine() << format_hex(SecPtr - SecContent, 10);
+    W.startLine() << ' ';
+    for (i = 0; TmpSecPtr < SecEnd && i < 4; ++i) {
+      for (k = 0; TmpSecPtr < SecEnd && k < 4; k++, TmpSecPtr++) {
+        uint8_t Val = *(reinterpret_cast<const uint8_t *>(TmpSecPtr));
+        W.startLine() << format_hex_no_prefix(Val, 2);
+      }
+      W.startLine() << ' ';
+    }
+
+    // We need to print the correct amount of spaces to match the format.
+    // We are adding the (4 - i) last rows that are 8 characters each.
+    // Then, the (4 - i) spaces that are in between the rows.
+    // Least, if we cut in a middle of a row, we add the remaining characters,
+    // which is (8 - (k * 2))
+    if (i < 4)
+      W.startLine() << format("%*c", (4 - i) * 8 + (4 - i) + (8 - (k * 2)),
+                              ' ');
+
+    TmpSecPtr = SecPtr;
+    for (i = 0; TmpSecPtr + i < SecEnd && i < 16; ++i) {
+      if (isprint(TmpSecPtr[i]))
+        W.startLine() << TmpSecPtr[i];
+      else
+        W.startLine() << '.';
+    }
+
+    W.startLine() << '\n';
+  }
+}
+
 } // namespace llvm

llvm/trunk/tools/llvm-readobj/llvm-readobj.cpp

cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"),
                                 cl::aliasopt(ProgramHeaders));
 
   // -string-dump
   cl::list<std::string> StringDump("string-dump", cl::desc("<number|name>"),
                                    cl::ZeroOrMore);
   cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"),
                             cl::aliasopt(StringDump));
 
+  // -hex-dump
+  cl::list<std::string> HexDump("hex-dump", cl::desc("<number|name>"),
+                                cl::ZeroOrMore);
+  cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"),
+                         cl::aliasopt(HexDump));
+
   // -hash-table
   cl::opt<bool> HashTable("hash-table",
     cl::desc("Display ELF hash table"));
 
   // -gnu-hash-table
   cl::opt<bool> GnuHashTable("gnu-hash-table",
     cl::desc("Display ELF .gnu.hash section"));
 
static void dumpObject(const ObjectFile *Obj, ScopedPrinter &Writer) {
   if (opts::NeededLibraries)
     Dumper->printNeededLibraries();
   if (opts::ProgramHeaders)
     Dumper->printProgramHeaders();
   if (!opts::StringDump.empty())
     llvm::for_each(opts::StringDump, [&Dumper](StringRef SectionName) {
       Dumper->printSectionAsString(SectionName);
     });
+  if (!opts::HexDump.empty())
+    llvm::for_each(opts::HexDump, [&Dumper](StringRef SectionName) {
+      Dumper->printSectionAsHex(SectionName);
+    });
   if (opts::HashTable)
     Dumper->printHashTable();
   if (opts::GnuHashTable)
     Dumper->printGnuHashTable();
   if (opts::VersionInfo)
     Dumper->printVersionInfo();
   if (Obj->isELF()) {
     if (opts::ELFLinkerOptions)