[llvm-readobj] - Deprecate the unwrapOrError helper.

[grimar]

Summary

I've noticed that we use unwrapOrError often.
It is a thing that fail on a error. It is a bit strange to me that we have something like that.

I think, that any (we have it in objdump, objcopy, but I had no chance to revew it)
dumper tool we have actually should never fail.
At least I see no reason for example why we print "<?>" for the section names in one case
and might fail with a error in another? I am not sure about GNU style where we are trying to follow GNU,
but still looks strange to me that we are able to report a error at all.

Dumper is a thing that is used to inspect a binary,
it does not make sense at all to allow it to fail.
Following the logic above I wonder why we have unwrapOrError function.
It is a corrupt for any dumper tool design IMO. (Isn't it?)

I investigated this area and at first tried to make it as deprecated:

template <class T>
LLVM_ATTRIBUTE_DEPRECATED(
    T unwrapOrError(StringRef Input, Expected<T> EO) {
      if (EO)
        return *EO;
      reportError(EO.takeError(), Input);
    },
    "XXXXX");

It kind of works, but I do not know if it is fine. I just do not
know much about it.
E.g. Can our bots fail? I observed failtures from bots before in my practice,
I do not know about the rules they use.
The approach above triggers a lot of warnings for me.
I.e. if all of warnings can trigger a failture or there is a set of allowed ones?
(Or if we have a single bot with "Treat Warning As Errors", it is enough to fail which
might break the whole idea).

Another thing I'd like to mention: llvm-readobj uses this helper in many places. I.e. it
should not be a trivial thing to fix it everywhere (and add tests I mean).
I can handle some of them, but for example I'd like to care about ELF,
but have no interest in COFF.

So, the solution I'd like to suggest: what if we just rename the unwrapOrError to unwrapOrError_DEPRECATED?
Pros: People will know it is a bad thing, either they'll try to rewrite it or to at least stop copy-pasting.
Cons: I do not know any of. A bad name? We need to get rid of this thing from all our dumper tools I believe.

[jhenderson]

Why not just get rid of it, and update the call sites?

[grimar]

In D74405#1869755, @jhenderson wrote:

Why not just get rid of it, and update the call sites?

Well... because I see 153 of them :) I think we should and I do not mind to care about at least some of them, but given the previous my experience my guess is
(I did not yet check though) that many of them are uncovered by tests. Writing tests for that amount of places might take a significant time.

Let me try to investigate it more though. May be it is not that bad how it looks like to me.

[jhenderson]

Sorry :) I just am not a fan of the _DEPRECATED name!

[grimar]

In D74405#1871640, @jhenderson wrote:

Sorry :) I just am not a fan of the _DEPRECATED name!

I've got it ;)

llvm/tools/llvm-readobj/ARMEHABIPrinter.h

PrinterContext<ET>::FunctionAtAddress(unsigned Section,
                                       uint64_t Address) const {
   if (!Symtab)
     return readobj_error::unknown_symbol;
   auto StrTableOrErr = ELF->getStringTableForSymtab(*Symtab);
   if (!StrTableOrErr)
     reportError(StrTableOrErr.takeError(), FileName);
   StringRef StrTable = *StrTableOrErr;
 
-  for (const Elf_Sym &Sym : unwrapOrError(FileName, ELF->symbols(Symtab)))
+  for (const Elf_Sym &Sym :
+       unwrapOrError_DEPRECATED(FileName, ELF->symbols(Symtab)))
     if (Sym.st_shndx == Section && Sym.st_value == Address &&
         Sym.getType() == ELF::STT_FUNC) {
       auto NameOrErr = Sym.getName(StrTable);
       if (!NameOrErr) {
         // TODO: Actually report errors helpfully.
         consumeError(NameOrErr.takeError());
         return readobj_error::unknown_symbol;
       }
PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
   /// Iterate through the sections, searching for the relocation section
   /// associated with the unwind index table section specified by
   /// IndexSectionIndex.  Iterate the associated section searching for the
   /// relocation associated with the index table entry specified by
   /// IndexTableOffset.  The symbol is the section symbol for the exception
   /// handling table.  Use this symbol to recover the actual exception handling
   /// table.
 
-  for (const Elf_Shdr &Sec : unwrapOrError(FileName, ELF->sections())) {
+  for (const Elf_Shdr &Sec : unwrapOrError_DEPRECATED(FileName, ELF->sections())) {
     if (Sec.sh_type != ELF::SHT_REL || Sec.sh_info != IndexSectionIndex)
       continue;
 
     auto SymTabOrErr = ELF->getSection(Sec.sh_link);
     if (!SymTabOrErr)
       reportError(SymTabOrErr.takeError(), FileName);
     const Elf_Shdr *SymTab = *SymTabOrErr;
 
-    for (const Elf_Rel &R : unwrapOrError(FileName, ELF->rels(&Sec))) {
+    for (const Elf_Rel &R : unwrapOrError_DEPRECATED(FileName, ELF->rels(&Sec))) {
       if (R.r_offset != static_cast<unsigned>(IndexTableOffset))
         continue;
 
       typename ET::Rela RelA;
       RelA.r_offset = R.r_offset;
       RelA.r_info = R.r_info;
       RelA.r_addend = 0;
 
       const Elf_Sym *Symbol =
-          unwrapOrError(FileName, ELF->getRelocationSymbol(&RelA, SymTab));
+          unwrapOrError_DEPRECATED(FileName, ELF->getRelocationSymbol(&RelA, SymTab));
 
       auto Ret = ELF->getSection(Symbol, SymTab, ShndxTable);
       if (!Ret)
         report_fatal_error(errorToErrorCode(Ret.takeError()).message());
       return *Ret;
     }
   }
   return nullptr;
void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
   }
 }
 
 template <typename ET>
 void PrinterContext<ET>::PrintUnwindInformation() const {
   DictScope UI(SW, "UnwindInformation");
 
   int SectionIndex = 0;
-  for (const Elf_Shdr &Sec : unwrapOrError(FileName, ELF->sections())) {
+  for (const Elf_Shdr &Sec : unwrapOrError_DEPRECATED(FileName, ELF->sections())) {
     if (Sec.sh_type == ELF::SHT_ARM_EXIDX) {
       DictScope UIT(SW, "UnwindIndexTable");
 
       SW.printNumber("SectionIndex", SectionIndex);
       if (auto SectionName = ELF->getSectionName(&Sec))
         SW.printString("SectionName", *SectionName);
       SW.printHex("SectionOffset", Sec.sh_offset);
 

llvm/tools/llvm-readobj/COFFDumper.cpp

void COFFDumper::printBaseOfDataField(const pe32_header *Hdr) {
   W.printHex("BaseOfData", Hdr->BaseOfData);
 }
 
 void COFFDumper::printBaseOfDataField(const pe32plus_header *) {}
 
 void COFFDumper::printCodeViewDebugInfo() {
   // Print types first to build CVUDTNames, then print symbols.
   for (const SectionRef &S : Obj->sections()) {
-    StringRef SectionName = unwrapOrError(Obj->getFileName(), S.getName());
+    StringRef SectionName = unwrapOrError_DEPRECATED(Obj->getFileName(), S.getName());
     // .debug$T is a standard CodeView type section, while .debug$P is the same
     // format but used for MSVC precompiled header object files.
     if (SectionName == ".debug$T" || SectionName == ".debug$P")
       printCodeViewTypeSection(SectionName, S);
   }
   for (const SectionRef &S : Obj->sections()) {
-    StringRef SectionName = unwrapOrError(Obj->getFileName(), S.getName());
+    StringRef SectionName = unwrapOrError_DEPRECATED(Obj->getFileName(), S.getName());
     if (SectionName == ".debug$S")
       printCodeViewSymbolSection(SectionName, S);
   }
 }
 
 void COFFDumper::initializeFileAndStringTables(BinaryStreamReader &Reader) {
   while (Reader.bytesRemaining() > 0 &&
          (!CVFileChecksumTable.valid() || !CVStringTable.valid())) {
while (Reader.bytesRemaining() > 0 &&
     if (Error E = Reader.skip(PaddedSize - SubSectionSize))
       reportError(std::move(E), Obj->getFileName());
   }
 }
 
 void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
                                             const SectionRef &Section) {
   StringRef SectionContents =
-      unwrapOrError(Obj->getFileName(), Section.getContents());
+      unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getContents());
   StringRef Data = SectionContents;
 
   SmallVector<StringRef, 10> FunctionNames;
   StringMap<StringRef> FunctionLineTables;
 
   ListScope D(W, "CodeViewDebugInfo");
   // Print the section to allow correlation with printSectionHeaders.
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
case DebugSubsectionKind::FrameData: {
               resolveSymbolName(Obj->getCOFFSection(Section), SectionContents,
                                 FrameData.getRelocPtr(), LinkageName))
         reportError(errorCodeToError(EC), Obj->getFileName());
       W.printString("LinkageName", LinkageName);
 
       // To find the active frame description, search this array for the
       // smallest PC range that includes the current PC.
       for (const auto &FD : FrameData) {
-        StringRef FrameFunc = unwrapOrError(
+        StringRef FrameFunc = unwrapOrError_DEPRECATED(
             Obj->getFileName(), CVStringTable.getString(FD.FrameFunc));
 
         DictScope S(W, "FrameData");
         W.printHex("RvaStart", FD.RvaStart);
         W.printHex("CodeSize", FD.CodeSize);
         W.printHex("LocalSize", FD.LocalSize);
         W.printHex("ParamsSize", FD.ParamsSize);
         W.printHex("MaxStackSize", FD.MaxStackSize);
void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
   BinaryStreamRef Stream(Subsection, llvm::support::little);
   DebugChecksumsSubsectionRef Checksums;
   if (Error E = Checksums.initialize(Stream))
     reportError(std::move(E), Obj->getFileName());
 
   for (auto &FC : Checksums) {
     DictScope S(W, "FileChecksum");
 
-    StringRef Filename = unwrapOrError(
+    StringRef Filename = unwrapOrError_DEPRECATED(
         Obj->getFileName(), CVStringTable.getString(FC.FileNameOffset));
     W.printHex("Filename", Filename, FC.FileNameOffset);
     W.printHex("ChecksumSize", FC.Checksum.size());
     W.printEnum("ChecksumKind", uint8_t(FC.Kind),
                 makeArrayRef(FileChecksumKindNames));
 
     W.printBinary("ChecksumBytes", FC.Checksum);
   }
StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) {
 
   auto Iter = CVFileChecksumTable.getArray().at(FileOffset);
 
   // Check if the file checksum table offset is valid.
   if (Iter == CVFileChecksumTable.end())
     reportError(errorCodeToError(object_error::parse_failed),
                 Obj->getFileName());
 
-  return unwrapOrError(Obj->getFileName(),
+  return unwrapOrError_DEPRECATED(Obj->getFileName(),
                        CVStringTable.getString(Iter->FileNameOffset));
 }
 
 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
   W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
 }
 
 void COFFDumper::mergeCodeViewTypes(MergingTypeTableBuilder &CVIDs,
                                     MergingTypeTableBuilder &CVTypes,
                                     GlobalTypeTableBuilder &GlobalCVIDs,
                                     GlobalTypeTableBuilder &GlobalCVTypes,
                                     bool GHash) {
   for (const SectionRef &S : Obj->sections()) {
-    StringRef SectionName = unwrapOrError(Obj->getFileName(), S.getName());
+    StringRef SectionName =
+        unwrapOrError_DEPRECATED(Obj->getFileName(), S.getName());
     if (SectionName == ".debug$T") {
-      StringRef Data = unwrapOrError(Obj->getFileName(), S.getContents());
+      StringRef Data =
+          unwrapOrError_DEPRECATED(Obj->getFileName(), S.getContents());
       uint32_t Magic;
       if (Error E = consume(Data, Magic))
         reportError(std::move(E), Obj->getFileName());
 
       if (Magic != 4)
         reportError(errorCodeToError(object_error::parse_failed),
                     Obj->getFileName());
 
void COFFDumper::mergeCodeViewTypes(MergingTypeTableBuilder &CVIDs,
   }
 }
 
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
-  StringRef Data = unwrapOrError(Obj->getFileName(), Section.getContents());
+  StringRef Data = unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getContents());
   if (opts::CodeViewSubsectionBytes)
     W.printBinaryBlock("Data", Data);
 
   uint32_t Magic;
   if (Error E = consume(Data, Magic))
     reportError(std::move(E), Obj->getFileName());
 
   W.printHex("Magic", Magic);

 
 void COFFDumper::printSectionHeaders() {
   ListScope SectionsD(W, "Sections");
   int SectionNumber = 0;
   for (const SectionRef &Sec : Obj->sections()) {
     ++SectionNumber;
     const coff_section *Section = Obj->getCOFFSection(Sec);
 
-    StringRef Name = unwrapOrError(Obj->getFileName(), Sec.getName());
+    StringRef Name = unwrapOrError_DEPRECATED(Obj->getFileName(), Sec.getName());
 
     DictScope D(W, "Section");
     W.printNumber("Number", SectionNumber);
     W.printBinary("Name", Name, Section->Name);
     W.printHex   ("VirtualSize", Section->VirtualSize);
     W.printHex   ("VirtualAddress", Section->VirtualAddress);
     W.printNumber("RawDataSize", Section->SizeOfRawData);
     W.printHex   ("PointerToRawData", Section->PointerToRawData);
if (opts::SectionSymbols) {
           continue;
 
         printSymbol(Symbol);
       }
     }
 
     if (opts::SectionData &&
         !(Section->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)) {
-      StringRef Data = unwrapOrError(Obj->getFileName(), Sec.getContents());
+      StringRef Data =
+          unwrapOrError_DEPRECATED(Obj->getFileName(), Sec.getContents());
       W.printBinaryBlock("SectionData", Data);
     }
   }
 }
 
 void COFFDumper::printRelocations() {
   ListScope D(W, "Relocations");
 
   int SectionNumber = 0;
   for (const SectionRef &Section : Obj->sections()) {
     ++SectionNumber;
-    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+    StringRef Name = unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
 
     bool PrintedGroup = false;
     for (const RelocationRef &Reloc : Section.relocations()) {
       if (!PrintedGroup) {
         W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
         W.indent();
         PrintedGroup = true;
       }
for (const ExportDirectoryEntryRef &E : Obj->export_directories()) {
     W.printNumber("Ordinal", Ordinal);
     W.printString("Name", Name);
     W.printHex("RVA", RVA);
   }
 }
 
 void COFFDumper::printCOFFDirectives() {
   for (const SectionRef &Section : Obj->sections()) {
-    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+    StringRef Name =
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
     if (Name != ".drectve")
       continue;
 
     StringRef Contents =
-        unwrapOrError(Obj->getFileName(), Section.getContents());
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getContents());
     W.printString("Directive(s)", Contents);
   }
 }
 
 static std::string getBaseRelocTypeName(uint8_t Type) {
   switch (Type) {
   case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE";
   case COFF::IMAGE_REL_BASED_HIGH: return "HIGH";
for (const BaseRelocRef &I : Obj->base_relocs()) {
     W.printString("Type", getBaseRelocTypeName(Type));
     W.printHex("Address", RVA);
   }
 }
 
 void COFFDumper::printCOFFResources() {
   ListScope ResourcesD(W, "Resources");
   for (const SectionRef &S : Obj->sections()) {
-    StringRef Name = unwrapOrError(Obj->getFileName(), S.getName());
+    StringRef Name = unwrapOrError_DEPRECATED(Obj->getFileName(), S.getName());
     if (!Name.startswith(".rsrc"))
       continue;
 
-    StringRef Ref = unwrapOrError(Obj->getFileName(), S.getContents());
+    StringRef Ref = unwrapOrError_DEPRECATED(Obj->getFileName(), S.getContents());
 
     if ((Name == ".rsrc") || (Name == ".rsrc$01")) {
       ResourceSectionRef RSF;
       Error E = RSF.load(Obj, S);
       if (E)
         reportError(std::move(E), Obj->getFileName());
-      auto &BaseTable = unwrapOrError(Obj->getFileName(), RSF.getBaseTable());
+      auto &BaseTable =
+          unwrapOrError_DEPRECATED(Obj->getFileName(), RSF.getBaseTable());
       W.printNumber("Total Number of Resources",
                     countTotalTableEntries(RSF, BaseTable, "Type"));
       W.printHex("Base Table Address",
                  Obj->getCOFFSection(S)->PointerToRawData);
       W.startLine() << "\n";
       printResourceDirectoryTable(RSF, BaseTable, "Type");
     }
     if (opts::SectionData)
       W.printBinaryBlock(Name.str() + " Data", Ref);
   }
 }
 
 uint32_t
 COFFDumper::countTotalTableEntries(ResourceSectionRef RSF,
                                    const coff_resource_dir_table &Table,
                                    StringRef Level) {
   uint32_t TotalEntries = 0;
   for (int i = 0; i < Table.NumberOfNameEntries + Table.NumberOfIDEntries;
        i++) {
-    auto Entry = unwrapOrError(Obj->getFileName(), RSF.getTableEntry(Table, i));
+    auto Entry = unwrapOrError_DEPRECATED(Obj->getFileName(),
+                                          RSF.getTableEntry(Table, i));
     if (Entry.Offset.isSubDir()) {
       StringRef NextLevel;
       if (Level == "Name")
         NextLevel = "Language";
       else
         NextLevel = "Name";
-      auto &NextTable =
-          unwrapOrError(Obj->getFileName(), RSF.getEntrySubDir(Entry));
+      auto &NextTable = unwrapOrError_DEPRECATED(Obj->getFileName(),
+                                                 RSF.getEntrySubDir(Entry));
       TotalEntries += countTotalTableEntries(RSF, NextTable, NextLevel);
     } else {
       TotalEntries += 1;
     }
   }
   return TotalEntries;
 }
 
 void COFFDumper::printResourceDirectoryTable(
     ResourceSectionRef RSF, const coff_resource_dir_table &Table,
     StringRef Level) {
 
   W.printNumber("Number of String Entries", Table.NumberOfNameEntries);
   W.printNumber("Number of ID Entries", Table.NumberOfIDEntries);
 
   // Iterate through level in resource directory tree.
   for (int i = 0; i < Table.NumberOfNameEntries + Table.NumberOfIDEntries;
        i++) {
-    auto Entry = unwrapOrError(Obj->getFileName(), RSF.getTableEntry(Table, i));
+    auto Entry = unwrapOrError_DEPRECATED(Obj->getFileName(),
+                                          RSF.getTableEntry(Table, i));
     StringRef Name;
     SmallString<20> IDStr;
     raw_svector_ostream OS(IDStr);
     if (i < Table.NumberOfNameEntries) {
-      ArrayRef<UTF16> RawEntryNameString =
-          unwrapOrError(Obj->getFileName(), RSF.getEntryNameString(Entry));
+      ArrayRef<UTF16> RawEntryNameString = unwrapOrError_DEPRECATED(
+          Obj->getFileName(), RSF.getEntryNameString(Entry));
       std::vector<UTF16> EndianCorrectedNameString;
       if (llvm::sys::IsBigEndianHost) {
         EndianCorrectedNameString.resize(RawEntryNameString.size() + 1);
         std::copy(RawEntryNameString.begin(), RawEntryNameString.end(),
                   EndianCorrectedNameString.begin() + 1);
         EndianCorrectedNameString[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
         RawEntryNameString = makeArrayRef(EndianCorrectedNameString);
       }
for (int i = 0; i < Table.NumberOfNameEntries + Table.NumberOfIDEntries;
     ListScope ResourceType(W, Level.str() + Name.str());
     if (Entry.Offset.isSubDir()) {
       W.printHex("Table Offset", Entry.Offset.value());
       StringRef NextLevel;
       if (Level == "Name")
         NextLevel = "Language";
       else
         NextLevel = "Name";
-      auto &NextTable =
-          unwrapOrError(Obj->getFileName(), RSF.getEntrySubDir(Entry));
+      auto &NextTable = unwrapOrError_DEPRECATED(Obj->getFileName(),
+                                                 RSF.getEntrySubDir(Entry));
       printResourceDirectoryTable(RSF, NextTable, NextLevel);
     } else {
       W.printHex("Entry Offset", Entry.Offset.value());
       char FormattedTime[20] = {};
       time_t TDS = time_t(Table.TimeDateStamp);
       strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
       W.printHex("Time/Date Stamp", FormattedTime, Table.TimeDateStamp);
       W.printNumber("Major Version", Table.MajorVersion);
       W.printNumber("Minor Version", Table.MinorVersion);
       W.printNumber("Characteristics", Table.Characteristics);
       ListScope DataScope(W, "Data");
       auto &DataEntry =
-          unwrapOrError(Obj->getFileName(), RSF.getEntryData(Entry));
+          unwrapOrError_DEPRECATED(Obj->getFileName(), RSF.getEntryData(Entry));
       W.printHex("DataRVA", DataEntry.DataRVA);
       W.printNumber("DataSize", DataEntry.DataSize);
       W.printNumber("Codepage", DataEntry.Codepage);
       W.printNumber("Reserved", DataEntry.Reserved);
       StringRef Contents =
-          unwrapOrError(Obj->getFileName(), RSF.getContents(DataEntry));
+          unwrapOrError_DEPRECATED(Obj->getFileName(), RSF.getContents(DataEntry));
       W.printBinaryBlock("Data", Contents);
     }
   }
 }
 
 void COFFDumper::printStackMap() const {
   object::SectionRef StackMapSection;
   for (auto Sec : Obj->sections()) {
     StringRef Name;
     if (Expected<StringRef> NameOrErr = Sec.getName())
       Name = *NameOrErr;
     else
       consumeError(NameOrErr.takeError());
 
     if (Name == ".llvm_stackmaps") {
       StackMapSection = Sec;
       break;
     }
   }
 
   if (StackMapSection == object::SectionRef())
     return;
 
   StringRef StackMapContents =
-      unwrapOrError(Obj->getFileName(), StackMapSection.getContents());
+      unwrapOrError_DEPRECATED(Obj->getFileName(), StackMapSection.getContents());
   ArrayRef<uint8_t> StackMapContentsArray =
       arrayRefFromStringRef(StackMapContents);
 
   if (Obj->isLittleEndian())
     prettyPrintStackMap(
         W, StackMapParser<support::little>(StackMapContentsArray));
   else
     prettyPrintStackMap(
if (Name == ".llvm_addrsig") {
       break;
     }
   }
 
   if (AddrsigSection == object::SectionRef())
     return;
 
   StringRef AddrsigContents =
-      unwrapOrError(Obj->getFileName(), AddrsigSection.getContents());
+      unwrapOrError_DEPRECATED(Obj->getFileName(), AddrsigSection.getContents());
   ArrayRef<uint8_t> AddrsigContentsArray(AddrsigContents.bytes_begin(),
                                          AddrsigContents.size());
 
   ListScope L(W, "Addrsig");
   const uint8_t *Cur = AddrsigContents.bytes_begin();
   const uint8_t *End = AddrsigContents.bytes_end();
   while (Cur != End) {
     unsigned Size;

llvm/tools/llvm-readobj/ELFDumper.cpp

if (IsDynamic) {
     StrTable = DynamicStringTable;
     Syms = dynamic_symbols();
     SymtabName = DynSymtabName;
     if (DynSymRegion.Addr)
       Entries = DynSymRegion.Size / DynSymRegion.EntSize;
   } else {
     if (!DotSymtabSec)
       return;
-    StrTable = unwrapOrError(ObjF->getFileName(),
+    StrTable = unwrapOrError_DEPRECATED(ObjF->getFileName(),
                              Obj->getStringTableForSymtab(*DotSymtabSec));
-    Syms = unwrapOrError(ObjF->getFileName(), Obj->symbols(DotSymtabSec));
+    Syms = unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->symbols(DotSymtabSec));
     SymtabName =
-        unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DotSymtabSec));
+        unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->getSectionName(DotSymtabSec));
     Entries = DotSymtabSec->getEntityCount();
   }
   if (Syms.begin() == Syms.end())
     return;
 
   // The st_other field has 2 logical parts. The first two bits hold the symbol
   // visibility (STV_*) and the remainder hold other platform-specific values.
   bool NonVisibilityBitsUsed = llvm::find_if(Syms, [](const Elf_Sym &S) {
Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym *Sym,
   }
 
   // Determine the position in the symbol table of this entry.
   size_t EntryIndex = (reinterpret_cast<uintptr_t>(Sym) -
                         reinterpret_cast<uintptr_t>(DynSymRegion.Addr)) /
                        sizeof(Elf_Sym);
 
   // Get the corresponding version index entry.
-  const Elf_Versym *Versym = unwrapOrError(
+  const Elf_Versym *Versym = unwrapOrError_DEPRECATED(
       ObjF->getFileName(), ObjF->getELFFile()->template getEntry<Elf_Versym>(
                                SymbolVersionSection, EntryIndex));
   return this->getSymbolVersionByIndex(Versym->vs_index, IsDefault);
 }
 
 static std::string maybeDemangle(StringRef Name) {
   return opts::Demangle ? demangle(std::string(Name)) : Name.str();
 }
ELFDumper<ELFT>::getSymbolVersionByIndex(uint32_t SymbolVersionIndex,
   return Entry.Name.c_str();
 }
 
 template <typename ELFT>
 std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
                                                StringRef StrTable,
                                                bool IsDynamic) const {
   std::string SymbolName = maybeDemangle(
-      unwrapOrError(ObjF->getFileName(), Symbol->getName(StrTable)));
+      unwrapOrError_DEPRECATED(ObjF->getFileName(), Symbol->getName(StrTable)));
 
   if (SymbolName.empty() && Symbol->getType() == ELF::STT_SECTION) {
-    Elf_Sym_Range Syms = unwrapOrError(
+    Elf_Sym_Range Syms = unwrapOrError_DEPRECATED(
         ObjF->getFileName(), ObjF->getELFFile()->symbols(DotSymtabSec));
     Expected<unsigned> SectionIndex =
         getSymbolSectionIndex(Symbol, Syms.begin());
     if (!SectionIndex) {
       ELFDumperStyle->reportUniqueWarning(SectionIndex.takeError());
       return "<?>";
     }
     Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex);
if (!SecOrErr)
     return SecOrErr.takeError();
   return Obj->getSectionName(*SecOrErr);
 }
 
 template <class ELFO>
 static const typename ELFO::Elf_Shdr *
 findNotEmptySectionByAddress(const ELFO *Obj, StringRef FileName,
                              uint64_t Addr) {
-  for (const auto &Shdr : unwrapOrError(FileName, Obj->sections()))
+  for (const auto &Shdr : unwrapOrError_DEPRECATED(FileName, Obj->sections()))
     if (Shdr.sh_addr == Addr && Shdr.sh_size > 0)
       return &Shdr;
   return nullptr;
 }
 
 template <class ELFO>
 static const typename ELFO::Elf_Shdr *
 findSectionByName(const ELFO &Obj, StringRef FileName, StringRef Name) {
-  for (const auto &Shdr : unwrapOrError(FileName, Obj.sections()))
-    if (Name == unwrapOrError(FileName, Obj.getSectionName(&Shdr)))
+  for (const auto &Shdr : unwrapOrError_DEPRECATED(FileName, Obj.sections()))
+    if (Name == unwrapOrError_DEPRECATED(FileName, Obj.getSectionName(&Shdr)))
       return &Shdr;
   return nullptr;
 }
 
 static const EnumEntry<unsigned> ElfClass[] = {
   {"None",   "none",   ELF::ELFCLASSNONE},
   {"32-bit", "ELF32",  ELF::ELFCLASS32},
   {"64-bit", "ELF64",  ELF::ELFCLASS64},

 }
 
 template <typename ELFT>
 std::pair<const typename ELFT::Phdr *, const typename ELFT::Shdr *>
 ELFDumper<ELFT>::findDynamic(const ELFFile<ELFT> *Obj) {
   // Try to locate the PT_DYNAMIC header.
   const Elf_Phdr *DynamicPhdr = nullptr;
   for (const Elf_Phdr &Phdr :
-       unwrapOrError(ObjF->getFileName(), Obj->program_headers())) {
+       unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->program_headers())) {
     if (Phdr.p_type != ELF::PT_DYNAMIC)
       continue;
     DynamicPhdr = &Phdr;
     break;
   }
 
   // Try to locate the .dynamic section in the sections header table.
   const Elf_Shdr *DynamicSec = nullptr;
   for (const Elf_Shdr &Sec :
-       unwrapOrError(ObjF->getFileName(), Obj->sections())) {
+       unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->sections())) {
     if (Sec.sh_type != ELF::SHT_DYNAMIC)
       continue;
     DynamicSec = &Sec;
     break;
   }
 
   if (DynamicPhdr && DynamicPhdr->p_offset + DynamicPhdr->p_filesz >
                          ObjF->getMemoryBufferRef().getBufferSize()) {
     reportWarning(
         createError(
             "PT_DYNAMIC segment offset + size exceeds the size of the file"),
         ObjF->getFileName());
     // Don't use the broken dynamic header.
     DynamicPhdr = nullptr;
   }
 
   if (DynamicPhdr && DynamicSec) {
     StringRef Name =
-        unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DynamicSec));
+        unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->getSectionName(DynamicSec));
     if (DynamicSec->sh_addr + DynamicSec->sh_size >
             DynamicPhdr->p_vaddr + DynamicPhdr->p_memsz ||
         DynamicSec->sh_addr < DynamicPhdr->p_vaddr)
       reportWarning(createError("The SHT_DYNAMIC section '" + Name +
                                 "' is not contained within the "
                                 "PT_DYNAMIC segment"),
                     ObjF->getFileName());
 

 ELFDumper<ELFT>::ELFDumper(const object::ELFObjectFile<ELFT> *ObjF,
                            ScopedPrinter &Writer)
     : ObjDumper(Writer), ObjF(ObjF), DynRelRegion(ObjF->getFileName()),
       DynRelaRegion(ObjF->getFileName()), DynRelrRegion(ObjF->getFileName()),
       DynPLTRelRegion(ObjF->getFileName()), DynSymRegion(ObjF->getFileName()),
       DynamicTable(ObjF->getFileName()) {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   typename ELFT::ShdrRange Sections =
-      unwrapOrError(ObjF->getFileName(), Obj->sections());
+      unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->sections());
   for (const Elf_Shdr &Sec : Sections) {
     switch (Sec.sh_type) {
     case ELF::SHT_SYMTAB:
       if (!DotSymtabSec)
         DotSymtabSec = &Sec;
       break;
     case ELF::SHT_DYNSYM:
       if (!DynSymRegion.Size) {
         DynSymRegion = createDRIFrom(&Sec);
         DynSymRegion.Context =
             ("section with index " + Twine(&Sec - &Sections.front())).str();
         // This is only used (if Elf_Shdr present)for naming section in GNU
         // style
-        DynSymtabName =
-            unwrapOrError(ObjF->getFileName(), Obj->getSectionName(&Sec));
+        DynSymtabName = unwrapOrError_DEPRECATED(ObjF->getFileName(),
+                                                 Obj->getSectionName(&Sec));
 
         if (Expected<StringRef> E = Obj->getStringTableForSymtab(Sec))
           DynamicStringTable = *E;
         else
           reportWarning(E.takeError(), ObjF->getFileName());
       }
       break;
     case ELF::SHT_SYMTAB_SHNDX:
-      ShndxTable = unwrapOrError(ObjF->getFileName(), Obj->getSHNDXTable(Sec));
+      ShndxTable = unwrapOrError_DEPRECATED(ObjF->getFileName(),
+                                            Obj->getSHNDXTable(Sec));
       break;
     case ELF::SHT_GNU_versym:
       if (!SymbolVersionSection)
         SymbolVersionSection = &Sec;
       break;
     case ELF::SHT_GNU_verdef:
       if (!SymbolVersionDefSection)
         SymbolVersionDefSection = &Sec;
template <> void ELFDumper<ELF32LE>::printAttributes() {
   const ELFFile<ELF32LE> *Obj = ObjF->getELFFile();
   if (Obj->getHeader()->e_machine != EM_ARM) {
     W.startLine() << "Attributes not implemented.\n";
     return;
   }
 
   DictScope BA(W, "BuildAttributes");
   for (const ELFO::Elf_Shdr &Sec :
-       unwrapOrError(ObjF->getFileName(), Obj->sections())) {
+       unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->sections())) {
     if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
       continue;
 
     ArrayRef<uint8_t> Contents =
-        unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(&Sec));
+        unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->getSectionContents(&Sec));
     if (Contents[0] != ARMBuildAttrs::Format_Version) {
       errs() << "unrecognised FormatVersion: 0x"
              << Twine::utohexstr(Contents[0]) << '\n';
       continue;
     }
 
     W.printHex("FormatVersion", Contents[0]);
     if (Contents.size() == 1)
MipsGOTParser<ELFT>::MipsGOTParser(const ELFO *Obj, StringRef FileName,
 
   // Find static GOT secton.
   if (IsStatic) {
     GotSec = findSectionByName(*Obj, FileName, ".got");
     if (!GotSec)
       return;
 
     ArrayRef<uint8_t> Content =
-        unwrapOrError(FileName, Obj->getSectionContents(GotSec));
+        unwrapOrError_DEPRECATED(FileName, Obj->getSectionContents(GotSec));
     GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
                          Content.size() / sizeof(Entry));
     LocalNum = GotEntries.size();
     return;
   }
 
   // Lookup dynamic table tags which define GOT/PLT layouts.
   Optional<uint64_t> DtPltGot;
if (!GotSec)
       reportError(createError("There is no not empty GOT section at 0x" +
                               Twine::utohexstr(*DtPltGot)),
                   FileName);
 
     LocalNum = *DtLocalGotNum;
     GlobalNum = DynSymTotal - *DtGotSym;
 
     ArrayRef<uint8_t> Content =
-        unwrapOrError(FileName, Obj->getSectionContents(GotSec));
+        unwrapOrError_DEPRECATED(FileName, Obj->getSectionContents(GotSec));
     GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
                          Content.size() / sizeof(Entry));
     GotDynSyms = DynSyms.drop_front(*DtGotSym);
   }
 
   // Find PLT section.
   if (DtMipsPltGot || DtJmpRel) {
     if (!DtMipsPltGot)
       report_fatal_error("Cannot find MIPS_PLTGOT dynamic table tag.");
     if (!DtJmpRel)
       report_fatal_error("Cannot find JMPREL dynamic table tag.");
 
     PltSec = findNotEmptySectionByAddress(Obj, FileName, * DtMipsPltGot);
     if (!PltSec)
       report_fatal_error("There is no not empty PLTGOT section at 0x " +
                          Twine::utohexstr(*DtMipsPltGot));
 
     PltRelSec = findNotEmptySectionByAddress(Obj, FileName, * DtJmpRel);
     if (!PltRelSec)
       report_fatal_error("There is no not empty RELPLT section at 0x" +
                          Twine::utohexstr(*DtJmpRel));
 
     ArrayRef<uint8_t> PltContent =
-        unwrapOrError(FileName, Obj->getSectionContents(PltSec));
+        unwrapOrError_DEPRECATED(FileName, Obj->getSectionContents(PltSec));
     PltEntries = Entries(reinterpret_cast<const Entry *>(PltContent.data()),
                          PltContent.size() / sizeof(Entry));
 
-    PltSymTable = unwrapOrError(FileName, Obj->getSection(PltRelSec->sh_link));
+    PltSymTable = unwrapOrError_DEPRECATED(FileName, Obj->getSection(PltRelSec->sh_link));
     PltStrTable =
-        unwrapOrError(FileName, Obj->getStringTableForSymtab(*PltSymTable));
+        unwrapOrError_DEPRECATED(FileName, Obj->getStringTableForSymtab(*PltSymTable));
   }
 }
 
 template <class ELFT> uint64_t MipsGOTParser<ELFT>::getGp() const {
   return GotSec->sh_addr + 0x7ff0;
 }
 
 template <class ELFT>
uint64_t MipsGOTParser<ELFT>::getPltAddress(const Entry *E) const {
   return PltSec->sh_addr + Offset;
 }
 
 template <class ELFT>
 const typename MipsGOTParser<ELFT>::Elf_Sym *
 MipsGOTParser<ELFT>::getPltSym(const Entry *E) const {
   int64_t Offset = std::distance(getPltEntries().data(), E);
   if (PltRelSec->sh_type == ELF::SHT_REL) {
-    Elf_Rel_Range Rels = unwrapOrError(FileName, Obj->rels(PltRelSec));
-    return unwrapOrError(FileName,
+    Elf_Rel_Range Rels = unwrapOrError_DEPRECATED(FileName, Obj->rels(PltRelSec));
+    return unwrapOrError_DEPRECATED(FileName,
                          Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
   } else {
-    Elf_Rela_Range Rels = unwrapOrError(FileName, Obj->relas(PltRelSec));
-    return unwrapOrError(FileName,
+    Elf_Rela_Range Rels = unwrapOrError_DEPRECATED(FileName, Obj->relas(PltRelSec));
+    return unwrapOrError_DEPRECATED(FileName,
                          Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
   }
 }
 
 static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
   {"None",                    Mips::AFL_EXT_NONE},
   {"Broadcom SB-1",           Mips::AFL_EXT_SB1},
   {"Cavium Networks Octeon",  Mips::AFL_EXT_OCTEON},

 template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const Elf_Shdr *Shdr = findSectionByName(*Obj, ObjF->getFileName(), ".reginfo");
   if (!Shdr) {
     W.startLine() << "There is no .reginfo section in the file.\n";
     return;
   }
   ArrayRef<uint8_t> Sec =
-      unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr));
+      unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->getSectionContents(Shdr));
   if (Sec.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
     W.startLine() << "The .reginfo section has a wrong size.\n";
     return;
   }
 
   DictScope GS(W, "MIPS RegInfo");
   auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec.data());
   printMipsReginfoData(W, *Reginfo);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const Elf_Shdr *Shdr =
       findSectionByName(*Obj, ObjF->getFileName(), ".MIPS.options");
   if (!Shdr) {
     W.startLine() << "There is no .MIPS.options section in the file.\n";
     return;
   }
 
   DictScope GS(W, "MIPS Options");
 
   ArrayRef<uint8_t> Sec =
-      unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr));
+      unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->getSectionContents(Shdr));
   while (!Sec.empty()) {
     if (Sec.size() < sizeof(Elf_Mips_Options<ELFT>)) {
       W.startLine() << "The .MIPS.options section has a wrong size.\n";
       return;
     }
     auto *O = reinterpret_cast<const Elf_Mips_Options<ELFT> *>(Sec.data());
     DictScope GS(W, getElfMipsOptionsOdkType(O->kind));
     switch (O->kind) {
     case ODK_REGINFO:
       printMipsReginfoData(W, O->getRegInfo());
       break;
     default:
       W.startLine() << "Unsupported MIPS options tag.\n";
       break;
     }
     Sec = Sec.slice(O->size);
   }
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const Elf_Shdr *StackMapSection = nullptr;
-  for (const auto &Sec : unwrapOrError(ObjF->getFileName(), Obj->sections())) {
-    StringRef Name =
-        unwrapOrError(ObjF->getFileName(), Obj->getSectionName(&Sec));
+  for (const auto &Sec :
+       unwrapOrError_DEPRECATED(ObjF->getFileName(), Obj->sections())) {
+    StringRef Name = unwrapOrError_DEPRECATED(ObjF->getFileName(),
+                                              Obj->getSectionName(&Sec));
     if (Name == ".llvm_stackmaps") {
       StackMapSection = &Sec;
       break;
     }
   }
 
   if (!StackMapSection)
     return;
 
-  ArrayRef<uint8_t> StackMapContentsArray = unwrapOrError(
+  ArrayRef<uint8_t> StackMapContentsArray = unwrapOrError_DEPRECATED(
       ObjF->getFileName(), Obj->getSectionContents(StackMapSection));
 
   prettyPrintStackMap(
       W, StackMapParser<ELFT::TargetEndianness>(StackMapContentsArray));
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printGroupSections() {
   ELFDumperStyle->printGroupSections(ObjF->getELFFile());

 
 template <class ELFT>
 static std::string getSectionHeadersNumString(const ELFFile<ELFT> *Obj,
                                               StringRef FileName) {
   const typename ELFT::Ehdr *ElfHeader = Obj->getHeader();
   if (ElfHeader->e_shnum != 0)
     return to_string(ElfHeader->e_shnum);
 
-  ArrayRef<typename ELFT::Shdr> Arr = unwrapOrError(FileName, Obj->sections());
+  ArrayRef<typename ELFT::Shdr> Arr = unwrapOrError_DEPRECATED(FileName, Obj->sections());
   if (Arr.empty())
     return "0";
   return "0 (" + to_string(Arr[0].sh_size) + ")";
 }
 
 template <class ELFT>
 static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> *Obj,
                                                     StringRef FileName) {
   const typename ELFT::Ehdr *ElfHeader = Obj->getHeader();
   if (ElfHeader->e_shstrndx != SHN_XINDEX)
     return to_string(ElfHeader->e_shstrndx);
 
-  ArrayRef<typename ELFT::Shdr> Arr = unwrapOrError(FileName, Obj->sections());
+  ArrayRef<typename ELFT::Shdr> Arr = unwrapOrError_DEPRECATED(FileName, Obj->sections());
   if (Arr.empty())
     return "65535 (corrupt: out of range)";
   return to_string(ElfHeader->e_shstrndx) + " (" + to_string(Arr[0].sh_link) +
          ")";
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
   const Elf_Ehdr *e = Obj->getHeader();

 std::vector<GroupSection> getGroups(const ELFFile<ELFT> *Obj,
                                     StringRef FileName) {
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Sym = typename ELFT::Sym;
   using Elf_Word = typename ELFT::Word;
 
   std::vector<GroupSection> Ret;
   uint64_t I = 0;
-  for (const Elf_Shdr &Sec : unwrapOrError(FileName, Obj->sections())) {
+  for (const Elf_Shdr &Sec : unwrapOrError_DEPRECATED(FileName, Obj->sections())) {
     ++I;
     if (Sec.sh_type != ELF::SHT_GROUP)
       continue;
 
     const Elf_Shdr *Symtab =
-        unwrapOrError(FileName, Obj->getSection(Sec.sh_link));
+        unwrapOrError_DEPRECATED(FileName, Obj->getSection(Sec.sh_link));
     StringRef StrTable =
-        unwrapOrError(FileName, Obj->getStringTableForSymtab(*Symtab));
-    const Elf_Sym *Sym = unwrapOrError(
+        unwrapOrError_DEPRECATED(FileName, Obj->getStringTableForSymtab(*Symtab));
+    const Elf_Sym *Sym = unwrapOrError_DEPRECATED(
         FileName, Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info));
-    auto Data = unwrapOrError(
+    auto Data = unwrapOrError_DEPRECATED(
         FileName, Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
 
-    StringRef Name = unwrapOrError(FileName, Obj->getSectionName(&Sec));
+    StringRef Name = unwrapOrError_DEPRECATED(FileName, Obj->getSectionName(&Sec));
     StringRef Signature = StrTable.data() + Sym->st_name;
     Ret.push_back({Name,
                    maybeDemangle(Signature),
                    Sec.sh_name,
                    I - 1,
                    Sec.sh_link,
                    Sec.sh_info,
                    Data[0],
                    {}});
 
     std::vector<GroupMember> &GM = Ret.back().Members;
     for (uint32_t Ndx : Data.slice(1)) {
-      auto Sec = unwrapOrError(FileName, Obj->getSection(Ndx));
-      const StringRef Name = unwrapOrError(FileName, Obj->getSectionName(Sec));
+      auto Sec = unwrapOrError_DEPRECATED(FileName, Obj->getSection(Ndx));
+      const StringRef Name = unwrapOrError_DEPRECATED(FileName, Obj->getSectionName(Sec));
       GM.push_back({Name, Ndx});
     }
   }
   return Ret;
 }
 
 DenseMap<uint64_t, const GroupSection *>
 mapSectionsToGroups(ArrayRef<GroupSection> Groups) {
template <class ELFT> void GNUStyle<ELFT>::printGroupSections(const ELFO *Obj) {
   if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                                      const Elf_Rela &R, bool IsRela) {
   const Elf_Sym *Sym =
-      unwrapOrError(this->FileName, Obj->getRelocationSymbol(&R, SymTab));
+      unwrapOrError_DEPRECATED(this->FileName, Obj->getRelocationSymbol(&R, SymTab));
   std::string TargetName;
   if (Sym && Sym->getType() == ELF::STT_SECTION) {
-    const Elf_Shdr *Sec = unwrapOrError(
+    const Elf_Shdr *Sec = unwrapOrError_DEPRECATED(
         this->FileName,
         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
     TargetName =
-        std::string(unwrapOrError(this->FileName, Obj->getSectionName(Sec)));
+        std::string(unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(Sec)));
   } else if (Sym) {
     StringRef StrTable =
-        unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*SymTab));
+        unwrapOrError_DEPRECATED(this->FileName, Obj->getStringTableForSymtab(*SymTab));
     TargetName = this->dumper()->getFullSymbolName(
         Sym, StrTable, SymTab->sh_type == SHT_DYNSYM /* IsDynamic */);
   }
   printRelocation(Obj, Sym, TargetName, R, IsRela);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Sym *Sym,
else
     OS << "     Info    Type                Sym. Value  Symbol's Name";
   if (IsRela)
     OS << " + Addend";
   OS << "\n";
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printRelocations(const ELFO *Obj) {
   bool HasRelocSections = false;
-  for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) {
+  for (const Elf_Shdr &Sec : unwrapOrError_DEPRECATED(this->FileName, Obj->sections())) {
     if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA &&
         Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_REL &&
         Sec.sh_type != ELF::SHT_ANDROID_RELA &&
         Sec.sh_type != ELF::SHT_ANDROID_RELR)
       continue;
     HasRelocSections = true;
-    StringRef Name = unwrapOrError(this->FileName, Obj->getSectionName(&Sec));
+    StringRef Name = unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(&Sec));
     unsigned Entries = Sec.getEntityCount();
     std::vector<Elf_Rela> AndroidRelas;
     if (Sec.sh_type == ELF::SHT_ANDROID_REL ||
         Sec.sh_type == ELF::SHT_ANDROID_RELA) {
       // Android's packed relocation section needs to be unpacked first
       // to get the actual number of entries.
-      AndroidRelas = unwrapOrError(this->FileName, Obj->android_relas(&Sec));
+      AndroidRelas = unwrapOrError_DEPRECATED(this->FileName, Obj->android_relas(&Sec));
       Entries = AndroidRelas.size();
     }
     std::vector<Elf_Rela> RelrRelas;
     if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR ||
                            Sec.sh_type == ELF::SHT_ANDROID_RELR)) {
       // .relr.dyn relative relocation section needs to be unpacked first
       // to get the actual number of entries.
-      Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(&Sec));
-      RelrRelas = unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
+      Elf_Relr_Range Relrs = unwrapOrError_DEPRECATED(this->FileName, Obj->relrs(&Sec));
+      RelrRelas = unwrapOrError_DEPRECATED(this->FileName, Obj->decode_relrs(Relrs));
       Entries = RelrRelas.size();
     }
     uintX_t Offset = Sec.sh_offset;
     OS << "\nRelocation section '" << Name << "' at offset 0x"
        << to_hexString(Offset, false) << " contains " << Entries
        << " entries:\n";
     printRelocHeader(Sec.sh_type);
     const Elf_Shdr *SymTab =
-        unwrapOrError(this->FileName, Obj->getSection(Sec.sh_link));
+        unwrapOrError_DEPRECATED(this->FileName, Obj->getSection(Sec.sh_link));
     switch (Sec.sh_type) {
     case ELF::SHT_REL:
-      for (const auto &R : unwrapOrError(this->FileName, Obj->rels(&Sec))) {
+      for (const auto &R :
+           unwrapOrError_DEPRECATED(this->FileName, Obj->rels(&Sec))) {
         Elf_Rela Rela;
         Rela.r_offset = R.r_offset;
         Rela.r_info = R.r_info;
         Rela.r_addend = 0;
         printRelocation(Obj, SymTab, Rela, false);
       }
       break;
     case ELF::SHT_RELA:
-      for (const auto &R : unwrapOrError(this->FileName, Obj->relas(&Sec)))
+      for (const auto &R :
+           unwrapOrError_DEPRECATED(this->FileName, Obj->relas(&Sec)))
         printRelocation(Obj, SymTab, R, true);
       break;
     case ELF::SHT_RELR:
     case ELF::SHT_ANDROID_RELR:
       if (opts::RawRelr)
-        for (const auto &R : unwrapOrError(this->FileName, Obj->relrs(&Sec)))
+        for (const auto &R :
+             unwrapOrError_DEPRECATED(this->FileName, Obj->relrs(&Sec)))
           OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8))
              << "\n";
       else
         for (const auto &R : RelrRelas)
           printRelocation(Obj, SymTab, R, false);
       break;
     case ELF::SHT_ANDROID_REL:
     case ELF::SHT_ANDROID_RELA:
else
     OS << "  ";
 
   OS << "p (processor specific)\n";
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
   unsigned Bias = ELFT::Is64Bits ? 0 : 8;
-  ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
+  ArrayRef<Elf_Shdr> Sections =
+      unwrapOrError_DEPRECATED(this->FileName, Obj->sections());
   OS << "There are " << to_string(Sections.size())
      << " section headers, starting at offset "
      << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n";
   OS << "Section Headers:\n";
   Field Fields[11] = {
       {"[Nr]", 2},        {"Name", 7},        {"Type", 25},
       {"Address", 41},    {"Off", 58 - Bias}, {"Size", 65 - Bias},
       {"ES", 72 - Bias},  {"Flg", 75 - Bias}, {"Lk", 79 - Bias},
       {"Inf", 82 - Bias}, {"Al", 86 - Bias}};
   for (auto &F : Fields)
     printField(F);
   OS << "\n";
 
   const ELFObjectFile<ELFT> *ElfObj = this->dumper()->getElfObject();
-  StringRef SecStrTable = unwrapOrError<StringRef>(
+  StringRef SecStrTable = unwrapOrError_DEPRECATED<StringRef>(
       ElfObj->getFileName(),
       Obj->getSectionStringTable(Sections, this->WarningHandler));
   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>(
+      Fields[1].Str = std::string(unwrapOrError_DEPRECATED<StringRef>(
           ElfObj->getFileName(), Obj->getSectionName(&Sec, SecStrTable)));
     Fields[2].Str =
         getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type);
     Fields[3].Str =
         to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8));
     Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6));
     Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6));
     Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2));
OS << "  Type           Offset   VirtAddr           PhysAddr         "
        << "  FileSiz  MemSiz   Flg Align\n";
   else
     OS << "  Type           Offset   VirtAddr   PhysAddr   FileSiz "
        << "MemSiz  Flg Align\n";
 
   unsigned Width = ELFT::Is64Bits ? 18 : 10;
   unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7;
   for (const auto &Phdr :
-       unwrapOrError(this->FileName, Obj->program_headers())) {
+       unwrapOrError_DEPRECATED(this->FileName, Obj->program_headers())) {
     Fields[0].Str = getElfPtType(Header->e_machine, Phdr.p_type);
     Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8));
     Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width));
     Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width));
     Fields[4].Str = to_string(format_hex(Phdr.p_filesz, SizeWidth));
     Fields[5].Str = to_string(format_hex(Phdr.p_memsz, SizeWidth));
     Fields[6].Str = printPhdrFlags(Phdr.p_flags);
     Fields[7].Str = to_string(format_hex(Phdr.p_align, 1));
     for (auto Field : Fields)
       printField(Field);
     if (Phdr.p_type == ELF::PT_INTERP) {
       OS << "\n      [Requesting program interpreter: ";
       OS << reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset << "]";
     }
     OS << "\n";
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printSectionMapping(const ELFO *Obj) {
   OS << "\n Section to Segment mapping:\n  Segment Sections...\n";
   DenseSet<const Elf_Shdr *> BelongsToSegment;
   int Phnum = 0;
   for (const Elf_Phdr &Phdr :
-       unwrapOrError(this->FileName, Obj->program_headers())) {
+       unwrapOrError_DEPRECATED(this->FileName, Obj->program_headers())) {
     std::string Sections;
     OS << format("   %2.2d     ", Phnum++);
-    for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) {
+    for (const Elf_Shdr &Sec :
+         unwrapOrError_DEPRECATED(this->FileName, Obj->sections())) {
       // Check if each section is in a segment and then print mapping.
       // readelf additionally makes sure it does not print zero sized sections
       // at end of segments and for PT_DYNAMIC both start and end of section
       // .tbss must only be shown in PT_TLS section.
       bool TbssInNonTLS = (Sec.sh_type == ELF::SHT_NOBITS) &&
                           ((Sec.sh_flags & ELF::SHF_TLS) != 0) &&
                           Phdr.p_type != ELF::PT_TLS;
       if (!TbssInNonTLS && checkTLSSections(Phdr, Sec) &&
           checkoffsets(Phdr, Sec) && checkVMA(Phdr, Sec) &&
           checkPTDynamic(Phdr, Sec) && (Sec.sh_type != ELF::SHT_NULL)) {
         Sections +=
-            unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() +
+            unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(&Sec)).str() +
             " ";
         BelongsToSegment.insert(&Sec);
       }
     }
     OS << Sections << "\n";
     OS.flush();
   }
 
   // Display sections that do not belong to a segment.
   std::string Sections;
-  for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) {
+  for (const Elf_Shdr &Sec : unwrapOrError_DEPRECATED(this->FileName, Obj->sections())) {
     if (BelongsToSegment.find(&Sec) == BelongsToSegment.end())
       Sections +=
-          unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() + ' ';
+          unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(&Sec)).str() + ' ';
   }
   if (!Sections.empty()) {
     OS << "   None  " << Sections << '\n';
     OS.flush();
   }
 }
 
 namespace {
if (DynRelrRegion.Size > 0) {
     OS << "\n'RELR' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynRelrRegion.Addr) -
                          Obj->base(),
                      1)
        << " contains " << DynRelrRegion.Size << " bytes:\n";
     printRelocHeader(ELF::SHT_REL);
     Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
     std::vector<Elf_Rela> RelrRelas =
-        unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
+        unwrapOrError_DEPRECATED(this->FileName, Obj->decode_relrs(Relrs));
     for (const Elf_Rela &Rela : RelrRelas) {
       printDynamicRelocation(Obj, Rela, false);
     }
   }
   if (DynPLTRelRegion.Size) {
     OS << "\n'PLT' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) -
                          Obj->base(),
if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printGNUVersionSectionProlog(
     const ELFFile<ELFT> *Obj, const typename ELFT::Shdr *Sec,
     const Twine &Label, unsigned EntriesNum) {
-  StringRef SecName = unwrapOrError(this->FileName, Obj->getSectionName(Sec));
+  StringRef SecName = unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(Sec));
   OS << Label << " section '" << SecName << "' "
      << "contains " << EntriesNum << " entries:\n";
 
   unsigned SecNdx = Sec - &cantFail(Obj->sections()).front();
   StringRef SymTabName = "<corrupt>";
 
   Expected<const typename ELFT::Shdr *> SymTabOrErr =
       Obj->getSection(Sec->sh_link);
   if (SymTabOrErr)
     SymTabName =
-        unwrapOrError(this->FileName, Obj->getSectionName(*SymTabOrErr));
+        unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(*SymTabOrErr));
   else
     this->reportUniqueWarning(
         createError("invalid section linked to " +
                     object::getELFSectionTypeName(Obj->getHeader()->e_machine,
                                                   Sec->sh_type) +
                     " section with index " + Twine(SecNdx) + ": " +
                     toString(SymTabOrErr.takeError())));
 
auto ProcessNote = [&](const Elf_Note &Note) {
     } else if (!Descriptor.empty()) {
       OS << "   description data:";
       for (uint8_t B : Descriptor)
         OS << " " << format("%02x", B);
       OS << '\n';
     }
   };
 
-  ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
+  ArrayRef<Elf_Shdr> Sections = unwrapOrError_DEPRECATED(this->FileName, Obj->sections());
   if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
     for (const auto &S : Sections) {
       if (S.sh_type != SHT_NOTE)
         continue;
       PrintHeader(S.sh_offset, S.sh_size);
       Error Err = Error::success();
       for (auto Note : Obj->notes(S, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   } else {
     for (const auto &P :
-         unwrapOrError(this->FileName, Obj->program_headers())) {
+         unwrapOrError_DEPRECATED(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       PrintHeader(P.p_offset, P.p_filesz);
       Error Err = Error::success();
       for (auto Note : Obj->notes(P, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
void DumpStyle<ELFT>::printNonRelocatableStackSizes(
   StringRef FileStr = Obj->getFileName();
   for (const SectionRef &Sec : Obj->sections()) {
     StringRef SectionName = getSectionName(Sec);
     if (SectionName != ".stack_sizes")
       continue;
     PrintHeader();
     const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
     ArrayRef<uint8_t> Contents =
-        unwrapOrError(this->FileName, EF->getSectionContents(ElfSec));
+        unwrapOrError_DEPRECATED(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
     // described in it.
     const Elf_Shdr *FunctionELFSec =
-        unwrapOrError(this->FileName, EF->getSection(ElfSec->sh_link));
+        unwrapOrError_DEPRECATED(this->FileName, EF->getSection(ElfSec->sh_link));
     uint64_t Offset = 0;
     while (Offset < Contents.size()) {
       // The function address is followed by a ULEB representing the stack
       // size. Check for an extra byte before we try to process the entry.
       if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1)) {
         reportError(
             createStringError(
                 object_error::parse_failed,
if (RelocSec == NullSection) {
       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 *StackSizesELFSec =
         Obj->getSection(StackSizesSec.getRawDataRefImpl());
-    const SectionRef FunctionSec = Obj->toSectionRef(unwrapOrError(
+    const SectionRef FunctionSec = Obj->toSectionRef(unwrapOrError_DEPRECATED(
         this->FileName, EF->getSection(StackSizesELFSec->sh_link)));
 
     bool (*IsSupportedFn)(uint64_t);
     RelocationResolver Resolver;
     std::tie(IsSupportedFn, Resolver) = getRelocationResolver(*Obj);
-    auto Contents = unwrapOrError(this->FileName, StackSizesSec.getContents());
+    auto Contents = unwrapOrError_DEPRECATED(this->FileName, StackSizesSec.getContents());
     DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr));
     for (const RelocationRef &Reloc : RelocSec.relocations()) {
       if (!IsSupportedFn || !IsSupportedFn(Reloc.getType()))
         reportError(createStringError(
                         object_error::parse_failed,
                         "unsupported relocation type in section %s: %s",
                         getSectionName(RelocSec).data(),
                         EF->getRelocationTypeName(Reloc.getType()).data()),

 template <class ELFT>
 void GNUStyle<ELFT>::printMipsABIFlags(const ELFObjectFile<ELFT> *ObjF) {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const Elf_Shdr *Shdr =
       findSectionByName(*Obj, ObjF->getFileName(), ".MIPS.abiflags");
   if (!Shdr)
     return;
 
-  ArrayRef<uint8_t> Sec =
-      unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr));
+  ArrayRef<uint8_t> Sec = unwrapOrError_DEPRECATED(
+      ObjF->getFileName(), Obj->getSectionContents(Shdr));
   if (Sec.size() != sizeof(Elf_Mips_ABIFlags<ELFT>))
     reportError(createError(".MIPS.abiflags section has a wrong size"),
                 ObjF->getFileName());
 
   auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec.data());
 
   OS << "MIPS ABI Flags Version: " << Flags->version << "\n\n";
   OS << "ISA: MIPS" << int(Flags->isa_level);
void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) {
   if (V.empty())
     W.startLine() << "There are no group sections in the file.\n";
 }
 
 template <class ELFT> void LLVMStyle<ELFT>::printRelocations(const ELFO *Obj) {
   ListScope D(W, "Relocations");
 
   int SectionNumber = -1;
-  for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) {
+  for (const Elf_Shdr &Sec :
+       unwrapOrError_DEPRECATED(this->FileName, Obj->sections())) {
     ++SectionNumber;
 
     if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA &&
         Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_REL &&
         Sec.sh_type != ELF::SHT_ANDROID_RELA &&
         Sec.sh_type != ELF::SHT_ANDROID_RELR)
       continue;
 
-    StringRef Name = unwrapOrError(this->FileName, Obj->getSectionName(&Sec));
+    StringRef Name =
+        unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(&Sec));
 
     W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
     W.indent();
 
     printRelocations(&Sec, Obj);
 
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printRelocations(const Elf_Shdr *Sec, const ELFO *Obj) {
   const Elf_Shdr *SymTab =
-      unwrapOrError(this->FileName, Obj->getSection(Sec->sh_link));
+      unwrapOrError_DEPRECATED(this->FileName, Obj->getSection(Sec->sh_link));
 
   switch (Sec->sh_type) {
   case ELF::SHT_REL:
-    for (const Elf_Rel &R : unwrapOrError(this->FileName, Obj->rels(Sec))) {
+    for (const Elf_Rel &R :
+         unwrapOrError_DEPRECATED(this->FileName, Obj->rels(Sec))) {
       Elf_Rela Rela;
       Rela.r_offset = R.r_offset;
       Rela.r_info = R.r_info;
       Rela.r_addend = 0;
       printRelocation(Obj, Rela, SymTab);
     }
     break;
   case ELF::SHT_RELA:
-    for (const Elf_Rela &R : unwrapOrError(this->FileName, Obj->relas(Sec)))
+    for (const Elf_Rela &R :
+         unwrapOrError_DEPRECATED(this->FileName, Obj->relas(Sec)))
       printRelocation(Obj, R, SymTab);
     break;
   case ELF::SHT_RELR:
   case ELF::SHT_ANDROID_RELR: {
-    Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(Sec));
+    Elf_Relr_Range Relrs =
+        unwrapOrError_DEPRECATED(this->FileName, Obj->relrs(Sec));
     if (opts::RawRelr) {
       for (const Elf_Relr &R : Relrs)
         W.startLine() << W.hex(R) << "\n";
     } else {
       std::vector<Elf_Rela> RelrRelas =
-          unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
+          unwrapOrError_DEPRECATED(this->FileName, Obj->decode_relrs(Relrs));
       for (const Elf_Rela &R : RelrRelas)
         printRelocation(Obj, R, SymTab);
     }
     break;
   }
   case ELF::SHT_ANDROID_REL:
   case ELF::SHT_ANDROID_RELA:
     for (const Elf_Rela &R :
-         unwrapOrError(this->FileName, Obj->android_relas(Sec)))
+         unwrapOrError_DEPRECATED(this->FileName, Obj->android_relas(Sec)))
       printRelocation(Obj, R, SymTab);
     break;
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel,
                                       const Elf_Shdr *SymTab) {
   SmallString<32> RelocName;
   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
   std::string TargetName;
-  const Elf_Sym *Sym =
-      unwrapOrError(this->FileName, Obj->getRelocationSymbol(&Rel, SymTab));
+  const Elf_Sym *Sym = unwrapOrError_DEPRECATED(
+      this->FileName, Obj->getRelocationSymbol(&Rel, SymTab));
   if (Sym && Sym->getType() == ELF::STT_SECTION) {
-    const Elf_Shdr *Sec = unwrapOrError(
+    const Elf_Shdr *Sec = unwrapOrError_DEPRECATED(
         this->FileName,
         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
-    TargetName =
-        std::string(unwrapOrError(this->FileName, Obj->getSectionName(Sec)));
+    TargetName = std::string(
+        unwrapOrError_DEPRECATED(this->FileName, Obj->getSectionName(Sec)));
   } else if (Sym) {
-    StringRef StrTable =
-        unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*SymTab));
+    StringRef StrTable = unwrapOrError_DEPRECATED(
+        this->FileName, Obj->getStringTableForSymtab(*SymTab));
     TargetName = this->dumper()->getFullSymbolName(
         Sym, StrTable, SymTab->sh_type == SHT_DYNSYM /* IsDynamic */);
   }
 
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
     W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-",
                   Rel.getSymbol(Obj->isMips64EL()));
     W.printHex("Addend", Rel.r_addend);
   } else {
     raw_ostream &OS = W.startLine();
     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
        << (!TargetName.empty() ? TargetName : "-") << " " << W.hex(Rel.r_addend)
        << "\n";
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
   ListScope SectionsD(W, "Sections");
 
   int SectionIndex = -1;
-  ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
+  ArrayRef<Elf_Shdr> Sections =
+      unwrapOrError_DEPRECATED(this->FileName, Obj->sections());
   std::vector<EnumEntry<unsigned>> FlagsList =
       getSectionFlagsForTarget(Obj->getHeader()->e_machine);
   for (const Elf_Shdr &Sec : Sections) {
     StringRef Name = "<?>";
     if (Expected<StringRef> SecNameOrErr =
             Obj->getSectionName(&Sec, this->WarningHandler))
       Name = *SecNameOrErr;
     else
for (const Elf_Shdr &Sec : Sections) {
     if (opts::SectionRelocations) {
       ListScope D(W, "Relocations");
       printRelocations(&Sec, Obj);
     }
 
     if (opts::SectionSymbols) {
       ListScope D(W, "Symbols");
       const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec();
-      StringRef StrTable =
-          unwrapOrError(this->FileName, Obj->getStringTableForSymtab(*Symtab));
+      StringRef StrTable = unwrapOrError_DEPRECATED(
+          this->FileName, Obj->getStringTableForSymtab(*Symtab));
 
       for (const Elf_Sym &Sym :
-           unwrapOrError(this->FileName, Obj->symbols(Symtab))) {
-        const Elf_Shdr *SymSec = unwrapOrError(
+           unwrapOrError_DEPRECATED(this->FileName, Obj->symbols(Symtab))) {
+        const Elf_Shdr *SymSec = unwrapOrError_DEPRECATED(
             this->FileName,
             Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable()));
         if (SymSec == &Sec)
           printSymbol(
               Obj, &Sym,
-              unwrapOrError(this->FileName, Obj->symbols(Symtab)).begin(),
+              unwrapOrError_DEPRECATED(this->FileName, Obj->symbols(Symtab))
+                  .begin(),
               StrTable, false, false);
       }
     }
 
     if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
-      ArrayRef<uint8_t> Data =
-          unwrapOrError(this->FileName, Obj->getSectionContents(&Sec));
+      ArrayRef<uint8_t> Data = unwrapOrError_DEPRECATED(
+          this->FileName, Obj->getSectionContents(&Sec));
       W.printBinaryBlock(
           "SectionData",
           StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()));
     }
   }
 }
 
 template <class ELFT>
for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
       Rela.r_offset = Rel.r_offset;
       Rela.r_info = Rel.r_info;
       Rela.r_addend = 0;
       printDynamicRelocation(Obj, Rela);
     }
   if (DynRelrRegion.Size > 0) {
     Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
     std::vector<Elf_Rela> RelrRelas =
-        unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
+        unwrapOrError_DEPRECATED(this->FileName, Obj->decode_relrs(Relrs));
     for (const Elf_Rela &Rela : RelrRelas)
       printDynamicRelocation(Obj, Rela);
   }
   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
       printDynamicRelocation(Obj, Rela);
   else
     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
if (PrintSectionMapping == cl::BOU_TRUE)
     printSectionMapping(Obj);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
   ListScope L(W, "ProgramHeaders");
 
   for (const Elf_Phdr &Phdr :
-       unwrapOrError(this->FileName, Obj->program_headers())) {
+       unwrapOrError_DEPRECATED(this->FileName, Obj->program_headers())) {
     DictScope P(W, "ProgramHeader");
     W.printHex("Type",
                getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
                Phdr.p_type);
     W.printHex("Offset", Phdr.p_offset);
     W.printHex("VirtualAddress", Phdr.p_vaddr);
     W.printHex("PhysicalAddress", Phdr.p_paddr);
     W.printNumber("FileSize", Phdr.p_filesz);
void LLVMStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) {
   W.startLine() << "Hash Histogram not implemented!\n";
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printCGProfile(const ELFFile<ELFT> *Obj) {
   ListScope L(W, "CGProfile");
   if (!this->dumper()->getDotCGProfileSec())
     return;
-  auto CGProfile = unwrapOrError(
+  auto CGProfile = unwrapOrError_DEPRECATED(
       this->FileName, Obj->template getSectionContentsAsArray<Elf_CGProfile>(
                           this->dumper()->getDotCGProfileSec()));
   for (const Elf_CGProfile &CGPE : CGProfile) {
     DictScope D(W, "CGProfileEntry");
     W.printNumber(
         "From",
-        unwrapOrError(this->FileName,
-                      this->dumper()->getStaticSymbolName(CGPE.cgp_from)),
+        unwrapOrError_DEPRECATED(
+            this->FileName, this->dumper()->getStaticSymbolName(CGPE.cgp_from)),
         CGPE.cgp_from);
     W.printNumber(
         "To",
-        unwrapOrError(this->FileName,
-                      this->dumper()->getStaticSymbolName(CGPE.cgp_to)),
+        unwrapOrError_DEPRECATED(
+            this->FileName, 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();
static Expected<std::vector<uint64_t>> toULEB128Array(ArrayRef<uint8_t> Data) {
   return Ret;
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printAddrsig(const ELFFile<ELFT> *Obj) {
   ListScope L(W, "Addrsig");
   if (!this->dumper()->getDotAddrsigSec())
     return;
-  ArrayRef<uint8_t> Contents = unwrapOrError(
+  ArrayRef<uint8_t> Contents = unwrapOrError_DEPRECATED(
       this->FileName,
       Obj->getSectionContents(this->dumper()->getDotAddrsigSec()));
   Expected<std::vector<uint64_t>> V = toULEB128Array(Contents);
   if (!V) {
     reportWarning(V.takeError(), this->FileName);
     return;
   }
 
if (Name == "GNU") {
         else
           reportWarning(Note.takeError(), this->FileName);
       }
     } else if (!Descriptor.empty()) {
       W.printBinaryBlock("Description data", Descriptor);
     }
   };
 
-  ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
+  ArrayRef<Elf_Shdr> Sections =
+      unwrapOrError_DEPRECATED(this->FileName, Obj->sections());
   if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
     for (const auto &S : Sections) {
       if (S.sh_type != SHT_NOTE)
         continue;
       DictScope D(W, "NoteSection");
       PrintHeader(S.sh_offset, S.sh_size);
       Error Err = Error::success();
       for (auto Note : Obj->notes(S, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   } else {
     for (const auto &P :
-         unwrapOrError(this->FileName, Obj->program_headers())) {
+         unwrapOrError_DEPRECATED(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       DictScope D(W, "NoteSection");
       PrintHeader(P.p_offset, P.p_filesz);
       Error Err = Error::success();
       for (auto Note : Obj->notes(P, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   ListScope L(W, "LinkerOptions");
 
   unsigned I = -1;
-  for (const Elf_Shdr &Shdr : unwrapOrError(this->FileName, Obj->sections())) {
+  for (const Elf_Shdr &Shdr :
+       unwrapOrError_DEPRECATED(this->FileName, Obj->sections())) {
     ++I;
     if (Shdr.sh_type != ELF::SHT_LLVM_LINKER_OPTIONS)
       continue;
 
-    ArrayRef<uint8_t> Contents =
-        unwrapOrError(this->FileName, Obj->getSectionContents(&Shdr));
+    ArrayRef<uint8_t> Contents = unwrapOrError_DEPRECATED(
+        this->FileName, Obj->getSectionContents(&Shdr));
     if (Contents.empty())
       continue;
 
     if (Contents.back() != 0) {
       reportWarning(createError("SHT_LLVM_LINKER_OPTIONS section at index " +
                                 Twine(I) +
                                 " is broken: the "
                                 "content is not null-terminated"),
void LLVMStyle<ELFT>::printDependentLibs(const ELFFile<ELFT> *Obj) {
 
   auto Warn = [this](unsigned SecNdx, StringRef Msg) {
     this->reportUniqueWarning(
         createError("SHT_LLVM_DEPENDENT_LIBRARIES section at index " +
                     Twine(SecNdx) + " is broken: " + Msg));
   };
 
   unsigned I = -1;
-  for (const Elf_Shdr &Shdr : unwrapOrError(this->FileName, Obj->sections())) {
+  for (const Elf_Shdr &Shdr :
+       unwrapOrError_DEPRECATED(this->FileName, Obj->sections())) {
     ++I;
     if (Shdr.sh_type != ELF::SHT_LLVM_DEPENDENT_LIBRARIES)
       continue;
 
     Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(&Shdr);
     if (!ContentsOrErr) {
       Warn(I, toString(ContentsOrErr.takeError()));
       continue;

 void LLVMStyle<ELFT>::printMipsABIFlags(const ELFObjectFile<ELFT> *ObjF) {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const Elf_Shdr *Shdr =
       findSectionByName(*Obj, ObjF->getFileName(), ".MIPS.abiflags");
   if (!Shdr) {
     W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
     return;
   }
-  ArrayRef<uint8_t> Sec =
-      unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Shdr));
+  ArrayRef<uint8_t> Sec = unwrapOrError_DEPRECATED(
+      ObjF->getFileName(), Obj->getSectionContents(Shdr));
   if (Sec.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
     W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
     return;
   }
 
   auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec.data());
 
   raw_ostream &OS = W.getOStream();

llvm/tools/llvm-readobj/MachODumper.cpp

void MachODumper::printSectionHeaders(const MachOObjectFile *Obj) {
 
   int SectionIndex = -1;
   for (const SectionRef &Section : Obj->sections()) {
     ++SectionIndex;
 
     MachOSection MOSection;
     getSection(Obj, Section.getRawDataRefImpl(), MOSection);
     DataRefImpl DR = Section.getRawDataRefImpl();
-    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+    StringRef Name = unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
     ArrayRef<char> RawName = Obj->getSectionRawName(DR);
     StringRef SegmentName = Obj->getSectionFinalSegmentName(DR);
     ArrayRef<char> RawSegmentName = Obj->getSectionRawFinalSegmentName(DR);
 
     DictScope SectionD(W, "Section");
     W.printNumber("Index", SectionIndex);
     W.printBinary("Name", Name, RawName);
     W.printBinary("Segment", SegmentName, RawSegmentName);
if (opts::SectionSymbols) {
         if (!Section.containsSymbol(Symbol))
           continue;
 
         printSymbol(Symbol);
       }
     }
 
     if (opts::SectionData && !Section.isBSS())
-      W.printBinaryBlock("SectionData", unwrapOrError(Obj->getFileName(),
-                                                      Section.getContents()));
+      W.printBinaryBlock(
+          "SectionData",
+          unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getContents()));
   }
 }
 
 void MachODumper::printRelocations() {
   ListScope D(W, "Relocations");
 
   std::error_code EC;
   for (const SectionRef &Section : Obj->sections()) {
-    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+    StringRef Name =
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
     bool PrintedGroup = false;
     for (const RelocationRef &Reloc : Section.relocations()) {
       if (!PrintedGroup) {
         W.startLine() << "Section " << Name << " {\n";
         W.indent();
         PrintedGroup = true;
       }
 
if (Symbol != Obj->symbol_end()) {
       Expected<StringRef> TargetNameOrErr = Symbol->getName();
       if (!TargetNameOrErr)
         reportError(TargetNameOrErr.takeError(), Obj->getFileName());
       TargetName = *TargetNameOrErr;
     }
   } else if (!IsScattered) {
     section_iterator SecI = Obj->getRelocationSection(DR);
     if (SecI != Obj->section_end())
-      TargetName = unwrapOrError(Obj->getFileName(), SecI->getName());
+      TargetName =
+          unwrapOrError_DEPRECATED(Obj->getFileName(), SecI->getName());
   }
   if (TargetName.empty())
     TargetName = "-";
 
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Offset);
     W.printNumber("PCRel", Obj->getAnyRelocationPCRel(RE));
void MachODumper::printSymbol(const SymbolRef &Symbol) {
 
   StringRef SectionName = "";
   Expected<section_iterator> SecIOrErr = Symbol.getSection();
   if (!SecIOrErr)
     reportError(SecIOrErr.takeError(), Obj->getFileName());
 
   section_iterator SecI = *SecIOrErr;
   if (SecI != Obj->section_end())
-    SectionName = unwrapOrError(Obj->getFileName(), SecI->getName());
+    SectionName = unwrapOrError_DEPRECATED(Obj->getFileName(), SecI->getName());
 
   DictScope D(W, "Symbol");
   W.printNumber("Name", SymbolName, MOSymbol.StringIndex);
   if (MOSymbol.Type & MachO::N_STAB) {
     W.printHex("Type", "SymDebugTable", MOSymbol.Type);
   } else {
     if (MOSymbol.Type & MachO::N_PEXT)
       W.startLine() << "PrivateExtern\n";
if (Name == "__llvm_stackmaps") {
       StackMapSection = Sec;
       break;
     }
   }
 
   if (StackMapSection == object::SectionRef())
     return;
 
-  StringRef StackMapContents =
-      unwrapOrError(Obj->getFileName(), StackMapSection.getContents());
+  StringRef StackMapContents = unwrapOrError_DEPRECATED(
+      Obj->getFileName(), StackMapSection.getContents());
   ArrayRef<uint8_t> StackMapContentsArray =
       arrayRefFromStringRef(StackMapContents);
 
   if (Obj->isLittleEndian())
     prettyPrintStackMap(
         W, StackMapParser<support::little>(StackMapContentsArray));
   else
     prettyPrintStackMap(

llvm/tools/llvm-readobj/ObjDumper.cpp

for (StringRef Section : Sections) {
     if (!Section.getAsInteger(0, SecIndex))
       SecIndices.emplace(SecIndex, false);
     else
       SecNames.emplace(std::string(Section), false);
   }
 
   SecIndex = Obj->isELF() ? 0 : 1;
   for (object::SectionRef SecRef : Obj->sections()) {
-    StringRef SecName = unwrapOrError(Obj->getFileName(), SecRef.getName());
+    StringRef SecName = unwrapOrError_DEPRECATED(Obj->getFileName(), SecRef.getName());
     auto NameIt = SecNames.find(std::string(SecName));
     if (NameIt != SecNames.end())
       NameIt->second = true;
     auto IndexIt = SecIndices.find(SecIndex);
     if (IndexIt != SecIndices.end())
       IndexIt->second = true;
     if (NameIt != SecNames.end() || IndexIt != SecIndices.end())
       Ret.push_back(SecRef);

 }
 
 void ObjDumper::printSectionsAsString(const object::ObjectFile *Obj,
                                       ArrayRef<std::string> Sections) {
   bool First = true;
   for (object::SectionRef Section :
        getSectionRefsByNameOrIndex(Obj, Sections)) {
     StringRef SectionName =
-        unwrapOrError(Obj->getFileName(), Section.getName());
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
 
     if (!First)
       W.startLine() << '\n';
     First = false;
     W.startLine() << "String dump of section '" << SectionName << "':\n";
 
     StringRef SectionContent =
-        unwrapOrError(Obj->getFileName(), Section.getContents());
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getContents());
 
     const uint8_t *SecContent = SectionContent.bytes_begin();
     const uint8_t *CurrentWord = SecContent;
     const uint8_t *SecEnd = SectionContent.bytes_end();
 
     while (CurrentWord <= SecEnd) {
       size_t WordSize = strnlen(reinterpret_cast<const char *>(CurrentWord),
                                 SecEnd - CurrentWord);

 }
 
 void ObjDumper::printSectionsAsHex(const object::ObjectFile *Obj,
                                    ArrayRef<std::string> Sections) {
   bool First = true;
   for (object::SectionRef Section :
        getSectionRefsByNameOrIndex(Obj, Sections)) {
     StringRef SectionName =
-        unwrapOrError(Obj->getFileName(), Section.getName());
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
 
     if (!First)
       W.startLine() << '\n';
     First = false;
     W.startLine() << "Hex dump of section '" << SectionName << "':\n";
 
     StringRef SectionContent =
-        unwrapOrError(Obj->getFileName(), Section.getContents());
+        unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getContents());
     const uint8_t *SecContent = SectionContent.bytes_begin();
     const uint8_t *SecEnd = SecContent + SectionContent.size();
 
     for (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
       const uint8_t *TmpSecPtr = SecPtr;
       uint8_t i;
       uint8_t k;
 

llvm/tools/llvm-readobj/WasmDumper.cpp

void WasmDumper::printRelocation(const SectionRef &Section,
   SmallString<64> RelocTypeName;
   uint64_t RelocType = Reloc.getType();
   Reloc.getTypeName(RelocTypeName);
   const wasm::WasmRelocation &WasmReloc = Obj->getWasmRelocation(Reloc);
 
   StringRef SymName;
   symbol_iterator SI = Reloc.getSymbol();
   if (SI != Obj->symbol_end())
-    SymName = unwrapOrError(Obj->getFileName(), SI->getName());
+    SymName = unwrapOrError_DEPRECATED(Obj->getFileName(), SI->getName());
 
   bool HasAddend = false;
   switch (RelocType) {
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:

 }
 
 void WasmDumper::printRelocations() {
   ListScope D(W, "Relocations");
 
   int SectionNumber = 0;
   for (const SectionRef &Section : Obj->sections()) {
     bool PrintedGroup = false;
-    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+    StringRef Name = unwrapOrError_DEPRECATED(Obj->getFileName(), Section.getName());
 
     ++SectionNumber;
 
     for (const RelocationRef &Reloc : Section.relocations()) {
       if (!PrintedGroup) {
         W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
         W.indent();
         PrintedGroup = true;

llvm/tools/llvm-readobj/XCOFFDumper.cpp

void XCOFFDumper::printRelocations(ArrayRef<XCOFFSectionHeader32> Sections) {
   ListScope LS(W, "Relocations");
   uint16_t Index = 0;
   for (const auto &Sec : Sections) {
     ++Index;
     // Only the .text, .data, .tdata, and STYP_DWARF sections have relocation.
     if (Sec.Flags != XCOFF::STYP_TEXT && Sec.Flags != XCOFF::STYP_DATA &&
         Sec.Flags != XCOFF::STYP_TDATA && Sec.Flags != XCOFF::STYP_DWARF)
       continue;
-    auto Relocations = unwrapOrError(Obj.getFileName(), Obj.relocations(Sec));
+    auto Relocations =
+        unwrapOrError_DEPRECATED(Obj.getFileName(), Obj.relocations(Sec));
     if (Relocations.empty())
       continue;
 
     W.startLine() << "Section (index: " << Index << ") " << Sec.getName()
                   << " {\n";
     for (auto Reloc : Relocations) {
-      StringRef SymbolName = unwrapOrError(
+      StringRef SymbolName = unwrapOrError_DEPRECATED(
           Obj.getFileName(), Obj.getSymbolNameByIndex(Reloc.SymbolIndex));
 
       DictScope RelocScope(W, "Relocation");
       W.printHex("Virtual Address", Reloc.VirtualAddress);
       W.printNumber("Symbol", SymbolName, Reloc.SymbolIndex);
       W.printString("IsSigned", Reloc.isRelocationSigned() ? "Yes" : "No");
       W.printNumber("FixupBitValue", Reloc.isFixupIndicated() ? 1 : 0);
       W.printNumber("Length", Reloc.getRelocatedLength());

 #undef ECase
 };
 
 void XCOFFDumper::printFileAuxEnt(const XCOFFFileAuxEnt *AuxEntPtr) {
   if (Obj.is64Bit())
     report_fatal_error(
         "Printing for File Auxiliary Entry in 64-bit is unimplemented.");
   StringRef FileName =
-      unwrapOrError(Obj.getFileName(), Obj.getCFileName(AuxEntPtr));
+      unwrapOrError_DEPRECATED(Obj.getFileName(), Obj.getCFileName(AuxEntPtr));
   DictScope SymDs(W, "File Auxiliary Entry");
   W.printNumber("Index",
                 Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(AuxEntPtr)));
   W.printString("Name", FileName);
   W.printEnum("Type", static_cast<uint8_t>(AuxEntPtr->Type),
               makeArrayRef(FileStringType));
 }
 
void XCOFFDumper::printSymbol(const SymbolRef &S) {
   const XCOFFSymbolEntry *SymbolEntPtr = Obj.toSymbolEntry(SymbolDRI);
 
   XCOFFSymbolRef XCOFFSymRef(SymbolDRI, &Obj);
   uint8_t NumberOfAuxEntries = XCOFFSymRef.getNumberOfAuxEntries();
 
   DictScope SymDs(W, "Symbol");
 
   StringRef SymbolName =
-      unwrapOrError(Obj.getFileName(), Obj.getSymbolName(SymbolDRI));
+      unwrapOrError_DEPRECATED(Obj.getFileName(), Obj.getSymbolName(SymbolDRI));
 
   W.printNumber("Index",
                 Obj.getSymbolIndex(reinterpret_cast<uintptr_t>(SymbolEntPtr)));
   W.printString("Name", SymbolName);
   W.printHex(GetSymbolValueName(SymbolEntPtr->StorageClass),
              SymbolEntPtr->Value);
 
   StringRef SectionName =
-      unwrapOrError(Obj.getFileName(), Obj.getSymbolSectionName(SymbolEntPtr));
+      unwrapOrError_DEPRECATED(Obj.getFileName(), Obj.getSymbolSectionName(SymbolEntPtr));
 
   W.printString("Section", SectionName);
   if (XCOFFSymRef.getStorageClass() == XCOFF::C_FILE) {
     W.printEnum("Source Language ID",
                 SymbolEntPtr->CFileLanguageIdAndTypeId.LanguageId,
                 makeArrayRef(CFileLangIdClass));
     W.printEnum("CPU Version ID",
                 SymbolEntPtr->CFileLanguageIdAndTypeId.CpuTypeId,

llvm/tools/llvm-readobj/llvm-readobj.h

namespace llvm {
   namespace object {
     class RelocationRef;
   }
 
   // Various helper functions.
   LLVM_ATTRIBUTE_NORETURN void reportError(Error Err, StringRef Input); 
   void reportWarning(Error Err, StringRef Input);
 
-  template <class T> T unwrapOrError(StringRef Input, Expected<T> EO) {
+  template <class T>
+  T unwrapOrError_DEPRECATED(StringRef Input, Expected<T> EO) {
     if (EO)
       return *EO;
     reportError(EO.takeError(), Input);
   }
 } // namespace llvm
 
 namespace opts {
   extern llvm::cl::opt<bool> SectionRelocations;