[llvm-readobj] - Remove 'error(Error EC)' helper.

[grimar]

Summary

We do not need it. I replaced it with
reportError(StringRef Input, Error Err)
almost without problems.

[MaskRay]

tools/llvm-readobj/COFFDumper.cpp

1922

reportError(..., codeview::visitTypeStream(..))

tools/llvm-readobj/ELFDumper.cpp

4417

if (Err) can be deleted

4429

if (Err) can be deleted

tools/llvm-readobj/llvm-readobj.cpp

385

reportError now checks if (!Err). Is it still appropriate to call it reportError? I want to hear other opinions.

[grimar]

tools/llvm-readobj/llvm-readobj.cpp

385

Previously error(Error EC) did that. I can probably remove if (!Err) check to avoid the confusion.

[jhenderson]

tools/llvm-readobj/llvm-readobj.cpp

385

I'd probably replace the if (!Err) check with an equivalent assertion. I think it's natural to write code like:

if (Error E = doSomething())
  reportError(File, std::move(E));

whereas the following looks weird to me:

reportError(doSomethingWhichWillSucceed());

An alternative name might be "checkError" if you didn't do that.

[MaskRay]

tools/llvm-readobj/llvm-readobj.cpp

385

checkError looks good to me.

[grimar]

tools/llvm-readobj/llvm-readobj.cpp

385

I'd probably stick to reportError version. It looks simpler and more natural to use for me.

[MaskRay]

tools/llvm-readobj/llvm-readobj.cpp

385

I think I slightly prefer Error being the first argument. This allows to use default arguments for other fields if we supply more arguments, e.g.:

checkError(Error E, StringRef FileName, StringRef ArchiveName,
             StringRef ArchitectureName = StringRef());

[grimar]

• Updated in according to the discussion.

tools/llvm-readobj/llvm-readobj.cpp

385

Ok, I made Error to be the first argument. I keeped reportError name and added an assert
to make sure it is used with if:

if (Err)
  reportError(Err, ...);

[jhenderson]

tools/llvm-readobj/COFFDumper.cpp

1158

Is EC an Error or std::error_code? If the latter, the move below is unnecessary.

1255

Same comment here and immediately below as above.

[grimar]

tools/llvm-readobj/COFFDumper.cpp

1158

It's an Error. EC is a bad original name, I can change it to E before the commit.

1255

It is also an Error returned here.

[grimar]

tools/llvm-readobj/COFFDumper.cpp

1158

Will also replace auto with an explicit type.

[jhenderson]

LGTM, with the suggestions.

test/tools/llvm-readobj/gnu-notes.test

- Name:         .note.gnu.gold-version
     Type:         SHT_NOTE
     AddressAlign: 0x0000000000000004
     Content:      040000000900000004000000474E5500676F6C6420312E3131000000
 
 ## Test tools report an error if a note section has an invalid offset
 ## that goes past the end of file.
 
 # RUN: yaml2obj --docnum=2 %s > %t2.so
-# RUN: not llvm-readelf --notes %t2.so 2>&1 | FileCheck %s --check-prefix=ERR1
-# RUN: not llvm-readobj --notes %t2.so 2>&1 | FileCheck %s --check-prefix=ERR1
+# RUN: not llvm-readelf --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1
+# RUN: not llvm-readobj --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1
 
-# ERR1: error: SHT_NOTE section [index 1] has invalid offset (0xffff0000) or size (0x0)
+# ERR1: error: '[[FILE]]': SHT_NOTE section [index 1] has invalid offset (0xffff0000) or size (0x0)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:     .note
     Type:     SHT_NOTE
     ShOffset: 0xffff0000
 
 ## Test tools report an error if a note section has invalid size
 ## that goes past the end of file.
 
 # RUN: yaml2obj --docnum=3 %s > %t3.so
-# RUN: not llvm-readelf --notes %t3.so 2>&1 | FileCheck %s --check-prefix=ERR2
-# RUN: not llvm-readobj --notes %t3.so 2>&1 | FileCheck %s --check-prefix=ERR2
+# RUN: not llvm-readelf --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2
+# RUN: not llvm-readobj --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2
 
-# ERR2: error: SHT_NOTE section [index 1] has invalid offset (0x180) or size (0xffff0000)
+# ERR2: error: '[[FILE]]': SHT_NOTE section [index 1] has invalid offset (0x180) or size (0xffff0000)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:   .note
     Type:   SHT_NOTE
     ShSize: 0xffff0000
 
 ## Test tools report an error if a note program header has an invalid offset that
 ## goes past the end of file.
 
 # RUN: yaml2obj --docnum=4 %s > %t4.so
-# RUN: not llvm-readelf --notes %t4.so 2>&1 | FileCheck %s --check-prefix=ERR3
-# RUN: not llvm-readobj --notes %t4.so 2>&1 | FileCheck %s --check-prefix=ERR3
+# RUN: not llvm-readelf --notes %t4.so 2>&1 | FileCheck -DFILE=%t4.so %s --check-prefix=ERR3
+# RUN: not llvm-readobj --notes %t4.so 2>&1 | FileCheck -DFILE=%t4.so %s --check-prefix=ERR3
 
-# ERR3: error: PT_NOTE header has invalid offset (0xffff0000) or size (0x0)
+# ERR3: error: '[[FILE]]': PT_NOTE header has invalid offset (0xffff0000) or size (0x0)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_CORE
   Machine: EM_X86_64
 Sections:
   - Name: .note
     Type: SHT_NOTE
 ProgramHeaders:
   - Type: PT_NOTE
     Offset: 0xffff0000
     Sections:
       - Section: .note
 
 ## Test tools report an error if a note program header has an invalid size that
 ## goes past the end of file.
 
 # RUN: yaml2obj --docnum=5 %s > %t5.so
-# RUN: not llvm-readelf --notes %t5.so 2>&1 | FileCheck %s --check-prefix=ERR4
-# RUN: not llvm-readobj --notes %t5.so 2>&1 | FileCheck %s --check-prefix=ERR4
+# RUN: not llvm-readelf --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so  %s --check-prefix=ERR4
+# RUN: not llvm-readobj --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4
 
-# ERR4: error: PT_NOTE header has invalid offset (0x1b8) or size (0xffff0000)
+# ERR4: error: '[[FILE]]': PT_NOTE header has invalid offset (0x1b8) or size (0xffff0000)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_CORE
   Machine: EM_X86_64
 Sections:
   - Name: .note
     Type: SHT_NOTE
 ProgramHeaders:
   - Type: PT_NOTE
     FileSize: 0xffff0000
     Sections:
       - Section: .note

tools/llvm-readobj/ARMEHABIPrinter.h

 template <typename ET>
 ErrorOr<StringRef>
 PrinterContext<ET>::FunctionAtAddress(unsigned Section,
                                       uint64_t Address) const {
   if (!Symtab)
     return readobj_error::unknown_symbol;
   auto StrTableOrErr = ELF->getStringTableForSymtab(*Symtab);
   if (!StrTableOrErr)
-    error(StrTableOrErr.takeError());
+    reportError(FileName, StrTableOrErr.takeError());
   StringRef StrTable = *StrTableOrErr;
 
   for (const Elf_Sym &Sym : unwrapOrError(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.
PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
   /// table.
 
   for (const Elf_Shdr &Sec : unwrapOrError(FileName, ELF->sections())) {
     if (Sec.sh_type != ELF::SHT_REL || Sec.sh_info != IndexSectionIndex)
       continue;
 
     auto SymTabOrErr = ELF->getSection(Sec.sh_link);
     if (!SymTabOrErr)
-      error(SymTabOrErr.takeError());
+      reportError(FileName, SymTabOrErr.takeError());
     const Elf_Shdr *SymTab = *SymTabOrErr;
 
     for (const Elf_Rel &R : unwrapOrError(FileName, ELF->rels(&Sec))) {
       if (R.r_offset != static_cast<unsigned>(IndexTableOffset))
         continue;
 
       typename ET::Rela RelA;
       RelA.r_offset = R.r_offset;

tools/llvm-readobj/COFFDumper.cpp

 }
 
 void COFFDumper::initializeFileAndStringTables(BinaryStreamReader &Reader) {
   while (Reader.bytesRemaining() > 0 &&
          (!CVFileChecksumTable.valid() || !CVStringTable.valid())) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
     uint32_t SubType, SubSectionSize;
-    error(Reader.readInteger(SubType));
-    error(Reader.readInteger(SubSectionSize));
+    reportError(Obj->getFileName(), Reader.readInteger(SubType));
+    reportError(Obj->getFileName(), Reader.readInteger(SubSectionSize));
 
     StringRef Contents;
-    error(Reader.readFixedString(Contents, SubSectionSize));
+    reportError(Obj->getFileName(),
+                Reader.readFixedString(Contents, SubSectionSize));
 
     BinaryStreamRef ST(Contents, support::little);
     switch (DebugSubsectionKind(SubType)) {
     case DebugSubsectionKind::FileChecksums:
-      error(CVFileChecksumTable.initialize(ST));
+      reportError(Obj->getFileName(), CVFileChecksumTable.initialize(ST));
       break;
     case DebugSubsectionKind::StringTable:
-      error(CVStringTable.initialize(ST));
+      reportError(Obj->getFileName(), CVStringTable.initialize(ST));
       break;
     default:
       break;
     }
 
     uint32_t PaddedSize = alignTo(SubSectionSize, 4);
-    error(Reader.skip(PaddedSize - SubSectionSize));
+    reportError(Obj->getFileName(), Reader.skip(PaddedSize - SubSectionSize));
   }
 }
 
 void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
                                             const SectionRef &Section) {
   StringRef SectionContents =
       unwrapOrError(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));
 
   uint32_t Magic;
-  error(consume(Data, Magic));
+  reportError(Obj->getFileName(), consume(Data, Magic));
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return error(object_error::parse_failed);
 
   BinaryStreamReader FSReader(Data, support::little);
   initializeFileAndStringTables(FSReader);
 
   // TODO: Convert this over to using ModuleSubstreamVisitor.
   while (!Data.empty()) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
     uint32_t SubType, SubSectionSize;
-    error(consume(Data, SubType));
-    error(consume(Data, SubSectionSize));
+    reportError(Obj->getFileName(), consume(Data, SubType));
+    reportError(Obj->getFileName(), consume(Data, SubSectionSize));
 
     ListScope S(W, "Subsection");
     // Dump the subsection as normal even if the ignore bit is set.
     if (SubType & SubsectionIgnoreFlag) {
       W.printHex("IgnoredSubsectionKind", SubType);
       SubType &= ~SubsectionIgnoreFlag;
     }
     W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes));
case DebugSubsectionKind::Lines: {
       FunctionNames.push_back(LinkageName);
       break;
     }
     case DebugSubsectionKind::FrameData: {
       // First four bytes is a relocation against the function.
       BinaryStreamReader SR(Contents, llvm::support::little);
 
       DebugFrameDataSubsectionRef FrameData;
-      error(FrameData.initialize(SR));
+      reportError(Obj->getFileName(), FrameData.initialize(SR));
 
       StringRef LinkageName;
       error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents,
                               FrameData.getRelocPtr(), LinkageName));
       W.printString("LinkageName", LinkageName);
 
       // To find the active frame description, search this array for the
       // smallest PC range that includes the current PC.
void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
   for (unsigned I = 0, E = FunctionNames.size(); I != E; ++I) {
     StringRef Name = FunctionNames[I];
     ListScope S(W, "FunctionLineTable");
     W.printString("LinkageName", Name);
 
     BinaryStreamReader Reader(FunctionLineTables[Name], support::little);
 
     DebugLinesSubsectionRef LineInfo;
-    error(LineInfo.initialize(Reader));
+    reportError(Obj->getFileName(), LineInfo.initialize(Reader));
 
     W.printHex("Flags", LineInfo.header()->Flags);
     W.printHex("CodeSize", LineInfo.header()->CodeSize);
     for (const auto &Entry : LineInfo) {
 
       ListScope S(W, "FilenameSegment");
       printFileNameForOffset("Filename", Entry.NameIndex);
       uint32_t ColumnIndex = 0;
void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
   CVSymbolArray Symbols;
   BinaryStreamReader Reader(BinaryData, llvm::support::little);
   if (auto EC = Reader.readArray(Symbols, Reader.getLength())) {
     consumeError(std::move(EC));
     W.flush();
     error(object_error::parse_failed);
   }
 
   if (auto EC = CVSD.dump(Symbols)) {
     W.flush();
-    error(std::move(EC));
+    reportError(Obj->getFileName(), std::move(EC));
   }
   CompilationCPUType = CVSD.getCompilationCPUType();
   W.flush();
 }
 
 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
   BinaryStreamRef Stream(Subsection, llvm::support::little);
   DebugChecksumsSubsectionRef Checksums;
-  error(Checksums.initialize(Stream));
+  reportError(Obj->getFileName(), Checksums.initialize(Stream));
 
   for (auto &FC : Checksums) {
     DictScope S(W, "FileChecksum");
 
     StringRef Filename = unwrapOrError(
         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);
   }
 }
 
 void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) {
   BinaryStreamReader SR(Subsection, llvm::support::little);
   DebugInlineeLinesSubsectionRef Lines;
-  error(Lines.initialize(SR));
+  reportError(Obj->getFileName(), Lines.initialize(SR));
 
   for (auto &Line : Lines) {
     DictScope S(W, "InlineeSourceLine");
     printTypeIndex("Inlinee", Line.Header->Inlinee);
     printFileNameForOffset("FileID", Line.Header->FileID);
     W.printNumber("SourceLineNum", Line.Header->SourceLineNum);
 
     if (Lines.hasExtraFiles()) {
void COFFDumper::mergeCodeViewTypes(MergingTypeTableBuilder &CVIDs,
                                     GlobalTypeTableBuilder &GlobalCVTypes,
                                     bool GHash) {
   for (const SectionRef &S : Obj->sections()) {
     StringRef SectionName;
     error(S.getName(SectionName));
     if (SectionName == ".debug$T") {
       StringRef Data = unwrapOrError(Obj->getFileName(), S.getContents());
       uint32_t Magic;
-      error(consume(Data, Magic));
+      reportError(Obj->getFileName(), consume(Data, Magic));
       if (Magic != 4)
         error(object_error::parse_failed);
 
       CVTypeArray Types;
       BinaryStreamReader Reader(Data, llvm::support::little);
       if (auto EC = Reader.readArray(Types, Reader.getLength())) {
         consumeError(std::move(EC));
         W.flush();
         error(object_error::parse_failed);
       }
       SmallVector<TypeIndex, 128> SourceToDest;
       Optional<uint32_t> PCHSignature;
       if (GHash) {
         std::vector<GloballyHashedType> Hashes =
             GloballyHashedType::hashTypes(Types);
         if (auto EC =
                 mergeTypeAndIdRecords(GlobalCVIDs, GlobalCVTypes, SourceToDest,
                                       Types, Hashes, PCHSignature))
-          return error(std::move(EC));
+          return reportError(Obj->getFileName(), std::move(EC));
       } else {
         if (auto EC = mergeTypeAndIdRecords(CVIDs, CVTypes, SourceToDest, Types,
                                             PCHSignature))
-          return error(std::move(EC));
+          return reportError(Obj->getFileName(), std::move(EC));
       }
     }
   }
 }
 
 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());
   if (opts::CodeViewSubsectionBytes)
     W.printBinaryBlock("Data", Data);
 
   uint32_t Magic;
-  error(consume(Data, Magic));
+  reportError(Obj->getFileName(), consume(Data, Magic));
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return error(object_error::parse_failed);
 
   Types.reset(Data, 100);
 
   TypeDumpVisitor TDV(Types, &W, opts::CodeViewSubsectionBytes);
-  error(codeview::visitTypeStream(Types, TDV));
+  reportError(Obj->getFileName(), codeview::visitTypeStream(Types, TDV));
   W.flush();
 }
 
 void COFFDumper::printSectionHeaders() {
   ListScope SectionsD(W, "Sections");
   int SectionNumber = 0;
   for (const SectionRef &Sec : Obj->sections()) {
     ++SectionNumber;
if (Symbol.isFunctionDefinition()) {
       if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
           && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
         const coff_section *Assoc;
         StringRef AssocName = "";
         if (std::error_code EC = Obj->getSection(AuxNumber, Assoc))
           error(EC);
         Expected<StringRef> Res = getSectionName(Obj, AuxNumber, Assoc);
         if (!Res)
-          error(Res.takeError());
+          reportError(Obj->getFileName(), Res.takeError());
         AssocName = *Res;
 
         W.printNumber("AssocSection", AssocName, AuxNumber);
       }
     } else if (Symbol.isCLRToken()) {
       const coff_aux_clr_token *Aux;
       error(getSymbolAuxData(Obj, Symbol, I, Aux));
 

 
 void llvm::dumpCodeViewMergedTypes(ScopedPrinter &Writer,
                                    ArrayRef<ArrayRef<uint8_t>> IpiRecords,
                                    ArrayRef<ArrayRef<uint8_t>> TpiRecords) {
   TypeTableCollection TpiTypes(TpiRecords);
   {
     ListScope S(Writer, "MergedTypeStream");
     TypeDumpVisitor TDV(TpiTypes, &Writer, opts::CodeViewSubsectionBytes);
-    error(codeview::visitTypeStream(TpiTypes, TDV));
+    if (Error Err = codeview::visitTypeStream(TpiTypes, TDV))
+      reportError("<?>", std::move(Err));
     Writer.flush();
   }
 
   // Flatten the id stream and print it next. The ID stream refers to names from
   // the type stream.
   TypeTableCollection IpiTypes(IpiRecords);
   {
     ListScope S(Writer, "MergedIDStream");
     TypeDumpVisitor TDV(TpiTypes, &Writer, opts::CodeViewSubsectionBytes);
     TDV.setIpiTypes(IpiTypes);
-    error(codeview::visitTypeStream(IpiTypes, TDV));
+    if (Error Err = codeview::visitTypeStream(IpiTypes, TDV))
+      reportError("<?>", std::move(Err));
     Writer.flush();
   }
 }

tools/llvm-readobj/ELFDumper.cpp

if (Obj->getHeader()->e_type == ELF::ET_CORE) {
     for (const auto &P :
          unwrapOrError(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       PrintHeader(P.p_offset, P.p_filesz);
       Error Err = Error::success();
       for (const auto &Note : Obj->notes(P, Err))
         ProcessNote(Note);
       if (Err)
-        error(std::move(Err));
+        reportError(this->FileName, std::move(Err));
     }
   } else {
     for (const auto &S :
          unwrapOrError(this->FileName, Obj->sections())) {
       if (S.sh_type != SHT_NOTE)
         continue;
       PrintHeader(S.sh_offset, S.sh_size);
       Error Err = Error::success();
       for (const auto &Note : Obj->notes(S, Err))
         ProcessNote(Note);
       if (Err)
-        error(std::move(Err));
+        reportError(this->FileName, std::move(Err));
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   OS << "printELFLinkerOptions not implemented!\n";
 }
for (const auto &P :
          unwrapOrError(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 (const auto &Note : Obj->notes(P, Err))
         ProcessNote(Note);
-      if (Err)
-        error(std::move(Err));
+      reportError(this->FileName, std::move(Err));
     }
   } else {
     for (const auto &S : unwrapOrError(this->FileName, Obj->sections())) {
       if (S.sh_type != SHT_NOTE)
         continue;
       DictScope D(W, "NoteSection");
       PrintHeader(S.sh_offset, S.sh_size);
       Error Err = Error::success();
       for (const auto &Note : Obj->notes(S, Err))
         ProcessNote(Note);
-      if (Err)
-        error(std::move(Err));
+      reportError(this->FileName, std::move(Err));
     }
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printELFLinkerOptions(const ELFFile<ELFT> *Obj) {
   ListScope L(W, "LinkerOptions");
 

tools/llvm-readobj/Win64EHDumper.cpp

void Dumper::printRuntimeFunction(const Context &Ctx,
   DictScope RFS(SW, "RuntimeFunction");
   printRuntimeFunctionEntry(Ctx, Section, SectionOffset, RF);
 
   const coff_section *XData;
   uint64_t Offset;
   resolveRelocation(Ctx, Section, SectionOffset + 8, XData, Offset);
 
   ArrayRef<uint8_t> Contents;
-  error(Ctx.COFF.getSectionContents(XData, Contents));
+  reportError(Ctx.COFF.getFileName(),
+              Ctx.COFF.getSectionContents(XData, Contents));
   if (Contents.empty())
     return;
 
   Offset = Offset + RF.UnwindInfoOffset;
   if (Offset > Contents.size())
     return;
 
   const auto UI = reinterpret_cast<const UnwindInfo*>(Contents.data() + Offset);
   printUnwindInfo(Ctx, XData, Offset, *UI);
 }
 
 void Dumper::printData(const Context &Ctx) {
   for (const auto &Section : Ctx.COFF.sections()) {
     StringRef Name;
     Section.getName(Name);
 
     if (Name != ".pdata" && !Name.startswith(".pdata$"))
       continue;
 
     const coff_section *PData = Ctx.COFF.getCOFFSection(Section);
     ArrayRef<uint8_t> Contents;
-    error(Ctx.COFF.getSectionContents(PData, Contents));
+    reportError(Ctx.COFF.getFileName(),
+                Ctx.COFF.getSectionContents(PData, Contents));
     if (Contents.empty())
       continue;
 
     const RuntimeFunction *Entries =
       reinterpret_cast<const RuntimeFunction *>(Contents.data());
     const size_t Count = Contents.size() / sizeof(RuntimeFunction);
     ArrayRef<RuntimeFunction> RuntimeFunctions(Entries, Count);
 

tools/llvm-readobj/llvm-readobj.h

namespace llvm {
 
   // Various helper functions.
   LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg);
   void reportError(StringRef Input, Error Err); 
   void reportWarning(Twine Msg);
   void reportWarning(StringRef Input, Error Err);
   void warn(llvm::Error Err);
   void error(std::error_code EC);
-  void error(llvm::Error EC);
 
   template <class T> T unwrapOrError(StringRef Input, Expected<T> EO) {
     if (EO)
       return *EO;
     reportError(Input, EO.takeError());
     llvm_unreachable("reportError shouldn't return in this case");
   }
 } // namespace llvm

tools/llvm-readobj/llvm-readobj.cpp

 
 LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) {
   fouts().flush();
   errs() << "\n";
   WithColor::error(errs()) << Msg << "\n";
   exit(1);
 }
 
 void reportError(StringRef Input, Error Err) {
+  if (!Err)
+    return;
   if (Input == "-")
     Input = "<stdin>";
-  error(createFileError(Input, std::move(Err)));
+  handleAllErrors(createFileError(Input, std::move(Err)),
+                  [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
 }
 
 void reportWarning(Twine Msg) {
   fouts().flush();
   errs() << "\n";
   WithColor::warning(errs()) << Msg << "\n";
 }
 
 void reportWarning(StringRef Input, Error Err) {
   if (Input == "-")
     Input = "<stdin>";
   warn(createFileError(Input, std::move(Err)));
 }
 
 void warn(Error Err) {
   handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
     reportWarning(EI.message());
   });
 }
 
-void error(Error EC) {
-  if (!EC)
-    return;
-  handleAllErrors(std::move(EC),
-                  [&](const ErrorInfoBase &EI) { reportError(EI.message()); });
-}
-
 void error(std::error_code EC) {
   if (!EC)
     return;
   reportError(EC.message());
 }
 
 } // namespace llvm