llvm-readobj: Display section group information in ELF files

[khemant]

Summary

This is similar to readelf -g elf.obj option. It shows all group sections (SHT_GROUP) with their signatures and corresponding member sections.

[echristo]

OK.

llvm/trunk/docs/CommandGuide/llvm-readobj.rst

 .. option:: -needed-libs
 
  Display the needed libraries (only for ELF object files).
 
 .. option:: -program-headers
 
  Display the ELF program headers (only for ELF object files).
 
+.. option:: -elf-section-groups, -g
+
+ Display section groups (only for ELF object files).
+
 EXIT STATUS
 -----------
 
 :program:`llvm-readobj` returns 0.

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

+# Source file compiled:
+##include <iostream>
+# #include <typeinfo>
+#template <class A>
+#void foo(A variable) {
+#  std::cout << "foo is " << typeid(A).name() << "\n";
+#}
+#int main () {
+#  char x = 'x';
+#  int y = 1;
+#  foo(x);
+#  foo(y);
+#  return 0;
+#}
+
+RUN: llvm-readobj -g %p/Inputs/elf-groups.x86_64 \
+RUN:   | FileCheck %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:      }
+

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

public:
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders() override;
   void printHashTable() override;
   void printGnuHashTable() override;
   void printLoadName() override;
   void printVersionInfo() override;
+  void printGroupSections() override;
 
   void printAttributes() override;
   void printMipsPLTGOT() override;
   void printMipsABIFlags() override;
   void printMipsReginfo() override;
 
   void printStackMap() const override;
 
static const char *getElfSectionType(unsigned Arch, unsigned Type) {
   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
   default: return "";
   }
 }
 
+static const char *getGroupType(uint32_t Flag) {
+  if (Flag & ELF::GRP_COMDAT)
+    return "COMDAT";
+  else
+    return "(unknown)";
+}
+
 static const EnumEntry<unsigned> ElfSectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE           ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC           ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE         ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR       ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE           ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS         ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK       ),
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 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;
+      ErrorOr<const Elf_Shdr *> Symtab =
+          errorOrDefault(Obj->getSection(Sec.sh_link));
+      ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(**Symtab);
+      error(StrTableOrErr.getError());
+      StringRef StrTable = *StrTableOrErr;
+      const Elf_Sym *Sym =
+          Obj->template getEntry<Elf_Sym>(*Symtab, Sec.sh_info);
+      auto Data = errorOrDefault(
+          Obj->template getSectionContentsAsArray<Elf32_Word>(&Sec));
+      DictScope D(W, "Group");
+      StringRef Name = errorOrDefault(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");
+        int Member = 1;
+        while (Member < Data.size()) {
+          auto Sec = errorOrDefault(Obj->getSection(Data[Member]));
+          const StringRef Name = errorOrDefault(Obj->getSectionName(Sec));
+          W.startLine() << Name << " (" << std::to_string(Data[Member++])
+                        << ")\n";
+        }
+      }
+    }
+    ++SectionIndex;
+  }
+  if (!HasGroups)
+    W.startLine() << "There are no group sections in the file.\n";
+}

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

public:
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }
   virtual void printNeededLibraries() { }
   virtual void printProgramHeaders() { }
   virtual void printHashTable() { }
   virtual void printGnuHashTable() { }
   virtual void printLoadName() {}
   virtual void printVersionInfo() {}
+  virtual void printGroupSections() {}
 
   // Only implemented for ARM ELF at this time.
   virtual void printAttributes() { }
 
   // Only implemented for MIPS ELF at this time.
   virtual void printMipsPLTGOT() { }
   virtual void printMipsABIFlags() { }
   virtual void printMipsReginfo() { }

llvm/trunk/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> SectionGroups("elf-section-groups",
+                              cl::desc("Display ELF section group contents"));
+  cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"),
+                               cl::aliasopt(SectionGroups));
+
 } // namespace opts
 
 namespace llvm {
 
 LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
   errs() << "\nError reading file: " << Msg << ".\n";
   errs().flush();
   exit(1);
static void dumpObject(const ObjectFile *Obj) {
   if (opts::ProgramHeaders)
     Dumper->printProgramHeaders();
   if (opts::HashTable)
     Dumper->printHashTable();
   if (opts::GnuHashTable)
     Dumper->printGnuHashTable();
   if (opts::VersionInfo)
     Dumper->printVersionInfo();
-  if (Obj->getArch() == llvm::Triple::arm && Obj->isELF())
+  if (Obj->isELF()) {
+    if (Obj->getArch() == llvm::Triple::arm)
       if (opts::ARMAttributes)
         Dumper->printAttributes();
-  if (isMipsArch(Obj->getArch()) && Obj->isELF()) {
+    if (isMipsArch(Obj->getArch())) {
       if (opts::MipsPLTGOT)
         Dumper->printMipsPLTGOT();
       if (opts::MipsABIFlags)
         Dumper->printMipsABIFlags();
       if (opts::MipsReginfo)
         Dumper->printMipsReginfo();
     }
+    if (opts::SectionGroups)
+      Dumper->printGroupSections();
+  }
   if (Obj->isCOFF()) {
     if (opts::COFFImports)
       Dumper->printCOFFImports();
     if (opts::COFFExports)
       Dumper->printCOFFExports();
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();
     if (opts::COFFBaseRelocs)