[llvm-readobj] Generic -string-dump option

[dblaikie]

Looks good - thanks!

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

+RUN: llvm-readobj -p .text %p/Inputs/elf-groups.x86_64 \
+RUN:     | FileCheck %s
+
+CHECK: [     0]  UH..H....E.
+CHECK: [     f]  .E.x.E..
+CHECK: [    1a]  ..}..
+CHECK: [    23]  .}..
+CHECK: [    2b]  1.H...].

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 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;
public:
   virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0;
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name,
                                   size_t Offset) {}
   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
                            const Elf_Sym *FirstSym, StringRef StrTable,
                            bool IsDynamic) = 0;
   virtual void printProgramHeaders(const ELFFile<ELFT> *Obj) = 0;
-  virtual void printSectionAsString(const ELFFile<ELFT> *Obj,
-                                   StringRef SectionName) = 0;
   virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
   virtual void printCGProfile(const ELFFile<ELFT> *Obj) = 0;
   virtual void printNotes(const ELFFile<ELFT> *Obj) = 0;
   virtual void printELFLinkerOptions(const ELFFile<ELFT> *Obj) = 0;
   virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
   const ELFDumper<ELFT> *dumper() const { return Dumper; }
 
public:
   void printRelocations(const ELFO *Obj) override;
   void printSections(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj) override;
   void printDynamicSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printSymtabMessage(const ELFO *Obj, StringRef Name,
                           size_t Offset) override;
   void printProgramHeaders(const ELFO *Obj) override;
-  void printSectionAsString(const ELFO *Obj, StringRef SectionName) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
public:
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
   void printSections(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj) override;
   void printDynamicSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printProgramHeaders(const ELFO *Obj) override;
-  void printSectionAsString(const ELFO *Obj, StringRef SectionName) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:

 void ELFDumper<ELFT>::printRelocations() {
   ELFDumperStyle->printRelocations(Obj);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
   ELFDumperStyle->printProgramHeaders(Obj);
 }
 
-template <class ELFT>
-void ELFDumper<ELFT>::printSectionAsString(StringRef SectionName) {
-  ELFDumperStyle->printSectionAsString(Obj, SectionName);
-}
-
 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
   ELFDumperStyle->printDynamicRelocations(Obj);
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printSymbols() {
   ELFDumperStyle->printSymbols(Obj);
 }
for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
         Sections += unwrapOrError(Obj->getSectionName(&Sec)).str() + " ";
     }
     OS << Sections << "\n";
     OS.flush();
   }
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printSectionAsString(const ELFO *Obj,
-                                         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));
-  OS << "String dump of section '" << SecName << "':\n";
-  const char *SecContent =
-      reinterpret_cast<const char *>(Obj->base() + Sec->sh_offset);
-  const char *CurrentWord = SecContent;
-  const char *SecEnd = SecContent + Sec->sh_size;
-  while (CurrentWord <= SecEnd) {
-    size_t WordSize = strnlen(CurrentWord, SecEnd - CurrentWord);
-    if (!WordSize) {
-      CurrentWord++;
-      continue;
-    }
-    OS << format("[%6tx]", CurrentWord - SecContent);
-    OS << format(" %.*s\n", WordSize, CurrentWord);
-    CurrentWord += WordSize + 1;
-  }
-  OS.flush();
-}
-
-template <class ELFT>
 void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela R,
                                             bool IsRela) {
   SmallString<32> RelocName;
   StringRef SymbolName;
   unsigned Width = ELFT::Is64Bits ? 16 : 8;
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   // First two fields are bit width dependent. The rest of them are after are
   // fixed width.
for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
     W.printNumber("FileSize", Phdr.p_filesz);
     W.printNumber("MemSize", Phdr.p_memsz);
     W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
     W.printNumber("Alignment", Phdr.p_align);
   }
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printSectionAsString(const ELFO *Obj,
-                                          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));
-  W.startLine() << "String dump of section '" << SecName << "':\n";
-  const char *SecContent =
-      reinterpret_cast<const char *>(Obj->base() + Sec->sh_offset);
-  const char *CurrentWord = SecContent;
-  const char *SecEnd = SecContent + Sec->sh_size;
-  while (CurrentWord <= SecEnd) {
-    size_t WordSize = strnlen(CurrentWord, SecEnd - CurrentWord);
-    if (!WordSize) {
-      CurrentWord++;
-      continue;
-    }
-    W.startLine() << "["
-                  << to_string(
-                         format_hex_no_prefix((CurrentWord - SecContent), 6))
-                  << "]";
-    W.startLine() << format(" %.*s\n", WordSize, CurrentWord);
-    CurrentWord += WordSize + 1;
-  }
-}
-
-template <class ELFT>
 void LLVMStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) {
   W.startLine() << "Hash Histogram not implemented!\n";
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printCGProfile(const ELFFile<ELFT> *Obj) {
   ListScope L(W, "CGProfile");
   if (!this->dumper()->getDotCGProfileSec())

tools/llvm-readobj/ObjDumper.h

 //===-- ObjDumper.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 #define LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 
 #include <memory>
 #include <system_error>
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Object/ObjectFile.h"
 
 namespace llvm {
 namespace object {
 class COFFImportFile;
 class ObjectFile;
 }
 namespace codeview {
 class MergingTypeTableBuilder;
public:
   virtual void printDynamicSymbols() = 0;
   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() {}
public:
   virtual void printMachOVersionMin() { }
   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);
+
 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);

tools/llvm-readobj/ObjDumper.cpp

 //===-- ObjDumper.cpp - Base dumper class -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements ObjDumper.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ObjDumper.h"
 #include "Error.h"
+#include "llvm-readobj.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 
 ObjDumper::ObjDumper(ScopedPrinter &Writer) : W(Writer) {}
 
 ObjDumper::~ObjDumper() {
 }
 
+static void printAsPrintable(raw_ostream &W, const uint8_t *Start, size_t Len) {
+  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;
+  unsigned SecIndex = 0;
+  for (object::SectionRef SecRef : Obj->sections()) {
+    if (*StrPtr) {
+      StringRef SectionName;
+
+      if (std::error_code E = SecRef.getName(SectionName))
+        return errorCodeToError(E);
+
+      if (SectionName == SecName)
+        return SecRef;
+    } else if (SecIndex == SectionIndex)
+      return SecRef;
+
+    SecIndex++;
+  }
+  return make_error<StringError>("invalid section reference",
+                                 object::object_error::parse_failed);
+}
+
+void ObjDumper::printSectionAsString(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() << "String dump of section '" << SectionName << "':\n";
+
+  StringRef SectionContent;
+  Section.getContents(SectionContent);
+
+  const uint8_t *SecContent = SectionContent.bytes_begin();
+  const uint8_t *CurrentWord = SecContent;
+  const uint8_t *SecEnd = SectionContent.bytes_end();
+
+  while (CurrentWord <= SecEnd) {
+    size_t WordSize = strnlen(reinterpret_cast<const char *>(CurrentWord),
+                              SecEnd - CurrentWord);
+    if (!WordSize) {
+      CurrentWord++;
+      continue;
+    }
+    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";
 
   for (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
     const uint8_t *TmpSecPtr = SecPtr;

tools/llvm-readobj/llvm-readobj.cpp

if (opts::UnwindInfo)
     Dumper->printUnwindInfo();
   if (opts::DynamicTable)
     Dumper->printDynamicTable();
   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);
+    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);
     });
   if (opts::HashTable)
     Dumper->printHashTable();
   if (opts::GnuHashTable)