[llvm-readelf/obj] - Minor cleanup of warning reporting.

[grimar]

Summary

This:

1. Removes the reportUniqueWarning overload that accepts Error Err.

We can live with the version that accepts const Twine & and
anyways warnings reported in many places touched by this patch can probably
be improved. To do that we would need to use Twine version anyways.

2. Converts the last reportWarning in ELFDumper.cpp to reportUniqueWarning.

In that place it is a no-op I believe.

[MaskRay]

Is this desired? For

reportUniqueWarning(
          "SHT_DYNSYM section header and DT_SYMTAB disagree about "
          "the location of the dynamic symbol table");

it is fine. But for the others, a bunch of toString are added.

[grimar]

In D93021#2446766, @MaskRay wrote:

Is this desired? For

reportUniqueWarning(
          "SHT_DYNSYM section header and DT_SYMTAB disagree about "
          "the location of the dynamic symbol table");

it is fine. But for the others, a bunch of toString are added.

It cleans up the API, leaving the single reportUniqueWarning(const Twine &Msg) method.
This method has different enough signature from regular global reportWarning.
It should help to encourage people to use toString and provide more context for error messages.

Generally I think that lines like
this->reportUniqueWarning(toString(SymsOrErr.takeError())); are not ideal.
Because most of the time messages could be better if they were like:
`this->reportUniqueWarning("some context here: " + toString(SymsOrErr.takeError()));`

I think a context could be added for many if not all of of places touched.

[jhenderson]

In D93021#2447909, @grimar wrote:

In D93021#2446766, @MaskRay wrote:

Is this desired? For

reportUniqueWarning(
          "SHT_DYNSYM section header and DT_SYMTAB disagree about "
          "the location of the dynamic symbol table");

it is fine. But for the others, a bunch of toString are added.

It cleans up the API, leaving the single reportUniqueWarning(const Twine &Msg) method.
This method has different enough signature from regular global reportWarning.
It should help to encourage people to use toString and provide more context for error messages.

Generally I think that lines like
this->reportUniqueWarning(toString(SymsOrErr.takeError())); are not ideal.
Because most of the time messages could be better if they were like:
`this->reportUniqueWarning("some context here: " + toString(SymsOrErr.takeError()));`

I think a context could be added for many if not all of of places touched.

It seems to me like having both APIs is useful - there are occasions when there is no need to add additional context, and other occasions where there is. I think we should use whichever approach is suitable for the given situation. For example, the version definition one in printVersionDependencySection is calling a method with the same parameters as the calling code - there is no additional context that the calling code can usefully provide that the callee which returned the error couldn't, so it just has to call toString.

[grimar]

Abandoning basing on comments.

llvm/tools/llvm-readobj/ELFDumper.cpp

Expected<ArrayRef<Elf_Versym>> VersionsOrErr =
       Obj.template getSectionContentsAsArray<Elf_Versym>(Sec);
   if (!VersionsOrErr)
     return createError("cannot read content of " + describe(Sec) + ": " +
                        toString(VersionsOrErr.takeError()));
 
   Expected<std::pair<ArrayRef<Elf_Sym>, StringRef>> SymTabOrErr =
       getLinkAsSymtab(Obj, Sec, SHT_DYNSYM);
   if (!SymTabOrErr) {
-    reportUniqueWarning(SymTabOrErr.takeError());
+    reportUniqueWarning(toString(SymTabOrErr.takeError()));
     return *VersionsOrErr;
   }
 
   if (SymTabOrErr->first.size() != VersionsOrErr->size())
     reportUniqueWarning(describe(Sec) + ": the number of entries (" +
                         Twine(VersionsOrErr->size()) +
                         ") does not match the number of symbols (" +
                         Twine(SymTabOrErr->first.size()) +

 }
 
 template <class ELFT>
 Expected<std::vector<VerNeed>>
 ELFDumper<ELFT>::getVersionDependencies(const Elf_Shdr &Sec) const {
   StringRef StrTab;
   Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Obj, Sec);
   if (!StrTabOrErr)
-    reportUniqueWarning(StrTabOrErr.takeError());
+    reportUniqueWarning(toString(StrTabOrErr.takeError()));
   else
     StrTab = *StrTabOrErr;
 
   Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Sec);
   if (!ContentsOrErr)
     return createError("cannot read content of " + describe(Sec) + ": " +
                        toString(ContentsOrErr.takeError()));
 
void printStackSize(const Relocation<ELFT> &R, const Elf_Shdr &RelocSec,
                       unsigned Ndx, const Elf_Shdr *SymTab,
                       const Elf_Shdr *FunctionSec, const Elf_Shdr &StackSizeSec,
                       const RelocationResolver &Resolver, DataExtractor Data);
   virtual void printStackSizeEntry(uint64_t Size, StringRef FuncName) = 0;
   virtual void printMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;
   virtual void printMipsABIFlags() = 0;
   const ELFDumper<ELFT> &dumper() const { return Dumper; }
-  void reportUniqueWarning(Error Err) const;
   void reportUniqueWarning(const Twine &Msg) const;
 
 protected:
   std::vector<GroupSection> getGroups();
 
   void printDependentLibsHelper(
       function_ref<void(const Elf_Shdr &)> OnSectionStart,
       function_ref<void(StringRef, uint64_t)> OnSectionEntry);
private:
   std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex);
   void printProgramHeaders();
   void printSectionMapping();
   void printGNUVersionSectionProlog(const typename ELFT::Shdr &Sec,
                                     const Twine &Label, unsigned EntriesNum);
 };
 
 template <class ELFT>
-void DumpStyle<ELFT>::reportUniqueWarning(Error Err) const {
-  this->dumper().reportUniqueWarning(std::move(Err));
-}
-
-template <class ELFT>
 void DumpStyle<ELFT>::reportUniqueWarning(const Twine &Msg) const {
   this->dumper().reportUniqueWarning(Msg);
 }
 
 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
 
std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym &Symbol,
                                                bool IsDynamic) const {
   if (!StrTable)
     return "<?>";
 
   std::string SymbolName;
   if (Expected<StringRef> NameOrErr = Symbol.getName(*StrTable)) {
     SymbolName = maybeDemangle(*NameOrErr);
   } else {
-    reportUniqueWarning(NameOrErr.takeError());
+    reportUniqueWarning(toString(NameOrErr.takeError()));
     return "<?>";
   }
 
   if (SymbolName.empty() && Symbol.getType() == ELF::STT_SECTION) {
     Expected<unsigned> SectionIndex = getSymbolSectionIndex(Symbol, SymIndex);
     if (!SectionIndex) {
-      reportUniqueWarning(SectionIndex.takeError());
+      reportUniqueWarning(toString(SectionIndex.takeError()));
       return "<?>";
     }
     Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex);
     if (!NameOrErr) {
-      reportUniqueWarning(NameOrErr.takeError());
+      reportUniqueWarning(toString(NameOrErr.takeError()));
       return ("<section " + Twine(*SectionIndex) + ">").str();
     }
     return std::string(*NameOrErr);
   }
 
   if (!IsDynamic)
     return SymbolName;
 
   bool IsDefault;
   Expected<StringRef> VersionOrErr = getSymbolVersion(Symbol, IsDefault);
   if (!VersionOrErr) {
-    reportUniqueWarning(VersionOrErr.takeError());
+    reportUniqueWarning(toString(VersionOrErr.takeError()));
     return SymbolName + "@<corrupt>";
   }
 
   if (!VersionOrErr->empty()) {
     SymbolName += (IsDefault ? "@@" : "@");
     SymbolName += *VersionOrErr;
   }
   return SymbolName;
case ELF::SHT_DYNSYM:
                               toString(RegOrErr.takeError()));
         }
       }
       break;
     case ELF::SHT_SYMTAB_SHNDX:
       if (Expected<ArrayRef<Elf_Word>> ShndxTableOrErr = Obj.getSHNDXTable(Sec))
         ShndxTable = *ShndxTableOrErr;
       else
-        this->reportUniqueWarning(ShndxTableOrErr.takeError());
+        this->reportUniqueWarning(toString(ShndxTableOrErr.takeError()));
       break;
     case ELF::SHT_GNU_versym:
       if (!SymbolVersionSection)
         SymbolVersionSection = &Sec;
       break;
     case ELF::SHT_GNU_verdef:
       if (!SymbolVersionDefSection)
         SymbolVersionDefSection = &Sec;
template <typename ELFT> void ELFDumper<ELFT>::parseDynamicTable() {
   if (DynSymRegion) {
     // Often we find the information about the dynamic symbol table
     // location in the SHT_DYNSYM section header. However, the value in
     // DT_SYMTAB has priority, because it is used by dynamic loaders to
     // locate .dynsym at runtime. The location we find in the section header
     // and the location we find here should match.
     if (DynSymFromTable && DynSymFromTable->Addr != DynSymRegion->Addr)
       reportUniqueWarning(
-          createError("SHT_DYNSYM section header and DT_SYMTAB disagree about "
-                      "the location of the dynamic symbol table"));
+          "SHT_DYNSYM section header and DT_SYMTAB disagree about "
+          "the location of the dynamic symbol table");
 
     // According to the ELF gABI: "The number of symbol table entries should
     // equal nchain". Check to see if the DT_HASH hash table nchain value
     // conflicts with the number of symbols in the dynamic symbol table
     // according to the section header.
     if (HashTable && IsHashTableSupported) {
       if (DynSymRegion->EntSize == 0)
         reportUniqueWarning("SHT_DYNSYM section has sh_entsize == 0");
template <typename ELFT> void ELFDumper<ELFT>::printHashTable() {
   bool IsHeaderValid;
   Error Err = checkHashTable(*this, HashTable, &IsHeaderValid);
   if (IsHeaderValid) {
     W.printNumber("Num Buckets", HashTable->nbucket);
     W.printNumber("Num Chains", HashTable->nchain);
   }
 
   if (Err) {
-    reportUniqueWarning(std::move(Err));
+    reportUniqueWarning(toString(std::move(Err)));
     return;
   }
 
   W.printList("Buckets", HashTable->buckets());
   W.printList("Chains", HashTable->chains());
 }
 
 template <class ELFT>
void ELFDumper<ELFT>::printGnuHashTable() {
   if (IsHeaderValid) {
     W.printNumber("Num Buckets", GnuHashTable->nbuckets);
     W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx);
     W.printNumber("Num Mask Words", GnuHashTable->maskwords);
     W.printNumber("Shift Count", GnuHashTable->shift2);
   }
 
   if (Err) {
-    reportUniqueWarning(std::move(Err));
+    reportUniqueWarning(toString(std::move(Err)));
     return;
   }
 
   ArrayRef<typename ELFT::Off> BloomFilter = GnuHashTable->filter();
   W.printHexList("Bloom Filter", BloomFilter);
 
   ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets();
   W.printList("Buckets", Buckets);
case EM_RISCV:
     printAttributes();
     break;
   case EM_MIPS: {
     ELFDumperStyle->printMipsABIFlags();
     printMipsOptions();
     printMipsReginfo();
     MipsGOTParser<ELFT> Parser(*this);
     if (Error E = Parser.findGOT(dynamic_table(), dynamic_symbols()))
-      reportUniqueWarning(std::move(E));
+      reportUniqueWarning(toString(std::move(E)));
     else if (!Parser.isGotEmpty())
       ELFDumperStyle->printMipsGOT(Parser);
 
     if (Error E = Parser.findPLT(dynamic_table()))
-      reportUniqueWarning(std::move(E));
+      reportUniqueWarning(toString(std::move(E)));
     else if (!Parser.isPltEmpty())
       ELFDumperStyle->printMipsPLT(Parser);
     break;
   }
   default:
     break;
   }
 }
template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
   ArrayRef<uint8_t> Data =
       unwrapOrError(ObjF.getFileName(), Obj.getSectionContents(*MipsOpts));
   const uint8_t *const SecBegin = Data.begin();
   while (!Data.empty()) {
     bool IsSupported;
     Expected<const Elf_Mips_Options<ELFT> *> OptsOrErr =
         readMipsOptions<ELFT>(SecBegin, Data, IsSupported);
     if (!OptsOrErr) {
-      reportUniqueWarning(OptsOrErr.takeError());
+      reportUniqueWarning(toString(OptsOrErr.takeError()));
       break;
     }
 
     unsigned Kind = (*OptsOrErr)->kind;
     const char *Type = getElfMipsOptionsOdkType(Kind);
     if (!IsSupported) {
       W.startLine() << "Unsupported MIPS options tag: " << Type << " (" << Kind
                     << ")\n";
for (const Field &F : Fields)
     printField(F);
   OS << "\n";
 
   StringRef SecStrTable;
   if (Expected<StringRef> SecStrTableOrErr = this->Obj.getSectionStringTable(
           Sections, this->dumper().WarningHandler))
     SecStrTable = *SecStrTableOrErr;
   else
-    this->reportUniqueWarning(SecStrTableOrErr.takeError());
+    this->reportUniqueWarning(toString(SecStrTableOrErr.takeError()));
 
   size_t SectionIndex = 0;
   for (const Elf_Shdr &Sec : Sections) {
     Fields[0].Str = to_string(SectionIndex);
     if (SecStrTable.empty())
       Fields[1].Str = "<no-strings>";
     else
       Fields[1].Str = std::string(unwrapOrError<StringRef>(
case ELF::SHN_COMMON:
     return "COM";
   case ELF::SHN_XINDEX: {
     Expected<uint32_t> IndexOrErr = object::getExtendedSymbolTableIndex<ELFT>(
         Symbol, SymIndex, this->dumper().getShndxTable());
     if (!IndexOrErr) {
       assert(Symbol.st_shndx == SHN_XINDEX &&
              "getExtendedSymbolTableIndex should only fail due to an invalid "
              "SHT_SYMTAB_SHNDX table/reference");
-      this->reportUniqueWarning(IndexOrErr.takeError());
+      this->reportUniqueWarning(toString(IndexOrErr.takeError()));
       return "RSV[0xffff]";
     }
     return to_string(format_decimal(*IndexOrErr, 3));
   }
   default:
     // Find if:
     // Processor specific
     if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC)
for (uint32_t Buc = 0; Buc < GnuHash.nbuckets; Buc++) {
     }
   }
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printHashSymbols() {
   if (const Elf_Hash *SysVHash = this->dumper().getHashTable()) {
     OS << "\n Symbol table of .hash for image:\n";
     if (Error E = checkHashTable<ELFT>(this->dumper(), SysVHash))
-      this->reportUniqueWarning(std::move(E));
+      this->reportUniqueWarning(toString(std::move(E)));
     else
       printHashTableSymbols(*SysVHash);
   }
 
   // Try printing the .gnu.hash table.
   if (const Elf_GnuHash *GnuHash = this->dumper().getGnuHashTable()) {
     OS << "\n Symbol table of .gnu.hash for image:\n";
     if (ELFT::Is64Bits)
       OS << "  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name";
     else
       OS << "  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name";
     OS << "\n";
 
     if (Error E = checkGNUHashTable<ELFT>(this->Obj, GnuHash))
-      this->reportUniqueWarning(std::move(E));
+      this->reportUniqueWarning(toString(std::move(E)));
     else
       printGnuHashTableSymbols(*GnuHash);
   }
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printSectionDetails() {
   ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
   OS << "There are " << to_string(Sections.size())
PrintFields({{"Type", 7},
                {"Al", Is64 ? 66 : 57}});
   PrintFields({{"Flags", 7}});
 
   StringRef SecStrTable;
   if (Expected<StringRef> SecStrTableOrErr = this->Obj.getSectionStringTable(
           Sections, this->dumper().WarningHandler))
     SecStrTable = *SecStrTableOrErr;
   else
-    this->reportUniqueWarning(SecStrTableOrErr.takeError());
+    this->reportUniqueWarning(toString(SecStrTableOrErr.takeError()));
 
   size_t SectionIndex = 0;
   const unsigned AddrSize = Is64 ? 16 : 8;
   for (const Elf_Shdr &S : Sections) {
     StringRef Name = "<?>";
     if (Expected<StringRef> NameOrErr =
             this->Obj.getSectionName(S, SecStrTable))
       Name = *NameOrErr;
     else
-      this->reportUniqueWarning(NameOrErr.takeError());
+      this->reportUniqueWarning(toString(NameOrErr.takeError()));
 
     OS.PadToColumn(2);
     OS << "[" << right_justify(to_string(SectionIndex), 2) << "]";
     PrintFields({{Name, 7}});
     PrintFields(
         {{getSectionTypeString(this->Obj.getHeader().e_machine, S.sh_type), 7},
          {to_string(format_hex_no_prefix(S.sh_addr, AddrSize)), 23},
          {to_string(format_hex_no_prefix(S.sh_offset, 6)), Is64 ? 39 : 32},
if (!Sec)
     return;
 
   printGNUVersionSectionProlog(*Sec, "Version symbols",
                                Sec->sh_size / sizeof(Elf_Versym));
   Expected<ArrayRef<Elf_Versym>> VerTableOrErr =
       this->dumper().getVersionTable(*Sec, /*SymTab=*/nullptr,
                                      /*StrTab=*/nullptr);
   if (!VerTableOrErr) {
-    this->reportUniqueWarning(VerTableOrErr.takeError());
+    this->reportUniqueWarning(toString(VerTableOrErr.takeError()));
     return;
   }
 
   ArrayRef<Elf_Versym> VerTable = *VerTableOrErr;
   std::vector<StringRef> Versions;
   for (size_t I = 0, E = VerTable.size(); I < E; ++I) {
     unsigned Ndx = VerTable[I].vs_index;
     if (Ndx == VER_NDX_LOCAL || Ndx == VER_NDX_GLOBAL) {

 void GNUStyle<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) {
   if (!Sec)
     return;
 
   printGNUVersionSectionProlog(*Sec, "Version definition", Sec->sh_info);
 
   Expected<std::vector<VerDef>> V = this->dumper().getVersionDefinitions(*Sec);
   if (!V) {
-    this->reportUniqueWarning(V.takeError());
+    this->reportUniqueWarning(toString(V.takeError()));
     return;
   }
 
   for (const VerDef &Def : *V) {
     OS << format("  0x%04x: Rev: %u  Flags: %s  Index: %u  Cnt: %u  Name: %s\n",
                  Def.Offset, Def.Version,
                  versionFlagToString(Def.Flags).c_str(), Def.Ndx, Def.Cnt,
                  Def.Name.data());
if (!Sec)
     return;
 
   unsigned VerneedNum = Sec->sh_info;
   printGNUVersionSectionProlog(*Sec, "Version needs", VerneedNum);
 
   Expected<std::vector<VerNeed>> V =
       this->dumper().getVersionDependencies(*Sec);
   if (!V) {
-    this->reportUniqueWarning(V.takeError());
+    this->reportUniqueWarning(toString(V.takeError()));
     return;
   }
 
   for (const VerNeed &VN : *V) {
     OS << format("  0x%04x: Version: %u  File: %s  Cnt: %u\n", VN.Offset,
                  VN.Version, VN.File.data(), VN.Cnt);
     for (const VernAux &Aux : VN.AuxV)
       OS << format("  0x%04x:   Name: %s  Flags: %s  Version: %u\n", Aux.Offset,

 // Hash histogram shows statistics of how efficient the hash was for the
 // dynamic symbol table. The table shows the number of hash buckets for
 // different lengths of chains as an absolute number and percentage of the total
 // buckets, and the cumulative coverage of symbols for each set of buckets.
 template <class ELFT> void GNUStyle<ELFT>::printHashHistograms() {
   // Print histogram for the .hash section.
   if (const Elf_Hash *HashTable = this->dumper().getHashTable()) {
     if (Error E = checkHashTable<ELFT>(this->dumper(), HashTable))
-      this->reportUniqueWarning(std::move(E));
+      this->reportUniqueWarning(toString(std::move(E)));
     else
       printHashHistogram(*HashTable);
   }
 
   // Print histogram for the .gnu.hash section.
   if (const Elf_GnuHash *GnuHashTable = this->dumper().getGnuHashTable()) {
     if (Error E = checkGNUHashTable<ELFT>(this->Obj, GnuHashTable))
-      this->reportUniqueWarning(std::move(E));
+      this->reportUniqueWarning(toString(std::move(E)));
     else
       printGnuHashHistogram(*GnuHashTable);
   }
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printCGProfile() {
   OS << "GNUStyle::printCGProfile not implemented\n";
 }

 template <class ELFT> void GNUStyle<ELFT>::printAddrsig() {
   const Elf_Shdr *Sec = this->dumper().getDotAddrsigSec();
   if (!Sec)
     return;
 
   Expected<std::vector<uint64_t>> SymsOrErr =
       decodeAddrsigSection(this->Obj, *Sec);
   if (!SymsOrErr) {
-    this->reportUniqueWarning(SymsOrErr.takeError());
+    this->reportUniqueWarning(toString(SymsOrErr.takeError()));
     return;
   }
 
   StringRef Name = this->getPrintableSectionName(*Sec);
   OS << "\nAddress-significant symbols section '" << Name << "'"
      << " contains " << SymsOrErr->size() << " entries:\n";
   OS << "   Num: Name\n";
 
void DumpStyle<ELFT>::printRelocatableStackSizes(
 
   for (const auto &StackSizeMapEntry : StackSizeRelocMap) {
     PrintHeader();
     const Elf_Shdr *StackSizesELFSec = StackSizeMapEntry.first;
     const Elf_Shdr *RelocSec = StackSizeMapEntry.second;
 
     // Warn about stack size sections without a relocation section.
     if (!RelocSec) {
-      reportWarning(createError(".stack_sizes (" +
-                                describe(Obj, *StackSizesELFSec) +
-                                ") does not have a corresponding "
-                                "relocation section"),
-                    FileName);
+      reportUniqueWarning(".stack_sizes (" + describe(Obj, *StackSizesELFSec) +
+                          "relocation section");
       continue;
     }
 
     // A .stack_sizes section header's sh_link field is supposed to point
     // to the section that contains the functions whose stack sizes are
     // described in it.
     const Elf_Shdr *FunctionSec = unwrapOrError(
         this->FileName, Obj.getSection(StackSizesELFSec->sh_link));

 }
 
 template <class ELFT> void GNUStyle<ELFT>::printMipsABIFlags() {
   const Elf_Mips_ABIFlags<ELFT> *Flags = nullptr;
   if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr =
           getMipsAbiFlagsSection(this->dumper()))
     Flags = *SecOrErr;
   else
-    this->reportUniqueWarning(SecOrErr.takeError());
+    this->reportUniqueWarning(toString(SecOrErr.takeError()));
   if (!Flags)
     return;
 
   OS << "MIPS ABI Flags Version: " << Flags->version << "\n\n";
   OS << "ISA: MIPS" << int(Flags->isa_level);
   if (Flags->isa_rev > 1)
     OS << "r" << int(Flags->isa_rev);
   OS << "\n";
void LLVMStyle<ELFT>::printSymbolSection(const Elf_Sym &Symbol,
   }
 
   Expected<unsigned> SectionIndex =
       this->dumper().getSymbolSectionIndex(Symbol, SymIndex);
   if (!SectionIndex) {
     assert(Symbol.st_shndx == SHN_XINDEX &&
            "getSymbolSectionIndex should only fail due to an invalid "
            "SHT_SYMTAB_SHNDX table/reference");
-    this->reportUniqueWarning(SectionIndex.takeError());
+    this->reportUniqueWarning(toString(SectionIndex.takeError()));
     W.printHex("Section", "Reserved", SHN_XINDEX);
     return;
   }
 
   Expected<StringRef> SectionName =
       this->dumper().getSymbolSectionName(Symbol, *SectionIndex);
   if (!SectionName) {
     // Don't report an invalid section name if the section headers are missing.
     // In such situations, all sections will be "invalid".
     if (!this->dumper().getElfObject().sections().empty())
-      this->reportUniqueWarning(SectionName.takeError());
+      this->reportUniqueWarning(toString(SectionName.takeError()));
     else
       consumeError(SectionName.takeError());
     W.printHex("Section", "<?>", *SectionIndex);
   } else {
     W.printHex("Section", *SectionName, *SectionIndex);
   }
 }
 
void LLVMStyle<ELFT>::printVersionSymbolSection(const Elf_Shdr *Sec) {
   if (!Sec)
     return;
 
   StringRef StrTable;
   ArrayRef<Elf_Sym> Syms;
   Expected<ArrayRef<Elf_Versym>> VerTableOrErr =
       this->dumper().getVersionTable(*Sec, &Syms, &StrTable);
   if (!VerTableOrErr) {
-    this->reportUniqueWarning(VerTableOrErr.takeError());
+    this->reportUniqueWarning(toString(VerTableOrErr.takeError()));
     return;
   }
 
   if (StrTable.empty() || Syms.empty() || Syms.size() != VerTableOrErr->size())
     return;
 
   for (size_t I = 0, E = Syms.size(); I < E; ++I) {
     DictScope S(W, "Symbol");

 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionDefinitionSection(const Elf_Shdr *Sec) {
   ListScope SD(W, "VersionDefinitions");
   if (!Sec)
     return;
 
   Expected<std::vector<VerDef>> V = this->dumper().getVersionDefinitions(*Sec);
   if (!V) {
-    this->reportUniqueWarning(V.takeError());
+    this->reportUniqueWarning(toString(V.takeError()));
     return;
   }
 
   for (const VerDef &D : *V) {
     DictScope Def(W, "Definition");
     W.printNumber("Version", D.Version);
     W.printFlags("Flags", D.Flags, makeArrayRef(SymVersionFlags));
     W.printNumber("Index", D.Ndx);
     W.printNumber("Hash", D.Hash);
     W.printString("Name", D.Name.c_str());
     W.printList(
         "Predecessors", D.AuxV,
         [](raw_ostream &OS, const VerdAux &Aux) { OS << Aux.Name.c_str(); });
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionDependencySection(const Elf_Shdr *Sec) {
   ListScope SD(W, "VersionRequirements");
   if (!Sec)
     return;
 
   Expected<std::vector<VerNeed>> V = this->dumper().getVersionDependencies(*Sec);
   if (!V) {
-    this->reportUniqueWarning(V.takeError());
+    this->reportUniqueWarning(toString(V.takeError()));
     return;
   }
 
   for (const VerNeed &VN : *V) {
     DictScope Entry(W, "Dependency");
     W.printNumber("Version", VN.Version);
     W.printNumber("Count", VN.Cnt);
     W.printString("FileName", VN.File.c_str());
template <class ELFT> void LLVMStyle<ELFT>::printAddrsig() {
   ListScope L(W, "Addrsig");
   const Elf_Shdr *Sec = this->dumper().getDotAddrsigSec();
   if (!Sec)
     return;
 
   Expected<std::vector<uint64_t>> SymsOrErr =
       decodeAddrsigSection(this->Obj, *Sec);
   if (!SymsOrErr) {
-    this->reportUniqueWarning(SymsOrErr.takeError());
+    this->reportUniqueWarning(toString(SymsOrErr.takeError()));
     return;
   }
 
   for (uint64_t Sym : *SymsOrErr)
     W.printNumber("Sym", this->dumper().getStaticSymbolName(Sym), Sym);
 }
 
 template <typename ELFT>
template <class ELFT> void LLVMStyle<ELFT>::printMipsABIFlags() {
   if (Expected<const Elf_Mips_ABIFlags<ELFT> *> SecOrErr =
           getMipsAbiFlagsSection(this->dumper())) {
     Flags = *SecOrErr;
     if (!Flags) {
       W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
       return;
     }
   } else {
-    this->reportUniqueWarning(SecOrErr.takeError());
+    this->reportUniqueWarning(toString(SecOrErr.takeError()));
     return;
   }
 
   raw_ostream &OS = W.getOStream();
   DictScope GS(W, "MIPS ABI Flags");
 
   W.printNumber("Version", Flags->version);
   W.startLine() << "ISA: ";

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printStackMap() const = 0;
 
   void printSectionsAsString(const object::ObjectFile &Obj,
                              ArrayRef<std::string> Sections);
   void printSectionsAsHex(const object::ObjectFile &Obj,
                           ArrayRef<std::string> Sections);
 
   std::function<Error(const Twine &Msg)> WarningHandler;
-  void reportUniqueWarning(Error Err) const;
   void reportUniqueWarning(const Twine &Msg) const;
 
 protected:
   ScopedPrinter &W;
 
 private:
   virtual void printSymbols() {}
   virtual void printDynamicSymbols() {}

llvm/tools/llvm-readobj/ObjDumper.cpp

WarningHandler = [=](const Twine &Msg) {
     if (Warnings.insert(Msg.str()).second)
       reportWarning(createError(Msg), ObjName);
     return Error::success();
   };
 }
 
 ObjDumper::~ObjDumper() {}
 
-void ObjDumper::reportUniqueWarning(Error Err) const {
-  reportUniqueWarning(toString(std::move(Err)));
-}
-
 void ObjDumper::reportUniqueWarning(const Twine &Msg) const {
   cantFail(WarningHandler(Msg),
            "WarningHandler should always return ErrorSuccess");
 }
 
 static void printAsPrintable(raw_ostream &W, const uint8_t *Start, size_t Len) {
   for (size_t i = 0; i < Len; i++)
     W << (isPrint(Start[i]) ? static_cast<char>(Start[i]) : '.');