Enable readobj to emit readelf like output.

[khemant]

Summary

This is first of a series that will enable to have an alternative dumping style for llvm-readobj tool. This particular patch prints output similar to readelf -h.

[davide]

Hi. I have a question: is there anything in particular that bothers you about the format used currently by readobj? Can't you just use a script to do the postprocessing for you?

[khemant]

Hello Davide,
The present format is good enough to convey the information. It is however not sufficient or sometimes difficult for present users of GNU tools (which are quite ubiquitous) to make a switch as it is complete redesign of the post processing tools they may have based on.

-Hemant

[echristo]

I'm not necessarily against this, but I think the patch should be generic for all targets and I've highlighted an example of where it isn't. Instead of conditionals I think you might just want to abstract out the dumping mechanism as well.

Also, don't forget to add llvm-commits as a subscriber to your patch when you upload it so that email goes to the list right away.

-eric

tools/llvm-readobj/ELFDumper.cpp

723

Example...

[khemant]

What I have noticed is All enums are made to string as is in the LLVM style. However, GNU has different naming conventions such as "W" instead of SHF_WRITE string as is. This will cause a lot of code bloat. An easy solution is to store GNU flavor of string with usuale string inside

[khemant]

My browser submitted the comment before completion. Apologies.
Here is complete comment:
What I have noticed is all enums are made to string as is in the LLVM style. However, GNU has different naming conventions such as "W" instead of SHF_WRITE string as is. This will cause a lot of code bloat. An easy solution is to store GNU flavor of string with usual string inside

template<typename T>
struct EnumEntry {
  StringRef Name;
  T Value;
};

Any thoughts on this?

[khemant]

In D14128#277866, @echristo wrote:

Instead of conditionals I think you might just want to abstract out the dumping mechanism as well.

Can you explain this a bit more.

-Hemant

[khemant]

tools/llvm-readobj/StreamWriter.h

324

This is unnecessary. Formatted raw stream is a better fit. Next patch will make use of that.

[khemant]

Updated to use Formatted stream. Adds the string used by readelf for enums.

[khemant]

Any comments/suggestions? Is this patch a good start for readelf like output format?

[khemant]

tools/llvm-readobj/ELFDumper.cpp

2219

Some versions of Cygwin apparently have newlib that do not support std::to_string. There needs to be a change to remove these calls.

[khemant]

Ping!

[echristo]

Some inline comments.

tools/llvm-readobj/ELFDumper.cpp

1058–1061

Can we get these two things to use the same interface?

2219

Is this an issue for any targets we have a bot for?

tools/llvm-readobj/StreamWriter.cpp

15

Just use stringstream here?

tools/llvm-readobj/StreamWriter.h

29

More descriptive/comment relating it to the option would be good.

[khemant]

Thank you echristo for comments. Modified as per your comments

[khemant]

tools/llvm-readobj/ELFDumper.cpp

2219

Yes. There are a couple of cygwin bots I believe. I found this when I checked this commit:
520b6856921a0d4b9f079f532b53a56199521cf2

[echristo]

One inline comment that'll require a bit of reworking, but otherwise LGTM for now.

Thanks!

-eric

tools/llvm-readobj/ELFDumper.cpp

2181

Ugh.

tools/llvm-readobj/llvm-readobj.h

45 ↗

(On Diff #47264)

Hate to ask at the last minute but can you make this an enum (admittedly with two choices) so that the checks in the code are positive? (e.g. OutputStyle == GNU and OutputStyle == LLVM)

[khemant]

tools/llvm-readobj/llvm-readobj.h

45 ↗

(On Diff #47264)

Sure.

[khemant]

Add enum instead of a bool.

[khemant]

Added enum

[echristo]

Couple inline comments. LGTM.

tools/llvm-readobj/StreamWriter.cpp

5

Needed?

tools/llvm-readobj/llvm-readobj.h

45 ↗

(On Diff #47361)

"Output"

test/MC/Hexagon/basic.ll

 ;; RUN: llc -mtriple=hexagon-unknown-elf -filetype=obj %s -o - \
 ;; RUN: | llvm-readobj -h -r | FileCheck -check-prefix=OBJ %s
 
 ; OBJ: Format: ELF32-hexagon
 ; OBJ: Arch: hexagon
 ; OBJ: AddressSize: 32bit
-; OBJ: Machine: EM_HEXAGON
+; OBJ: Machine: Qualcomm Hexagon

test/tools/llvm-readobj/gnu-file-headers.test

+RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-i386 -gnu-style \
+RUN:   | FileCheck %s -check-prefix ELF32
+RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-x86-64 -gnu-style \
+RUN:   | FileCheck %s -check-prefix ELF64
+
+ELF32:      ELF Header:
+ELF32-NEXT:  Magic:   7f 45 4c 46 01 01 01 03 00 00 00 00 00 00 00 00
+ELF32-NEXT:  Class:                             32-bit
+ELF32-NEXT:  Data:                              LittleEndian
+ELF32-NEXT:  Version:                           1 (current)
+ELF32-NEXT:  OS/ABI:                            GNU/Linux
+ELF32-NEXT:  ABI Version:                       0
+ELF32-NEXT:  Type:                              Relocatable
+ELF32-NEXT:  Machine:                           EM_386
+ELF32-NEXT:  Version:                           0x1
+ELF32-NEXT:  Entry point address:               0x0
+ELF32-NEXT:  Start of program headers:          0 (bytes into file)
+ELF32-NEXT:  Start of section headers:          200 (bytes into file)
+ELF32-NEXT:  Flags:                             0x0
+ELF32-NEXT:  Size of this header:               52 (bytes)
+ELF32-NEXT:  Size of prgram headers:            0 (bytes)
+ELF32-NEXT:  Number of prgram headers:          0
+ELF32-NEXT:  Size of section headers:           40 (bytes)
+ELF32-NEXT:  Number of section headers:         10
+ELF32-NEXT:  Section header string table index: 7
+
+ELF64:     ELF Header:
+ELF64-NEXT:  Magic:   7f 45 4c 46 02 01 01 03 00 00 00 00 00 00 00 00
+ELF64-NEXT:  Class:                             64-bit
+ELF64-NEXT:  Data:                              LittleEndian
+ELF64-NEXT:  Version:                           1 (current)
+ELF64-NEXT:  OS/ABI:                            GNU/Linux
+ELF64-NEXT:  ABI Version:                       0
+ELF64-NEXT:  Type:                              Relocatable
+ELF64-NEXT:  Machine:                           EM_X86_64
+ELF64-NEXT:  Version:                           0x1
+ELF64-NEXT:  Entry point address:               0x0
+ELF64-NEXT:  Start of program headers:          0 (bytes into file)
+ELF64-NEXT:  Start of section headers:          184 (bytes into file)
+ELF64-NEXT:  Flags:                             0x0
+ELF64-NEXT:  Size of this header:               64 (bytes)
+ELF64-NEXT:  Size of prgram headers:            0 (bytes)
+ELF64-NEXT:  Number of prgram headers:          0
+ELF64-NEXT:  Size of section headers:           64 (bytes)
+ELF64-NEXT:  Number of section headers:         10
+ELF64-NEXT:  Section header string table index: 7

tools/llvm-readobj/ELFDumper.cpp

 using namespace llvm::object;
 using namespace ELF;
 
 #define LLVM_READOBJ_ENUM_CASE(ns, enum) \
   case ns::enum: return #enum;
 
 namespace {
 
+template <class ELFT> class DumpStyle;
+
 template<typename ELFT>
 class ELFDumper : public ObjDumper {
 public:
-  ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer);
+  ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer, bool isGNUStyle);
 
   void printFileHeaders() override;
   void printSections() override;
   void printRelocations() override;
   void printDynamicRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
public:
   void printAttributes() override;
   void printMipsPLTGOT() override;
   void printMipsABIFlags() override;
   void printMipsReginfo() override;
 
   void printStackMap() const override;
 
 private:
+  std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
   typedef ELFFile<ELFT> ELFO;
   typedef typename ELFO::Elf_Shdr Elf_Shdr;
   typedef typename ELFO::Elf_Sym Elf_Sym;
   typedef typename ELFO::Elf_Dyn Elf_Dyn;
   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
   typedef typename ELFO::Elf_Rel Elf_Rel;
   typedef typename ELFO::Elf_Rela Elf_Rela;
   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;
public:
 
   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
                                 bool IsDynamic);
   const Elf_Shdr *getDotDynSymSec() const { return DotDynSymSec; }
   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
   ArrayRef<Elf_Word> getShndxTable() { return ShndxTable; }
 };
 
+template <typename ELFT> class DumpStyle {
+public:
+  virtual void printFileHeaders(const typename ELFFile<ELFT>::Elf_Ehdr *e) = 0;
+};
+
+template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
+public:
+  typedef std::pair<StringRef, int> LineEntry;
+  GNUStyle(raw_ostream &os) : OS(os) {}
+
+  void printFileHeaders(const typename ELFFile<ELFT>::Elf_Ehdr *e) override;
+
+  void printLine(ArrayRef<LineEntry> line) {
+    int position = 0;
+    for (const auto &entry : line) {
+      int blanks = position <= entry.second ? entry.second - position : 1;
+      std::string blankSpace(blanks, ' ');
+      OS << blankSpace << entry.first;
+      position = position + blanks + entry.first.size();
+    }
+    OS << "\n";
+  }
+
+private:
+  raw_ostream &OS;
+};
+
+template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
+public:
+  LLVMStyle(StreamWriter &W) : W(W) {}
+
+  void printFileHeaders(const typename ELFFile<ELFT>::Elf_Ehdr *e) override;
+
+private:
+  StreamWriter &W;
+};
+
 template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) {
   if (!Val) {
     error(Val.getError());
     return Default;
   }
 
   return *Val;
 }
 } // namespace
 
 namespace llvm {
 
 template <class ELFT>
-static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
-                                       StreamWriter &Writer,
-                                       std::unique_ptr<ObjDumper> &Result) {
-  Result.reset(new ELFDumper<ELFT>(Obj, Writer));
+static std::error_code
+createELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer,
+                std::unique_ptr<ObjDumper> &Result, bool GNUStyle) {
+  Result.reset(new ELFDumper<ELFT>(Obj, Writer, GNUStyle));
   return readobj_error::success;
 }
 
 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 StreamWriter &Writer,
-                                std::unique_ptr<ObjDumper> &Result) {
+                                std::unique_ptr<ObjDumper> &Result,
+                                bool GNUStyle) {
   // Little-endian 32-bit
   if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
-    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
+    return createELFDumper(ELFObj->getELFFile(), Writer, Result, GNUStyle);
 
   // Big-endian 32-bit
   if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
-    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
+    return createELFDumper(ELFObj->getELFFile(), Writer, Result, GNUStyle);
 
   // Little-endian 64-bit
   if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
-    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
+    return createELFDumper(ELFObj->getELFFile(), Writer, Result, GNUStyle);
 
   // Big-endian 64-bit
   if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
-    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
+    return createELFDumper(ELFObj->getELFFile(), Writer, Result, GNUStyle);
 
   return readobj_error::unsupported_obj_file_format;
 }
 
 } // namespace llvm
 
 // Iterate through the versions needed section, and place each Elf_Vernaux
 // in the VersionMap according to its index.
static const EnumEntry<unsigned> ElfMachineType[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17       ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000     ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000     ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500     ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS   ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C  ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C         ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA     ),
-  LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON      ),
+  {"Qualcomm Hexagon", ELF::EM_HEXAGON       },
   LLVM_READOBJ_ENUM_ENT(ELF, EM_8051         ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X       ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32        ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1        ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X       ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30       ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16       ),
   LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK        ),
static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
 };
 
 template <typename ELFT>
-ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
+ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer,
+                           bool isGNUStyle)
     : ObjDumper(Writer), Obj(Obj) {
 
   SmallVector<const Elf_Phdr *, 4> LoadSegments;
   for (const Elf_Phdr &Phdr : Obj->program_headers()) {
     if (Phdr.p_type == ELF::PT_DYNAMIC) {
       DynamicProgHeader = &Phdr;
       continue;
     }
for (const Elf_Shdr &Sec : Obj->sections()) {
     case ELF::SHT_SYMTAB_SHNDX: {
       ErrorOr<ArrayRef<Elf_Word>> TableOrErr = Obj->getSHNDXTable(Sec);
       error(TableOrErr.getError());
       ShndxTable = *TableOrErr;
       break;
     }
     }
   }
+  if (isGNUStyle)
+    ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer.getOStream()));
+  else
+    ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer));
 }
 
 template <typename ELFT>
 const typename ELFDumper<ELFT>::Elf_Rela *
 ELFDumper<ELFT>::dyn_rela_begin() const {
   if (DynRelaRegion.Size && DynRelaRegion.EntSize != sizeof(Elf_Rela))
     report_fatal_error("Invalid relocation entry size");
   return reinterpret_cast<const Elf_Rela *>(DynRelaRegion.Addr);

 template <typename ELFT>
 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
   return make_range(dyn_rela_begin(), dyn_rela_end());
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printFileHeaders() {
   const Elf_Ehdr *Header = Obj->getHeader();
-
-  {
-    DictScope D(W, "ElfHeader");
-    {
-      DictScope D(W, "Ident");
-      W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0,
-                                                                 4));
-      W.printEnum  ("Class", Header->e_ident[ELF::EI_CLASS],
-                      makeArrayRef(ElfClass));
-      W.printEnum  ("DataEncoding", Header->e_ident[ELF::EI_DATA],
-                      makeArrayRef(ElfDataEncoding));
-      W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]);
-
-      // Handle architecture specific OS/ABI values.
-      if (Header->e_machine == ELF::EM_AMDGPU &&
-          Header->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
-        W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
-      else
-        W.printEnum  ("OS/ABI", Header->e_ident[ELF::EI_OSABI],
-                      makeArrayRef(ElfOSABI));
-      W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]);
-      W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD));
-    }
-
-    W.printEnum  ("Type", Header->e_type, makeArrayRef(ElfObjectFileType));
-    W.printEnum  ("Machine", Header->e_machine, makeArrayRef(ElfMachineType));
-    W.printNumber("Version", Header->e_version);
-    W.printHex   ("Entry", Header->e_entry);
-    W.printHex   ("ProgramHeaderOffset", Header->e_phoff);
-    W.printHex   ("SectionHeaderOffset", Header->e_shoff);
-    if (Header->e_machine == EM_MIPS)
-      W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags),
-                   unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
-                   unsigned(ELF::EF_MIPS_MACH));
-    else
-      W.printFlags("Flags", Header->e_flags);
-    W.printNumber("HeaderSize", Header->e_ehsize);
-    W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize);
-    W.printNumber("ProgramHeaderCount", Header->e_phnum);
-    W.printNumber("SectionHeaderEntrySize", Header->e_shentsize);
-    W.printNumber("SectionHeaderCount", Header->e_shnum);
-    W.printNumber("StringTableSectionIndex", Header->e_shstrndx);
-  }
+  ELFDumperStyle->printFileHeaders(Header);
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printSections() {
   ListScope SectionsD(W, "Sections");
 
   int SectionIndex = -1;
   for (const Elf_Shdr &Sec : Obj->sections()) {
template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
   StringRef StackMapContents;
   ErrorOr<ArrayRef<uint8_t>> StackMapContentsArray =
     Obj->getSectionContents(StackMapSection);
 
   prettyPrintStackMap(
               llvm::outs(),
               StackMapV1Parser<ELFT::TargetEndianness>(*StackMapContentsArray));
 }
+
+template <class ELFT>
+void
+GNUStyle<ELFT>::printFileHeaders(const typename ELFFile<ELFT>::Elf_Ehdr *e) {
+  LineEntry fields[2];
+  OS << "ELF Header:\n";
+  OS << "  Magic:  ";
+  for (int i = 0; i < ELF::EI_NIDENT; i++)
+    OS << format(" %02x", static_cast<int>(e->e_ident[i]));
+  OS << "\n";
+  fields[0].first = "Class:";
+  fields[0].second = 2;
+  enumStr(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass), fields[1].first);
+  fields[1].second = 37;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Data:";
+  enumStr(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding),
+          fields[1].first);
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Version:";
+  std::string tmpstr = to_hexString(e->e_ident[ELF::EI_VERSION]);
+  if (e->e_version == ELF::EV_CURRENT)
+    tmpstr += " (current)";
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "OS/ABI:";
+  enumStr(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI), fields[1].first);
+  printLine(makeArrayRef(fields));
+  fields[0].first = "ABI Version:";
+  tmpstr = to_hexString(e->e_ident[ELF::EI_ABIVERSION]);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Type:";
+  enumStr(e->e_type, makeArrayRef(ElfObjectFileType), fields[1].first);
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Machine:";
+  enumStr(e->e_machine, makeArrayRef(ElfMachineType), fields[1].first);
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Version:";
+  tmpstr = "0x" + to_hexString(e->e_version);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Entry point address:";
+  tmpstr = "0x" + to_hexString(e->e_entry);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Start of program headers:";
+  tmpstr = std::to_string(e->e_phoff) + " (bytes into file)";
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Start of section headers:";
+  tmpstr = std::to_string(e->e_shoff) + " (bytes into file)";
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Flags:";
+  tmpstr = "0x" + to_hexString(e->e_flags);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Size of this header:";
+  tmpstr = std::to_string(e->e_ehsize) + " (bytes)";
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Size of prgram headers:";
+  tmpstr = std::to_string(e->e_phentsize) + " (bytes)";
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Number of prgram headers:";
+  tmpstr = std::to_string(e->e_phnum);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Size of section headers:";
+  tmpstr = std::to_string(e->e_shentsize) + " (bytes)";
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Number of section headers:";
+  tmpstr = std::to_string(e->e_shnum);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+  fields[0].first = "Section header string table index:";
+  tmpstr = std::to_string(e->e_shstrndx);
+  fields[1].first = tmpstr;
+  printLine(makeArrayRef(fields));
+}
+
+template <class ELFT>
+void
+LLVMStyle<ELFT>::printFileHeaders(const typename ELFFile<ELFT>::Elf_Ehdr *e) {
+  {
+    DictScope D(W, "ElfHeader");
+    {
+      DictScope D(W, "Ident");
+      W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4));
+      W.printEnum("Class", e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
+      W.printEnum("DataEncoding", e->e_ident[ELF::EI_DATA],
+                  makeArrayRef(ElfDataEncoding));
+      W.printNumber("FileVersion", e->e_ident[ELF::EI_VERSION]);
+
+      // Handle architecture specific OS/ABI values.
+      if (e->e_machine == ELF::EM_AMDGPU &&
+          e->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
+        W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
+      else
+        W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI],
+                    makeArrayRef(ElfOSABI));
+      W.printNumber("ABIVersion", e->e_ident[ELF::EI_ABIVERSION]);
+      W.printBinary("Unused", makeArrayRef(e->e_ident).slice(ELF::EI_PAD));
+    }
+
+    W.printEnum("Type", e->e_type, makeArrayRef(ElfObjectFileType));
+    W.printEnum("Machine", e->e_machine, makeArrayRef(ElfMachineType));
+    W.printNumber("Version", e->e_version);
+    W.printHex("Entry", e->e_entry);
+    W.printHex("ProgramHeaderOffset", e->e_phoff);
+    W.printHex("SectionHeaderOffset", e->e_shoff);
+    if (e->e_machine == EM_MIPS)
+      W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderMipsFlags),
+                   unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
+                   unsigned(ELF::EF_MIPS_MACH));
+    else
+      W.printFlags("Flags", e->e_flags);
+    W.printNumber("HeaderSize", e->e_ehsize);
+    W.printNumber("ProgramHeaderEntrySize", e->e_phentsize);
+    W.printNumber("ProgramHeaderCount", e->e_phnum);
+    W.printNumber("SectionHeaderEntrySize", e->e_shentsize);
+    W.printNumber("SectionHeaderCount", e->e_shnum);
+    W.printNumber("StringTableSectionIndex", e->e_shstrndx);
+  }
+}

tools/llvm-readobj/ObjDumper.h

 };
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,
                                  StreamWriter &Writer,
                                  std::unique_ptr<ObjDumper> &Result);
 
 std::error_code createELFDumper(const object::ObjectFile *Obj,
                                 StreamWriter &Writer,
-                                std::unique_ptr<ObjDumper> &Result);
+                                std::unique_ptr<ObjDumper> &Result,
+                                bool GNUStyle = false);
 
 std::error_code createMachODumper(const object::ObjectFile *Obj,
                                   StreamWriter &Writer,
                                   std::unique_ptr<ObjDumper> &Result);
 
 void dumpCOFFImportFile(const object::COFFImportFile *File);
 
 } // namespace llvm
 
 #endif

tools/llvm-readobj/StreamWriter.h

 using namespace llvm;
 using namespace llvm::support;
 
 namespace llvm {
 
 template<typename T>
 struct EnumEntry {
   StringRef Name;
   T Value;
 };
 
 struct HexNumber {
   // To avoid sign-extension we have to explicitly cast to the appropriate
   // unsigned type. The overloads are here so that every type that is implicitly
   // convertible to an integer (including enums and endian helpers) can be used
   // without requiring type traits or call-site changes.
   HexNumber(char             Value) : Value(static_cast<unsigned char>(Value)) { }
   HexNumber(signed char      Value) : Value(static_cast<unsigned char>(Value)) { }
   HexNumber(signed short     Value) : Value(static_cast<unsigned short>(Value)) { }
   HexNumber(signed int       Value) : Value(static_cast<unsigned int>(Value)) { }
   HexNumber(signed long      Value) : Value(static_cast<unsigned long>(Value)) { }
   HexNumber(signed long long Value) : Value(static_cast<unsigned long long>(Value)) { }
   HexNumber(unsigned char      Value) : Value(Value) { }
   HexNumber(unsigned short     Value) : Value(Value) { }
   HexNumber(unsigned int       Value) : Value(Value) { }
   HexNumber(unsigned long      Value) : Value(Value) { }
   HexNumber(unsigned long long Value) : Value(Value) { }
   uint64_t Value;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value);
 
+const std::string to_hexString(uint64_t Value, bool UpperCase = true);
+
+template <typename T, typename TEnum>
+bool enumStr(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues, StringRef &Name) {
+  for (const auto &EnumItem : EnumValues) {
+    if (EnumItem.Value == Value) {
+      Name = EnumItem.Name;
+      return true;
+    }
+  }
+  return false;
+}
+
 class StreamWriter {
 public:
   StreamWriter(raw_ostream &OS)
     : OS(OS)
     , IndentLevel(0) {
   }
 
   void flush() {
public:
   HexNumber hex(T Value) {
     return HexNumber(Value);
   }
 
   template<typename T, typename TEnum>
   void printEnum(StringRef Label, T Value,
                  ArrayRef<EnumEntry<TEnum> > EnumValues) {
     StringRef Name;
-    bool Found = false;
-    for (const auto &EnumItem : EnumValues) {
-      if (EnumItem.Value == Value) {
-        Name = EnumItem.Name;
-        Found = true;
-        break;
-      }
-    }
+    bool Found = enumStr(Value, EnumValues, Name);
 
     if (Found) {
       startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
     } else {
       startLine() << Label << ": " << hex(Value) << "\n";
     }
   }
 
struct ListScope {
   ~ListScope() {
     W.unindent();
     W.startLine() << "]\n";
   }
 
   StreamWriter& W;
 };
 
 } // namespace llvm
 
 #endif

tools/llvm-readobj/StreamWriter.cpp

 #include "StreamWriter.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Format.h"
 #include <cctype>
 
 using namespace llvm::support;
 
 namespace llvm {
 
 raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value) {
-  uint64_t N = Value.Value;
+  OS << "0x" << to_hexString(Value.Value);
+  return OS;
+}
+
+const std::string to_hexString(uint64_t Value, bool UpperCase) {
   // Zero is a special case.
-  if (N == 0)
-    return OS << "0x0";
+  if (Value == 0)
+    return "0";
 
   char NumberBuffer[20];
   char *EndPtr = NumberBuffer + sizeof(NumberBuffer);
   char *CurPtr = EndPtr;
-
-  while (N) {
-    uintptr_t X = N % 16;
-    *--CurPtr = (X < 10 ? '0' + X : 'A' + X - 10);
-    N /= 16;
+  char A = 'a';
+  int digits = 0;
+  if (UpperCase)
+    A = 'A';
+
+  while (Value) {
+    uintptr_t X = Value % 16;
+    *--CurPtr = (X < 10 ? '0' + X : A + X - 10);
+    Value /= 16;
+    digits++;
   }
-
-  OS << "0x";
-  return OS.write(CurPtr, EndPtr - CurPtr);
+  return std::string(CurPtr, digits);
 }
 
 void StreamWriter::printBinaryImpl(StringRef Label, StringRef Str,
                                    ArrayRef<uint8_t> Data, bool Block) {
   if (Data.size() > 16)
     Block = true;
 
   if (Block) {

tools/llvm-readobj/llvm-readobj.cpp

PrintStackMap("stackmap",
                 cl::desc("Display contents of stackmap section"));
 
   // -version-info
   cl::opt<bool>
       VersionInfo("version-info",
                   cl::desc("Display ELF version sections (if present)"));
   cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"),
                              cl::aliasopt(VersionInfo));
+
+  cl::opt<bool> GNUStyle("gnu-style", cl::init(false),
+                         cl::desc("print ELF dump simialr to readelf tools"));
+
 } // namespace opts
 
 namespace llvm {
 
 void reportError(Twine Msg) {
   outs() << "\nError reading file: " << Msg << ".\n";
   outs().flush();
   exit(1);

 static std::error_code createDumper(const ObjectFile *Obj, StreamWriter &Writer,
                                     std::unique_ptr<ObjDumper> &Result) {
   if (!Obj)
     return readobj_error::unsupported_file_format;
 
   if (Obj->isCOFF())
     return createCOFFDumper(Obj, Writer, Result);
   if (Obj->isELF())
-    return createELFDumper(Obj, Writer, Result);
+    return createELFDumper(Obj, Writer, Result, opts::GNUStyle);
   if (Obj->isMachO())
     return createMachODumper(Obj, Writer, Result);
 
   return readobj_error::unsupported_obj_file_format;
 }
 
 /// @brief Dumps the specified object file.
 static void dumpObject(const ObjectFile *Obj) {
   StreamWriter Writer(outs());
   std::unique_ptr<ObjDumper> Dumper;
   if (std::error_code EC = createDumper(Obj, Writer, Dumper)) {
     reportError(Obj->getFileName(), EC);
     return;
   }
 
+  if (!opts::GNUStyle) {
     outs() << '\n';
     outs() << "File: " << Obj->getFileName() << "\n";
     outs() << "Format: " << Obj->getFileFormatName() << "\n";
-  outs() << "Arch: "
-         << Triple::getArchTypeName((llvm::Triple::ArchType)Obj->getArch())
-         << "\n";
-  outs() << "AddressSize: " << (8*Obj->getBytesInAddress()) << "bit\n";
+    outs() << "Arch: " << Triple::getArchTypeName(
+                              (llvm::Triple::ArchType)Obj->getArch()) << "\n";
+    outs() << "AddressSize: " << (8 * Obj->getBytesInAddress()) << "bit\n";
     Dumper->printLoadName();
+  }
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
   if (opts::Sections)
     Dumper->printSections();
   if (opts::Relocations)
     Dumper->printRelocations();
   if (opts::DynRelocs)