[llvm-readobj] Generic hex-dump option

[paulsemel]

Summary

Helpers are available to make this option file format independant. This patch adds the feature for Wasm file format. It doesn't change the behavior of the other file format handling.

[dblaikie]

A more detailed commit message (is this meant to change behavior? what's change? if it's mostly/only a refactor - what's the end goal? (or is this retroactive tidy-up?)) would be good.

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

10 ↗

(On Diff #156268)

What's happening in these test changes?

[paulsemel]

Fixed the behavior between ELF and other file formats.

[paulsemel]

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

10 ↗

(On Diff #156268)

That's a mistake from my part, should have paid more attention ! The problem is that ELF is the only format with 0 based indexes.

[dblaikie]

Looks good - though needs a test case for the new functionality (a WAsm example, going from the patch description).

[paulsemel]

Added a WAsm test

[dblaikie]

Looks good - thanks!

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

 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.
+
+RUN: llvm-readobj -x 1 %p/Inputs/trivial.obj.wasm \
+RUN:     | FileCheck %s --check-prefix WASM
+
+WASM: 0x00000000 03600001 7f60017f 017f6001 7f00 .`...`....`...

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 printDynamicRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders() 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 printMachODysymtab() { }
   virtual void printMachOSegment() { }
   virtual void printMachOIndirectSymbols() { }
   virtual void printMachOLinkerOptions() { }
 
   virtual void printStackMap() const = 0;
 
   void printSectionAsString(const object::ObjectFile *Obj, StringRef SecName);
+  void printSectionAsHex(const object::ObjectFile *Obj, StringRef SecName);
 
 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

for (size_t i = 0; i < Len; i++)
     W << (isprint(Start[i]) ? static_cast<char>(Start[i]) : '.');
 }
 
 static Expected<object::SectionRef>
 getSecNameOrIndexAsSecRef(const object::ObjectFile *Obj, StringRef SecName) {
   char *StrPtr;
   long SectionIndex = strtol(SecName.data(), &StrPtr, 10);
   object::SectionRef Section;
-  long SecIndex = 0;
+  long SecIndex;
+  if (Obj->isELF())
+    SecIndex = 0;
+  else
+    SecIndex = 1;
   for (object::SectionRef SecRef : Obj->sections()) {
     if (*StrPtr) {
       StringRef SectionName;
 
       if (std::error_code E = SecRef.getName(SectionName))
         return errorCodeToError(E);
 
       if (SectionName == SecName)
while (CurrentWord <= SecEnd) {
     }
     W.startLine() << format("[%6tx] ", CurrentWord - SecContent);
     printAsPrintable(W.startLine(), CurrentWord, WordSize);
     W.startLine() << '\n';
     CurrentWord += WordSize + 1;
   }
 }
 
-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";
+void ObjDumper::printSectionAsHex(const object::ObjectFile *Obj,
+                                  StringRef SecName) {
+  Expected<object::SectionRef> SectionRefOrError =
+      getSecNameOrIndexAsSecRef(Obj, SecName);
+  if (!SectionRefOrError)
+    error(std::move(SectionRefOrError));
+  object::SectionRef Section = *SectionRefOrError;
+  StringRef SectionName;
+
+  if (std::error_code E = Section.getName(SectionName))
+    error(E);
+  W.startLine() << "Hex dump of section '" << SectionName << "':\n";
+
+  StringRef SectionContent;
+  Section.getContents(SectionContent);
+  const uint8_t *SecContent = SectionContent.bytes_begin();
+  const uint8_t *SecEnd = SecContent + SectionContent.size();
 
   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 (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
     // 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() << '.';
-    }
+    for (i = 0; TmpSecPtr + i < SecEnd && i < 16; ++i)
+      W.startLine() << (isprint(TmpSecPtr[i]) ? static_cast<char>(TmpSecPtr[i])
+                                              : '.');
 
     W.startLine() << '\n';
   }
 }
 
 } // namespace llvm

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

if (opts::NeededLibraries)
     Dumper->printNeededLibraries();
   if (opts::ProgramHeaders)
     Dumper->printProgramHeaders();
   if (!opts::StringDump.empty())
     llvm::for_each(opts::StringDump, [&Dumper, Obj](StringRef SectionName) {
       Dumper->printSectionAsString(Obj, SectionName);
     });
   if (!opts::HexDump.empty())
-    llvm::for_each(opts::HexDump, [&Dumper](StringRef SectionName) {
-      Dumper->printSectionAsHex(SectionName);
+    llvm::for_each(opts::HexDump, [&Dumper, Obj](StringRef SectionName) {
+      Dumper->printSectionAsHex(Obj, SectionName);
     });
   if (opts::HashTable)
     Dumper->printHashTable();
   if (opts::GnuHashTable)
     Dumper->printGnuHashTable();
   if (opts::VersionInfo)
     Dumper->printVersionInfo();
   if (Obj->isELF()) {