[llvm-readobj/llvm-readelf] - .stack_sizes: demangle symbol names in warnings reported.

[grimar]

Summary

I started this patch as a refactoring, tried to make a helper for
getting symbol names, similar to how we get section names
used in warning messages.

So this patch cleanups the code and fixes an issue: symbol names
in warning messages were not demangled.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

4822 ↗

(On Diff #221695)

It was unnecessary to touch this, but I decided that it is nice to move it closer to the new getSymbolName helper.

[jhenderson]

tools/llvm-readobj/ELFDumper.cpp

4786 ↗

(On Diff #221695)

Since we're now demangling these symbols, I wonder if it would make sense here and in the other warning to quote the symbol names, because demangled names can be phrases rather than individual names. Quoting would make the name easier to read, I think.

[grimar]

• Addressed review comments.
• Added a test case for another warning too.

tools/llvm-readobj/ELFDumper.cpp

4786 ↗

(On Diff #221695)

Sounds good. Done.

[jhenderson]

LGTM, thanks!

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

 ## that is referenced by the stack sizes section's sh_link.
 
 # RUN: yaml2obj --docnum=4 %s > %t04
 # RUN: llvm-readelf --stack-sizes %t04 2> %t04-gnu.err | FileCheck %s --check-prefix=WRONGSECTION-GNU
 # RUN: FileCheck %s < %t04-gnu.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
 # RUN: llvm-readobj --stack-sizes %t04 2> %t04-llvm.err | FileCheck %s --check-prefix=WRONGSECTION-LLVM
 # RUN: FileCheck %s < %t04-llvm.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
 
+# RUN: llvm-readelf --stack-sizes --demangle %t04 2>&1 | FileCheck %s --check-prefix=WRONGSECTION-DEMANGLE-ERR -DFILE=%t04
+# RUN: llvm-readobj --stack-sizes --demangle %t04 2>&1 | FileCheck %s --check-prefix=WRONGSECTION-DEMANGLE-ERR -DFILE=%t04
+
 # WRONGSECTION-GNU:      Size Function
-# WRONGSECTION-GNU-NEXT: 8 foo
+# WRONGSECTION-GNU-NEXT: 8 _Z3foof
 
 # WRONGSECTION-LLVM:      StackSizes [
 # WRONGSECTION-LLVM-NEXT:   Entry {
-# WRONGSECTION-LLVM-NEXT:     Function: foo
+# WRONGSECTION-LLVM-NEXT:     Function: _Z3foof
 # WRONGSECTION-LLVM-NEXT:     Size: 0x8
 # WRONGSECTION-LLVM-NEXT:   }
 # WRONGSECTION-LLVM-NEXT: ]
 
-# WRONGSECTION-ERR:  warning: '[[FILE]]': relocation symbol foo is not in the expected section
+# WRONGSECTION-ERR:           warning: '[[FILE]]': relocation symbol '_Z3foof' is not in the expected section
+# WRONGSECTION-DEMANGLE-ERR:  warning: '[[FILE]]': relocation symbol 'foo(float)' is not in the expected section
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
- Name:    .stack_sizes
     Entries:
       - Size: 0x8
     Link:    .text2
   - Name:    .rela.stack_sizes
     Type:    SHT_RELA
     Info:    .stack_sizes
     Relocations:
       - Offset: 0
-        Symbol: foo 
+        Symbol: _Z3foof
         Type:   R_X86_64_64
 Symbols:
-  - Name:    foo
+  - Name:    _Z3foof
     Section: .text
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
 ## Check that we report an error when a stack sizes section ends with an incomplete stack size entry.
 
 # RUN: yaml2obj --docnum=5 %s > %t05
 # RUN: not llvm-readelf --stack-sizes %t05 2>&1 | \

 ## output.
 
 # RUN: yaml2obj --docnum=7 %s > %t07
 # RUN: llvm-readelf --stack-sizes %t07 2> %t07-gnu.err | FileCheck %s --check-prefix=BADSECTION-OUT-GNU
 # RUN: FileCheck %s < %t07-gnu.err --check-prefix=BADSECTION-ERR -DFILE=%t07
 # RUN: llvm-readobj --stack-sizes %t07 2> %t07-llvm.err | FileCheck %s --check-prefix=BADSECTION-OUT-LLVM
 # RUN: FileCheck %s < %t07-llvm.err --check-prefix=BADSECTION-ERR -DFILE=%t07
 
+# RUN: llvm-readelf --stack-sizes --demangle %t07 2>&1 | FileCheck %s --check-prefix=BADSECTION-DEMANGLE-ERR -DFILE=%t07
+# RUN: llvm-readobj --stack-sizes --demangle %t07 2>&1 | FileCheck %s --check-prefix=BADSECTION-DEMANGLE-ERR -DFILE=%t07
+
 # BADSECTION-OUT-GNU: Size Function
 # BADSECTION-OUT-GNU:    8 ?
 
 # BADSECTION-OUT-LLVM:      StackSizes [
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
 # BADSECTION-OUT-LLVM-NEXT:     Function: ?
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x8
 # BADSECTION-OUT-LLVM-NEXT:   }
 # BADSECTION-OUT-LLVM-NEXT: ]
 
-# BADSECTION-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol foo
+# BADSECTION-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol '_Z3foof'
+# BADSECTION-DEMANGLE-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol 'foo(float)'
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name:    .text
     Type:    SHT_PROGBITS
     Size:    8
   - Name:    .stack_sizes
     Type:    SHT_PROGBITS
     Link:    .text
     Entries:
       - Size: 0x8
   - Name:    .rela.stack_sizes
     Type:    SHT_RELA
     Info:    .stack_sizes
     Relocations:
     - Offset: 0
-      Symbol: foo 
+      Symbol: _Z3foof
       Type:   R_X86_64_64
 Symbols:
-  - Name:    foo
+  - Name:    _Z3foof
 ## An invalid section index.
     Index:   10
     Type:    STT_FUNC
     Binding: STB_GLOBAL
 
 ## Check that we report a warning when a stack sizes section does not come with
 ## a corresponding relocation section.
 

 # RUN: llvm-ar rc %t2.a %t04 %t01
 # RUN: llvm-readelf --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-GNU \
 # RUN:   -DFILE=%t2.a --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-LLVM -DFILE=%t2.a
 
 #      ARCHIVEWARN-GNU:File: [[FILE]]({{.*04}})
 #      ARCHIVEWARN-GNU:Stack Sizes:
 # ARCHIVEWARN-GNU-NEXT:         Size     Function
-#      ARCHIVEWARN-GNU:{{.*}}: warning: '{{.*04}}': relocation symbol foo is not in the expected section
-#      ARCHIVEWARN-GNU:            8     foo
+#      ARCHIVEWARN-GNU:{{.*}}: warning: '{{.*04}}': relocation symbol '_Z3foof' is not in the expected section
+#      ARCHIVEWARN-GNU:            8     _Z3foof
 #      ARCHIVEWARN-GNU:File: [[FILE]]({{.*01}})
 #      ARCHIVEWARN-GNU:Stack Sizes:
 # ARCHIVEWARN-GNU-NEXT:         Size     Function
 # ARCHIVEWARN-GNU-NEXT:           16     referenced_by_symbol_foo
 # ARCHIVEWARN-GNU-NEXT:           32     referenced_via_section_bar
 # ARCHIVEWARN-GNU-NEXT:            8     separate_text_section_baz
 #  ARCHIVEWARN-GNU-NOT:{{.}}
 
 
 # ARCHIVEWARN-LLVM:      File: [[FILE]]({{.*04}})
 # ARCHIVEWARN-LLVM:      StackSizes [
-# ARCHIVEWARN-LLVM:      warning: '{{.*04}}': relocation symbol foo is not in the expected section
+# ARCHIVEWARN-LLVM:      warning: '{{.*04}}': relocation symbol '_Z3foof' is not in the expected section
 # ARCHIVEWARN-LLVM-NEXT:   Entry {
-# ARCHIVEWARN-LLVM-NEXT:     Function: foo
+# ARCHIVEWARN-LLVM-NEXT:     Function: _Z3foof
 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x8
 # ARCHIVEWARN-LLVM-NEXT:   }
 # ARCHIVEWARN-LLVM-NEXT: ]
 # ARCHIVEWARN-LLVM:      File: [[FILE]]({{.*01}})
 # ARCHIVEWARN-LLVM:      StackSizes [
 # ARCHIVEWARN-LLVM-NEXT:   Entry {
 # ARCHIVEWARN-LLVM-NEXT:     Function: referenced_by_symbol_foo
 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x10

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

void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   OS << "printELFLinkerOptions not implemented!\n";
 }
 
+// Used for printing section names in places where possible errors can be
+// ignored.
+static StringRef getSectionName(const SectionRef &Sec) {
+  Expected<StringRef> NameOrErr = Sec.getName();
+  if (NameOrErr)
+    return *NameOrErr;
+  consumeError(NameOrErr.takeError());
+  return "<?>";
+}
+
+// Used for printing symbol names in places where possible errors can be
+// ignored.
+static std::string getSymbolName(const ELFSymbolRef &Sym) {
+  Expected<StringRef> NameOrErr = Sym.getName();
+  if (NameOrErr)
+    return maybeDemangle(*NameOrErr);
+  consumeError(NameOrErr.takeError());
+  return "<?>";
+}
+
 template <class ELFT>
 void DumpStyle<ELFT>::printFunctionStackSize(
     const ELFObjectFile<ELFT> *Obj, uint64_t SymValue, SectionRef FunctionSec,
     const StringRef SectionName, DataExtractor Data, uint64_t *Offset) {
   // This function ignores potentially erroneous input, unless it is directly
   // related to stack size reporting.
   SymbolRef FuncSym;
   for (const ELFSymbolRef &Symbol : Obj->symbols()) {
     Expected<uint64_t> SymAddrOrErr = Symbol.getAddress();
     if (!SymAddrOrErr) {
       consumeError(SymAddrOrErr.takeError());
       continue;
     }
     if (Symbol.getELFType() == ELF::STT_FUNC && *SymAddrOrErr == SymValue) {
       // Check if the symbol is in the right section.
       if (FunctionSec.containsSymbol(Symbol)) {
         FuncSym = Symbol;
         break;
       }
     }
   }
 
   std::string FuncName = "?";
   // A valid SymbolRef has a non-null object file pointer.
-  if (FuncSym.BasicSymbolRef::getObject()) {
-    // Extract the symbol name.
-    Expected<StringRef> FuncNameOrErr = FuncSym.getName();
-    if (FuncNameOrErr)
-      FuncName = maybeDemangle(*FuncNameOrErr);
-    else
-      consumeError(FuncNameOrErr.takeError());
-  } else {
+  if (FuncSym.BasicSymbolRef::getObject())
+    FuncName = getSymbolName(FuncSym);
     reportWarning(
         createError("could not identify function symbol for stack size entry"),
         Obj->getFileName());
-  }
 
   // Extract the size. The expectation is that Offset is pointing to the right
   // place, i.e. past the function address.
   uint64_t PrevOffset = *Offset;
   uint64_t StackSize = Data.getULEB128(Offset);
   // getULEB128() does not advance Offset if it is not able to extract a valid
   // integer.
   if (*Offset == PrevOffset)
void DumpStyle<ELFT>::printStackSize(const ELFObjectFile<ELFT> *Obj,
   // related to stack size reporting.
   object::symbol_iterator RelocSym = Reloc.getSymbol();
   uint64_t RelocSymValue = 0;
   StringRef FileStr = Obj->getFileName();
   if (RelocSym != Obj->symbol_end()) {
     // Ensure that the relocation symbol is in the function section, i.e. the
     // section where the functions whose stack sizes we are reporting are
     // located.
-    StringRef SymName = "?";
-    Expected<StringRef> NameOrErr = RelocSym->getName();
-    if (NameOrErr)
-      SymName = *NameOrErr;
-    else
-      consumeError(NameOrErr.takeError());
-
     auto SectionOrErr = RelocSym->getSection();
     if (!SectionOrErr) {
       reportWarning(
-          createError("cannot identify the section for relocation symbol " +
-                      SymName),
+          createError("cannot identify the section for relocation symbol '" +
+                      getSymbolName(*RelocSym) + "'"),
           FileStr);
       consumeError(SectionOrErr.takeError());
     } else if (*SectionOrErr != FunctionSec) {
-      reportWarning(createError("relocation symbol " + SymName +
-                                " is not in the expected section"),
+      reportWarning(createError("relocation symbol '" +
+                                getSymbolName(*RelocSym) +
+                                "' is not in the expected section"),
                     FileStr);
       // Pretend that the symbol is in the correct section and report its
       // stack size anyway.
       FunctionSec = **SectionOrErr;
     }
 
     Expected<uint64_t> RelocSymValueOrErr = RelocSym->getValue();
     if (RelocSymValueOrErr)
reportError(
         FileStr);
 
   uint64_t Addend = Data.getAddress(&Offset);
   uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend);
   this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName,
                                Data, &Offset);
 }
 
-// Used for printing section names in places where possible errors can be
-// ignored.
-static StringRef getSectionName(const SectionRef &Sec) {
-  Expected<StringRef> NameOrErr = Sec.getName();
-  if (NameOrErr)
-    return *NameOrErr;
-  consumeError(NameOrErr.takeError());
-  return "<?>";
-}
-
 template <class ELFT>
 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()) {