[llvm-readobj] - Teach tool to report error if some section is in multiple COMDAT groups at once.

[grimar]

Summary

This is relative to PR34506,
current LLD head produces broken output. It places the same section into 2 COMDAT groups.
gnu readelf tool reports an error in this case.

Patch teaches llvm-readobj to do the same.

[davide]

We should really move away from a model where we check in a binary for the dumper output.
Can you try to write a YAML file to generate the same object? (I think mc won't do it).

[grimar]

• Used yaml2obj for producing testcase instead of using precompiled binary.

Note: there is patch for printGroupSections() refactoring on review, it is D37621,
it may make sence to land it first probably and rebase this one after that.

[grimar]

• Rebased after r313236.

[grimar]

• Print introduced error to stderr instead of stdout. This is consistent with GNU readelf behavior.

test/tools/llvm-readobj/broken-group.test

+# RUN: yaml2obj %s -o %t.o
+
+# RUN: llvm-readobj --elf-section-groups -elf-output-style=GNU %t.o \
+# RUN:   | FileCheck %s -check-prefix=GNU
+# GNU:      COMDAT group section [    2] `.group' [bar] contains 1 sections:
+# GNU-NEXT:   [Index]    Name
+# GNU-NEXT:   [    3]   .foo
+# GNU:      COMDAT group section [    4] `.group1' [zed] contains 1 sections:
+# GNU-NEXT:   [Index]    Name
+# GNU-NEXT:   Error: section [    3] in group section [    4] already in group section [    2]
+
+# RUN: llvm-readobj --elf-section-groups %t.o \
+# RUN:   | FileCheck %s -check-prefix=LLVM
+# LLVM:      Groups {
+# LLVM-NEXT:   Group {
+# LLVM-NEXT:     Name: .group
+# LLVM-NEXT:     Index: 2
+# LLVM-NEXT:     Type: COMDAT
+# LLVM-NEXT:     Signature: bar
+# LLVM-NEXT:     Section(s) in group [
+# LLVM-NEXT:       .foo (3)
+# LLVM-NEXT:     ]
+# LLVM-NEXT:   }
+# LLVM-NEXT:   Group {
+# LLVM-NEXT:     Name: .group1
+# LLVM-NEXT:     Index: 4
+# LLVM-NEXT:     Type: COMDAT
+# LLVM-NEXT:     Signature: zed
+# LLVM-NEXT:     Section(s) in group [
+# LLVM-NEXT:       Error: .foo (3) already in a group .group (2)
+# LLVM-NEXT:     ]
+# LLVM-NEXT:   }
+# LLVM-NEXT: }
+
+!ELF
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .group
+    Type:            SHT_GROUP
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            bar
+    Members:         
+      - SectionOrType:   GRP_COMDAT
+      - SectionOrType:   .foo
+  - Name:            .foo
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .group1
+    Type:            SHT_GROUP
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            zed
+    Members:         
+      - SectionOrType:   GRP_COMDAT
+      - SectionOrType:   .foo
+Symbols:         
+  Local:           
+    - Name:            bar
+      Section:         .group
+    - Name:            zed
+      Section:         .group1

tools/llvm-readobj/ELFDumper.cpp

 //===----------------------------------------------------------------------===//
 
 #include "ARMEHABIPrinter.h"
 #include "Error.h"
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
template <class ELFT> void GNUStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
   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;
+  DenseMap<uint32_t, uint32_t> SectionToGroup;
   for (const Elf_Shdr &Sec : unwrapOrError(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 =
           unwrapOrError(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)) {
+      for (Elf_Word Ndx : Data.slice(1)) {
+        auto It = SectionToGroup.insert({Ndx, SectionIndex});
+        if (!It.second) {
+          OS << "Error: section [" << format_decimal(Ndx, 5)
+             << "] in group section [" << format_decimal(SectionIndex, 5)
+             << "] already in group section ["
+             << format_decimal(It.first->second, 5) << "]";
+          continue;
+        }
         auto Sec = unwrapOrError(Obj->getSection(Ndx));
         const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
         OS << "   [" << format_decimal(Ndx, 5) << "]   " << Name
            << "\n";
       }
     }
     ++SectionIndex;
   }
template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) {
   DictScope Lists(W, "Groups");
   uint32_t SectionIndex = 0;
   bool HasGroups = false;
+  DenseMap<uint32_t, std::pair<StringRef, uint32_t>> SectionToGroup;
   for (const Elf_Shdr &Sec : unwrapOrError(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 =
           unwrapOrError(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);
+      StringRef GroupName = unwrapOrError(Obj->getSectionName(&Sec));
+      W.printNumber("Name", GroupName, 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";
+          Elf_Word Ndx = Data[Member++];
+          const StringRef SecName = unwrapOrError(Obj->getSectionName(Sec));
+          auto It = SectionToGroup.insert({Ndx, {GroupName, SectionIndex}});
+          if (!It.second) {
+            StringRef GroupName = It.first->second.first;
+            uint32_t GroupIndex = It.first->second.second;
+            W.startLine() << "Error: " << SecName << " (" << Ndx
+                          << ") already in a group " + GroupName + " ("
+                          << GroupIndex << ")\n";
+            continue;
+          }
+          W.startLine() << SecName << " (" << Ndx << ")\n";
         }
       }
     }
     ++SectionIndex;
   }
   if (!HasGroups)
     W.startLine() << "There are no group sections in the file.\n";
 }