[llvm-readobj] - Stop treating ".stack_sizes.*" sections as stack sizes sections.

[grimar]

Summary

llvm-readobj currently handles .stack_sizes.* (e.g. .stack_sizes.foo)
as a normal stack sizes section. Though MC does not produce sections with
such names. Also, linkers do not combine .stack_sizes.* into .stack_sizes.

A mini discussion about this correctness issue is here: https://reviews.llvm.org/D67757#inline-609274
This patch changes implementation so that only now only '.stack_sizes' name is
accepted as a real stack sizes section.

[MaskRay]

tools/llvm-readobj/ELFDumper.cpp

4907 ↗

(On Diff #220990)

Omit ()

llvm/trunk/test/tools/llvm-readobj/stack-sizes.test

- Name:    .text.baz
     Flags:   [SHF_ALLOC]
     Size:    16
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
 ## 2 stack size entries. Each consists of an address (subject to relocation)
 ## followed by a ULEB for the size.
     Content: "000000000000000010000000000000000020"
     Link:    .text
-  - Name:    .stack_sizes.baz
+  - Name:    '.stack_sizes [1]'
     Type:    SHT_PROGBITS
 ## One stack size entry.
     Content: "200000000000000008"
     Link:    .text.baz
   - Name:    .rela.stack_sizes
     Type:    SHT_RELA
     Info:    .stack_sizes
     Relocations:
 ## A symbol relative reference. 
       - Offset: 0
         Symbol: referenced_by_symbol_foo 
         Type:   R_X86_64_64
 ## A section relative reference. 
       - Offset: 9
         Addend: 16
         Symbol: .text
         Type:   R_X86_64_64
-  - Name:   .rela.stack_sizes.baz
+  - Name:   '.rela.stack_sizes [1]'
     Type:   SHT_RELA
-    Info:   .stack_sizes.baz
+    Info:   '.stack_sizes [1]'
     Relocations:
       - Offset: 0
         Symbol: separate_text_section_baz
         Type:   R_X86_64_64
 Symbols:
   - Name:    separate_text_section_baz
     Section: .text.baz
     Type:    STT_FUNC

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

 void DumpStyle<ELFT>::printNonRelocatableStackSizes(
     const ELFObjectFile<ELFT> *Obj, std::function<void()> PrintHeader) {
   // This function ignores potentially erroneous input, unless it is directly
   // related to stack size reporting.
   const ELFFile<ELFT> *EF = Obj->getELFFile();
   StringRef FileStr = Obj->getFileName();
   for (const SectionRef &Sec : Obj->sections()) {
     StringRef SectionName = getSectionName(Sec);
-    if (!SectionName.startswith(".stack_sizes"))
+    if (SectionName != ".stack_sizes")
       continue;
     PrintHeader();
     const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
     ArrayRef<uint8_t> Contents =
         unwrapOrError(this->FileName, EF->getSectionContents(ElfSec));
     DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr));
     // A .stack_sizes section header's sh_link field is supposed to point
     // to the section that contains the functions whose stack sizes are
for (const SectionRef &Sec : Obj->sections()) {
     StringRef SectionName;
     if (Expected<StringRef> NameOrErr = Sec.getName())
       SectionName = *NameOrErr;
     else
       consumeError(NameOrErr.takeError());
 
     // A stack size section that we haven't encountered yet is mapped to the
     // null section until we find its corresponding relocation section.
-    if (SectionName.startswith(".stack_sizes"))
+    if (SectionName == ".stack_sizes")
       if (StackSizeRelocMap.count(Sec) == 0) {
         StackSizeRelocMap[Sec] = NullSection;
         continue;
       }
 
     // Check relocation sections if they are relocating contents of a
     // stack sizes section.
     const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
     uint32_t SectionType = ElfSec->sh_type;
     if (SectionType != ELF::SHT_RELA && SectionType != ELF::SHT_REL)
       continue;
 
     SectionRef Contents = *Sec.getRelocatedSection();
     const Elf_Shdr *ContentsSec = Obj->getSection(Contents.getRawDataRefImpl());
     Expected<StringRef> ContentsSectionNameOrErr =
         EF->getSectionName(ContentsSec);
     if (!ContentsSectionNameOrErr) {
       consumeError(ContentsSectionNameOrErr.takeError());
       continue;
     }
-    if (!ContentsSectionNameOrErr->startswith(".stack_sizes"))
+    if (*ContentsSectionNameOrErr != ".stack_sizes")
       continue;
     // Insert a mapping from the stack sizes section to its relocation section.
     StackSizeRelocMap[Obj->toSectionRef(ContentsSec)] = Sec;
   }
 
   for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
     PrintHeader();
     const SectionRef &StackSizesSec = StackSizeMapEntry.first;