[llvm-readobj] - Refactor ELFDumper<ELFT>::getStaticSymbolName.

[grimar]

Summary

This is a followup for D83129.
It is possible to make getStaticSymbolName report warnings inside
and return the "<?>" on an error. This allows to encapsulate errors handling
and slightly simplifies the logic in callers code.

[jhenderson]

LGTM.

llvm/tools/llvm-readobj/ELFDumper.cpp

1135

Either simply Warn or ReportWarning, I think.

llvm/test/tools/llvm-readobj/ELF/addrsig.test

 ## Check we report a warning when SHT_LLVM_ADDRSIG references a symbol that can't be
 ## dumped (e.g. the index value is larger than the number of symbols in .symtab).
 
 # RUN: yaml2obj --docnum=3 %s -o %t3.o
 # RUN: llvm-readobj --addrsig %t3.o 2>&1 | FileCheck %s -DFILE=%t3.o --check-prefix=INVALID-INDEX
 
 # INVALID-INDEX:      Addrsig [
 # INVALID-INDEX-NEXT:   Sym: foo (1)
-# INVALID-INDEX-NEXT:   warning: '[[FILE]]': unable to get symbol from section [index 2]: invalid symbol index (255)
+# INVALID-INDEX-NEXT:   warning: '[[FILE]]': unable to read the name of symbol with index 255: unable to get symbol from section [index 2]: invalid symbol index (255)
 # INVALID-INDEX-NEXT:   Sym: <?> (255)
 # INVALID-INDEX-NEXT:   Sym: bar (2)
 # INVALID-INDEX-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
   Elf_Relr_Range dyn_relrs() const;
   std::string getFullSymbolName(const Elf_Sym *Symbol,
                                 Optional<StringRef> StrTable,
                                 bool IsDynamic) const;
   Expected<unsigned> getSymbolSectionIndex(const Elf_Sym *Symbol,
                                            const Elf_Sym *FirstSym) const;
   Expected<StringRef> getSymbolSectionName(const Elf_Sym *Symbol,
                                            unsigned SectionIndex) const;
-  Expected<std::string> getStaticSymbolName(uint32_t Index) const;
+  std::string getStaticSymbolName(uint32_t Index) const;
   StringRef getDynamicString(uint64_t Value) const;
   Expected<StringRef> getSymbolVersionByIndex(uint32_t VersionSymbolIndex,
                                               bool &IsDefault) const;
 
   void printSymbolsHelper(bool IsDynamic) const;
   std::string getDynamicEntry(uint64_t Type, uint64_t Value) const;
 
   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
ELFDumper<ELFT>::getRelocationTarget(const Elf_Shdr *SymTab,
   return std::make_pair(Sym, SymbolName);
 }
 
 static std::string maybeDemangle(StringRef Name) {
   return opts::Demangle ? demangle(std::string(Name)) : Name.str();
 }
 
 template <typename ELFT>
-Expected<std::string>
-ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
+std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
+  auto Warn = [&](Error E) -> std::string {
+    this->reportUniqueWarning(
+        createError("unable to read the name of symbol with index " +
+                    Twine(Index) + ": " + toString(std::move(E))));
+    return "<?>";
+  };
+
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   Expected<const typename ELFT::Sym *> SymOrErr =
       Obj->getSymbol(DotSymtabSec, Index);
   if (!SymOrErr)
-    return SymOrErr.takeError();
+    return Warn(SymOrErr.takeError());
 
   Expected<StringRef> StrTabOrErr = Obj->getStringTableForSymtab(*DotSymtabSec);
   if (!StrTabOrErr)
-    return StrTabOrErr.takeError();
+    return Warn(StrTabOrErr.takeError());
 
   Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr);
   if (!NameOrErr)
-    return NameOrErr.takeError();
+    return Warn(NameOrErr.takeError());
   return maybeDemangle(*NameOrErr);
 }
 
 template <typename ELFT>
 Expected<StringRef>
 ELFDumper<ELFT>::getSymbolVersionByIndex(uint32_t SymbolVersionIndex,
                                          bool &IsDefault) const {
   size_t VersionIndex = SymbolVersionIndex & VERSYM_VERSION;
Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr =
           this->dumper()->getDotCGProfileSec());
   if (!CGProfileOrErr) {
     this->reportUniqueWarning(
         createError("unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: " +
                     toString(CGProfileOrErr.takeError())));
     return;
   }
 
-  auto GetSymName = [&](uint32_t Index) -> std::string {
-    if (Expected<std::string> NameOrErr =
-            this->dumper()->getStaticSymbolName(Index))
-      return *NameOrErr;
-    else
-      this->reportUniqueWarning(
-          createError("unable to read the name of symbol with index " +
-                      Twine(Index) + ": " + toString(NameOrErr.takeError())));
-    return "<?>";
-  };
-
   for (const Elf_CGProfile &CGPE : *CGProfileOrErr) {
     DictScope D(W, "CGProfileEntry");
-    W.printNumber("From", GetSymName(CGPE.cgp_from), CGPE.cgp_from);
-    W.printNumber("To", GetSymName(CGPE.cgp_to), CGPE.cgp_to);
+    W.printNumber("From", this->dumper()->getStaticSymbolName(CGPE.cgp_from),
+                  CGPE.cgp_from);
+    W.printNumber("To", this->dumper()->getStaticSymbolName(CGPE.cgp_to),
+                  CGPE.cgp_to);
     W.printNumber("Weight", CGPE.cgp_weight);
   }
 }
 
 static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) {
   std::vector<uint64_t> Ret;
   const uint8_t *Cur = Data.begin();
   const uint8_t *End = Data.end();