llvm-readobj: enable GNU style -g option

[khemant]

Summary

Implements equivalent functionality of:
readelf -g

[khemant]

Ping

[• rafael]

tools/llvm-readobj/ELFDumper.cpp

2331 ↗

(On Diff #49648)

replace auto with type.

2339 ↗

(On Diff #49648)

This can be a range loop over Data.slice(1).

[khemant]

Suggestion by Rafael incorporated:
Changed auto to ArrayRef<Elf_Word>
Removed while() {} and used range based loops.

[• rafael]

LGTM

llvm/trunk/test/tools/llvm-readobj/elf-groups.test

 #  int y = 1;
 #  foo(x);
 #  foo(y);
 #  return 0;
 #}
 
 RUN: llvm-readobj -g %p/Inputs/elf-groups.x86_64 \
 RUN:   | FileCheck %s
+RUN: llvm-readobj -g -elf-output-style=GNU %p/Inputs/elf-groups.x86_64 \
+RUN:   | FileCheck --check-prefix="GNU" %s
 CHECK:         Groups {
 CHECK-NEXT:      Group {
 CHECK-NEXT:        Name: .group (92)
 CHECK-NEXT:        Index: 1
 CHECK-NEXT:        Type: COMDAT (0x1)
 CHECK-NEXT:        Signature: _Z3fooIcEvT_
 CHECK-NEXT:        Section(s) in group [
 CHECK-NEXT:          .text._Z3fooIcEvT_ (10)
 CHECK-NEXT:          .rela.text._Z3fooIcEvT_ (11)
 CHECK-NEXT:        ]
 CHECK-NEXT:      }
 CHECK-NEXT:      Group {
 CHECK-NEXT:        Name: .group (92)
 CHECK-NEXT:        Index: 2
 CHECK-NEXT:        Type: COMDAT (0x1)
 CHECK-NEXT:        Signature: _Z3fooIiEvT_
 CHECK-NEXT:        Section(s) in group [
 CHECK-NEXT:          .text._Z3fooIiEvT_ (12)
 CHECK-NEXT:          .rela.text._Z3fooIiEvT_ (13)
 CHECK-NEXT:        ]
 CHECK-NEXT:      }
 
+GNU:COMDAT group section [    1] `.group' [_Z3fooIcEvT_] contains 2 sections:
+GNU-NEXT:   [Index]    Name
+GNU-NEXT:   [   10]   .text._Z3fooIcEvT_
+GNU-NEXT:   [   11]   .rela.text._Z3fooIcEvT_
+GNU:COMDAT group section [    2] `.group' [_Z3fooIiEvT_] contains 2 sections:
+GNU-NEXT:   [Index]    Name
+GNU-NEXT:   [   12]   .text._Z3fooIiEvT_
+GNU-NEXT:   [   13]   .rela.text._Z3fooIiEvT_
+GNU:COMDAT group section [    3] `.group' [_ZNKSt9type_info4nameEv] contains 1 sections:
+GNU-NEXT:   [Index]    Name
+GNU-NEXT:   [   14]   .text._ZNKSt9type_info4nameEv

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

#define LLVM_READOBJ_ENUM_CASE(ns, enum) \
   case ns::enum: return #enum;
 
 #define ENUM_ENT(enum, altName) \
   { #enum, altName, ELF::enum }
 
 #define ENUM_ENT_1(enum) \
   { #enum, #enum, ELF::enum }
 
+#define TYPEDEF_ELF_TYPES(ELFT)                                                \
+  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;                        \
+  typedef typename ELFO::Elf_Phdr Elf_Phdr;                                    \
+  typedef typename ELFO::Elf_Half Elf_Half;                                    \
+  typedef typename ELFO::Elf_Ehdr Elf_Ehdr;                                    \
+  typedef typename ELFO::Elf_Word Elf_Word;                                    \
+  typedef typename ELFO::uintX_t uintX_t;
+
 namespace {
 
 template <class ELFT> class DumpStyle;
 
 /// Represents a contiguous uniform range in the file. We cannot just create a
 /// range directly because when creating one of these from the .dynamic table
 /// the size, entity size and virtual address are different entries in arbitrary
 /// order (DT_REL, DT_RELSZ, DT_RELENT for example).
public:
   ArrayRef<Elf_Word> getShndxTable() { return ShndxTable; }
   StringRef getDynamicStringTable() const { return DynamicStringTable; }
 };
 
 template <typename ELFT> class DumpStyle {
 public:
   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual ~DumpStyle() { }
+  virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
 };
 
 template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
   formatted_raw_ostream OS;
 
 public:
-  typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
+  TYPEDEF_ELF_TYPES(ELFT)
   GNUStyle(StreamWriter &W) : OS(W.getOStream()) {}
   void printFileHeaders(const ELFFile<ELFT> *Obj) override;
+  void printGroupSections(const ELFFile<ELFT> *Obj) override;
 
 private:
   template <typename T, typename TEnum>
   std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
     for (const auto &EnumItem : EnumValues)
       if (EnumItem.Value == Value)
         return EnumItem.AltName;
     return to_hexString(Value);
   }
 };
 
 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 public:
-  typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
+  TYPEDEF_ELF_TYPES(ELFT)
   LLVMStyle(StreamWriter &W) : W(W) {}
-
   void printFileHeaders(const ELFFile<ELFT> *Obj) override;
+  void printGroupSections(const ELFFile<ELFT> *Obj) override;
 
 private:
   StreamWriter &W;
 };
 
 } // namespace
 
 namespace llvm {
template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
   ArrayRef<uint8_t> StackMapContentsArray =
       unwrapOrError(Obj->getSectionContents(StackMapSection));
 
   prettyPrintStackMap(llvm::outs(), StackMapV1Parser<ELFT::TargetEndianness>(
                                         StackMapContentsArray));
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printGroupSections() {
-  DictScope Lists(W, "Groups");
-  uint32_t SectionIndex = 0;
-  bool HasGroups = false;
-  for (const Elf_Shdr &Sec : Obj->sections()) {
-    if (Sec.sh_type == ELF::SHT_GROUP) {
-      HasGroups = true;
-      const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
-      StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
-      const Elf_Sym *Sym = Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info);
-      auto Data = unwrapOrError(
-          Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
-      DictScope D(W, "Group");
-      StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
-      W.printNumber("Name", Name, Sec.sh_name);
-      W.printNumber("Index", SectionIndex);
-      W.printHex("Type", getGroupType(Data[0]), Data[0]);
-      W.startLine() << "Signature: " << StrTable.data() + Sym->st_name << "\n";
-      {
-        ListScope L(W, "Section(s) in group");
-        size_t Member = 1;
-        while (Member < Data.size()) {
-          auto Sec = unwrapOrError(Obj->getSection(Data[Member]));
-          const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
-          W.startLine() << Name << " (" << Data[Member++] << ")\n";
-        }
-      }
-    }
-    ++SectionIndex;
-  }
-  if (!HasGroups)
-    W.startLine() << "There are no group sections in the file.\n";
+  ELFDumperStyle->printGroupSections(Obj);
 }
 
 static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
                                StringRef Str2) {
   OS.PadToColumn(2u);
   OS << Str1;
   OS.PadToColumn(37u);
   OS << Str2 << "\n";
void GNUStyle<ELFT>::printFileHeaders(const ELFFile<ELFT> *Obj) {
   Str = to_string(e->e_shentsize) + " (bytes)";
   printFields(OS, "Size of section headers:", Str);
   Str = to_string(e->e_shnum);
   printFields(OS, "Number of section headers:", Str);
   Str = to_string(e->e_shstrndx);
   printFields(OS, "Section header string table index:", Str);
 }
 
+template <class ELFT> void GNUStyle<ELFT>::printGroupSections(const ELFO *Obj) {
+  uint32_t SectionIndex = 0;
+  bool HasGroups = false;
+  for (const Elf_Shdr &Sec : Obj->sections()) {
+    if (Sec.sh_type == ELF::SHT_GROUP) {
+      HasGroups = true;
+      const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
+      StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
+      const Elf_Sym *Signature =
+          Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info);
+      ArrayRef<Elf_Word> Data = unwrapOrError(
+          Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
+      StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
+      OS << "\n" << getGroupType(Data[0]) << " group section ["
+         << format_decimal(SectionIndex, 5) << "] `" << Name << "' ["
+         << StrTable.data() + Signature->st_name << "] contains "
+         << (Data.size() - 1) << " sections:\n"
+         << "   [Index]    Name\n";
+      for (auto &Ndx : Data.slice(1)) {
+        auto Sec = unwrapOrError(Obj->getSection(Ndx));
+        const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
+        OS << "   [" << format_decimal(Ndx, 5) << "]   " << Name
+           << "\n";
+      }
+    }
+    ++SectionIndex;
+  }
+  if (!HasGroups)
+    OS << "There are no section groups in this file.\n";
+}
+
 template <class ELFT>
 void LLVMStyle<ELFT>::printFileHeaders(const ELFFile<ELFT> *Obj) {
   const Elf_Ehdr *e = Obj->getHeader();
   {
     DictScope D(W, "ElfHeader");
     {
       DictScope D(W, "Ident");
       W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4));
const Elf_Ehdr *e = Obj->getHeader();
     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);
   }
 }
+
+template <class ELFT>
+void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) {
+  DictScope Lists(W, "Groups");
+  uint32_t SectionIndex = 0;
+  bool HasGroups = false;
+  for (const Elf_Shdr &Sec : Obj->sections()) {
+    if (Sec.sh_type == ELF::SHT_GROUP) {
+      HasGroups = true;
+      const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
+      StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
+      const Elf_Sym *Sym = Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info);
+      auto Data = unwrapOrError(
+          Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
+      DictScope D(W, "Group");
+      StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
+      W.printNumber("Name", Name, Sec.sh_name);
+      W.printNumber("Index", SectionIndex);
+      W.printHex("Type", getGroupType(Data[0]), Data[0]);
+      W.startLine() << "Signature: " << StrTable.data() + Sym->st_name << "\n";
+      {
+        ListScope L(W, "Section(s) in group");
+        size_t Member = 1;
+        while (Member < Data.size()) {
+          auto Sec = unwrapOrError(Obj->getSection(Data[Member]));
+          const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
+          W.startLine() << Name << " (" << Data[Member++] << ")\n";
+        }
+      }
+    }
+    ++SectionIndex;
+  }
+  if (!HasGroups)
+    W.startLine() << "There are no group sections in the file.\n";
+}