[llvm-readobj] - Remove Error.cpp,.h and drop dependencies in the code.

[grimar]

Summary

We have Error.cpp/.h which contains some code for working with error codes.
In fact we use Error/Expected<> almost everywhere already and we can get rid
of these files.

Note: a few places in the code used readobj specific error codes,
e.g. return readobj_error::unknown_symbol. But these codes are never really used,
i.e. the code checks the fact of a success/error call only.
So I've changes them to return inconvertibleErrorCode() for now.
It seems that these places probably should be converted to use Error/Expected<>.

Rebased on top of D86771.

[sbc100]

llvm/tools/llvm-readobj/llvm-readobj.cpp

640

Should we assert or llvm_unreachable here then? Since it should be impossible to get here because the above "case" statement should handle all valid file types?

[grimar]

llvm/tools/llvm-readobj/llvm-readobj.cpp

640

I don't think that it is right to use llvm_unreachable, because I guess it might be possible that one day a new object format appears, but will be unsupported by llvm-readelf. We probably don't want to fail in this case, but want to show an error message I think.

Regarding adding an assert, I don't know. I don't have any stong feeling about it.

[jhenderson]

llvm/tools/llvm-readobj/llvm-readobj.cpp

582

This doesn't look clang-formatted.

589–590

I think the message should be: "foo.o has an unrecognized file type" (or possibly even "unsupported" instead of "unrecognized").

640

I think llvm_unreachable is the right thing here. Currently, it should be impossible to reach this code (hence "unreachable"). The only way that it would be reachable is if somebody adds a new variety of Binary without properly adding support for it everywhere. This is a programmer error, so assert/llvm_unreachable is the way to report this. Since this code can't be executed under current state, llvm_unreachable is more appropriate than assert (which is better used for checking pre/post conditions).

If one day a user does add a new file type, which shouldn't be supported by llvm-readobj, they can change to reporting a normal error as you are currently doing. This would be a conscious decision on their part, to not (at that point) add the support.

[grimar]

• Addressed review comments.

llvm/tools/llvm-readobj/llvm-readobj.cpp

640

OK, I've used llvm_unreachable.

[jhenderson]

LGTM.

llvm/test/tools/llvm-readobj/archive.test

 
 # RUN: rm -f %t2.a
 # RUN: llvm-ar rc %t.dir/broken.a %t.dir/trivial.obj.elf-x86-64
 # RUN: llvm-ar qc %t2.a %t.dir/trivial.obj.elf-x86-64 %t.dir/broken.a %t.dir/trivial.obj.elf-x86-64
 # RUN: llvm-readobj --all %t2.a 2>&1 | FileCheck %s -DARFILE="%t2.a" --check-prefix=BROKEN
 # RUN: llvm-readelf --all %t2.a 2>&1 | FileCheck %s -DARFILE="%t2.a" --check-prefix=BROKEN
 
 # BROKEN: File: [[ARFILE]](trivial.obj.elf-x86-64)
-# BROKEN: warning: '[[ARFILE]]': Unrecognized file type.
+# BROKEN: warning: '[[ARFILE]]': unrecognized file type of broken.a
 # BROKEN: File: [[ARFILE]](trivial.obj.elf-x86-64)

llvm/tools/llvm-readobj/ARMEHABIPrinter.h

 //===--- ARMEHABIPrinter.h - ARM EHABI Unwind Information Printer ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H
 #define LLVM_TOOLS_LLVM_READOBJ_ARMEHABIPRINTER_H
 
-#include "Error.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Support/ARMEHABI.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Format.h"

 template <typename ET>
 const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
 
 template <typename ET>
 ErrorOr<StringRef>
 PrinterContext<ET>::FunctionAtAddress(unsigned Section,
                                       uint64_t Address) const {
   if (!Symtab)
-    return readobj_error::unknown_symbol;
+    return inconvertibleErrorCode();
   auto StrTableOrErr = ELF->getStringTableForSymtab(*Symtab);
   if (!StrTableOrErr)
     reportError(StrTableOrErr.takeError(), FileName);
   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.
         consumeError(NameOrErr.takeError());
-        return readobj_error::unknown_symbol;
+        return inconvertibleErrorCode();
       }
       return *NameOrErr;
     }
-  return readobj_error::unknown_symbol;
+  return inconvertibleErrorCode();
 }
 
 template <typename ET>
 const typename ET::Shdr *
 PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
                                        off_t IndexTableOffset) const {
   /// Iterate through the sections, searching for the relocation section
   /// associated with the unwind index table section specified by

llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp

 // beginning of the frame.
 //
 // The byte-code maintains a 1-1 instruction mapping, indicating both the width
 // of the instruction (Thumb2 instructions are variable length, 16 or 32 bits
 // wide) allowing the program to unwind from any point in the prologue, body, or
 // epilogue of the function.
 
 #include "ARMWinEHPrinter.h"
-#include "Error.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ARMWinEH.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support;

 Decoder::getSectionContaining(const COFFObjectFile &COFF, uint64_t VA) {
   for (const auto &Section : COFF.sections()) {
     uint64_t Address = Section.getAddress();
     uint64_t Size = Section.getSize();
 
     if (VA >= Address && (VA - Address) <= Size)
       return Section;
   }
-  return readobj_error::unknown_symbol;
+  return inconvertibleErrorCode();
 }
 
 ErrorOr<object::SymbolRef> Decoder::getSymbol(const COFFObjectFile &COFF,
                                               uint64_t VA, bool FunctionOnly) {
   for (const auto &Symbol : COFF.symbols()) {
     Expected<SymbolRef::Type> Type = Symbol.getType();
     if (!Type)
       return errorToErrorCode(Type.takeError());
     if (FunctionOnly && *Type != SymbolRef::ST_Function)
       continue;
 
     Expected<uint64_t> Address = Symbol.getAddress();
     if (!Address)
       return errorToErrorCode(Address.takeError());
     if (*Address == VA)
       return Symbol;
   }
-  return readobj_error::unknown_symbol;
+  return inconvertibleErrorCode();
 }
 
 ErrorOr<SymbolRef> Decoder::getRelocatedSymbol(const COFFObjectFile &,
                                                const SectionRef &Section,
                                                uint64_t Offset) {
   for (const auto &Relocation : Section.relocations()) {
     uint64_t RelocationOffset = Relocation.getOffset();
     if (RelocationOffset == Offset)
       return *Relocation.getSymbol();
   }
-  return readobj_error::unknown_symbol;
+  return inconvertibleErrorCode();
 }
 
 bool Decoder::opcode_0xxxxxxx(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   uint8_t Imm = OC[Offset] & 0x7f;
   SW.startLine() << format("0x%02x                ; %s sp, #(%u * 4)\n",
                            OC[Offset],
                            static_cast<const char *>(Prologue ? "sub" : "add"),

llvm/tools/llvm-readobj/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   DebugInfoPDB
   )
 
 add_llvm_tool(llvm-readobj
   ARMWinEHPrinter.cpp
   COFFDumper.cpp
   COFFImportDumper.cpp
   ELFDumper.cpp
-  Error.cpp
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
   WasmDumper.cpp
   Win64EHDumper.cpp
   WindowsResourceDumper.cpp
   XCOFFDumper.cpp
   )
 
 add_llvm_tool_symlink(llvm-readelf llvm-readobj)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(readelf llvm-readobj)
 endif()

llvm/tools/llvm-readobj/COFFDumper.cpp

 //===-- COFFDumper.cpp - COFF-specific dumper -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the COFF-specific dumper for llvm-readobj.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ARMWinEHPrinter.h"
-#include "Error.h"
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "Win64EHDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
for (const auto &Relocation : Relocations) {
     uint64_t RelocationOffset = Relocation.getOffset();
 
     if (RelocationOffset == Offset) {
       SymI = Relocation.getSymbol();
       break;
     }
   }
   if (SymI == Obj->symbol_end())
-    return readobj_error::unknown_symbol;
+    return inconvertibleErrorCode();
   Sym = *SymI;
-  return readobj_error::success;
+  return std::error_code();
 }
 
 // Given a section and an offset into this section the function returns the name
 // of the symbol used for the relocation at the offset.
 std::error_code COFFDumper::resolveSymbolName(const coff_section *Section,
                                               uint64_t Offset,
                                               StringRef &Name) {
   SymbolRef Symbol;

 
 template <typename T>
 static std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
                                         COFFSymbolRef Symbol,
                                         uint8_t AuxSymbolIdx, const T *&Aux) {
   ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol);
   AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize());
   Aux = reinterpret_cast<const T*>(AuxData.data());
-  return readobj_error::success;
+  return std::error_code();
 }
 
 void COFFDumper::cacheRelocations() {
   if (RelocCached)
     return;
   RelocCached = true;
 
   for (const SectionRef &S : Obj->sections()) {

llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h

 //===--- DwarfCFIEHPrinter.h - DWARF-based Unwind Information Printer -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_DWARFCFIEHPRINTER_H
 #define LLVM_TOOLS_LLVM_READOBJ_DWARFCFIEHPRINTER_H
 
-#include "Error.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"

llvm/tools/llvm-readobj/ELFDumper.cpp

 //===- ELFDumper.cpp - ELF-specific dumper --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the ELF-specific dumper for llvm-readobj.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ARMEHABIPrinter.h"
 #include "DwarfCFIEHPrinter.h"
-#include "Error.h"
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"

llvm/tools/llvm-readobj/Error.h

-//===- Error.h - system_error extensions for llvm-readobj -------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This declares a new error_category for the llvm-readobj tool.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TOOLS_LLVM_READOBJ_ERROR_H
-#define LLVM_TOOLS_LLVM_READOBJ_ERROR_H
-
-#include <system_error>
-
-namespace llvm {
-const std::error_category &readobj_category();
-
-enum class readobj_error {
-  success = 0,
-  file_not_found,
-  unsupported_file_format,
-  unrecognized_file_format,
-  unsupported_obj_file_format,
-  unknown_symbol
-};
-
-inline std::error_code make_error_code(readobj_error e) {
-  return std::error_code(static_cast<int>(e), readobj_category());
-}
-
-} // namespace llvm
-
-namespace std {
-template <> struct is_error_code_enum<llvm::readobj_error> : std::true_type {};
-}
-
-#endif

llvm/tools/llvm-readobj/Error.cpp

-//===- Error.cpp - system_error extensions for llvm-readobj -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This defines a new error_category for the llvm-readobj tool.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Error.h"
-#include "llvm/Support/ErrorHandling.h"
-
-using namespace llvm;
-
-namespace {
-// FIXME: This class is only here to support the transition to llvm::Error. It
-// will be removed once this transition is complete. Clients should prefer to
-// deal with the Error value directly, rather than converting to error_code.
-class _readobj_error_category : public std::error_category {
-public:
-  const char* name() const noexcept override;
-  std::string message(int ev) const override;
-};
-} // namespace
-
-const char *_readobj_error_category::name() const noexcept {
-  return "llvm.readobj";
-}
-
-std::string _readobj_error_category::message(int EV) const {
-  switch (static_cast<readobj_error>(EV)) {
-  case readobj_error::success: return "Success";
-  case readobj_error::file_not_found:
-    return "No such file.";
-  case readobj_error::unsupported_file_format:
-    return "The file was not recognized as a valid object file.";
-  case readobj_error::unrecognized_file_format:
-    return "Unrecognized file type.";
-  case readobj_error::unsupported_obj_file_format:
-    return "Unsupported object file format.";
-  case readobj_error::unknown_symbol:
-    return "Unknown symbol.";
-  }
-  llvm_unreachable("An enumerator of readobj_error does not have a message "
-                   "defined.");
-}
-
-namespace llvm {
-const std::error_category &readobj_category() {
-  static _readobj_error_category o;
-  return o;
-}
-} // namespace llvm

llvm/tools/llvm-readobj/MachODumper.cpp

 //===- MachODumper.cpp - Object file dumping utility for llvm -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the MachO-specific dumper for llvm-readobj.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Error.h"
 #include "ObjDumper.h"
 #include "StackMapPrinter.h"
 #include "llvm-readobj.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ScopedPrinter.h"

llvm/tools/llvm-readobj/ObjDumper.cpp

 //===-- ObjDumper.cpp - Base dumper class -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements ObjDumper.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ObjDumper.h"
-#include "Error.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 

llvm/tools/llvm-readobj/WasmDumper.cpp

 //===-- WasmDumper.cpp - Wasm-specific object file dumper -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Wasm-specific dumper for llvm-readobj.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Error.h"
 #include "ObjDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace object;
 

llvm/tools/llvm-readobj/Win64EHDumper.cpp

 //===- Win64EHDumper.cpp - Win64 EH Printer ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Win64EHDumper.h"
-#include "Error.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::Win64EH;

 static std::error_code getSymbol(const COFFObjectFile &COFF, uint64_t VA,
                                  object::SymbolRef &Sym) {
   for (const auto &Symbol : COFF.symbols()) {
     Expected<uint64_t> Address = Symbol.getAddress();
     if (!Address)
       return errorToErrorCode(Address.takeError());
     if (*Address == VA) {
       Sym = Symbol;
-      return readobj_error::success;
+      return std::error_code();
     }
   }
-  return readobj_error::unknown_symbol;
+  return inconvertibleErrorCode();
 }
 
 static std::string formatSymbol(const Dumper::Context &Ctx,
                                 const coff_section *Section, uint64_t Offset,
                                 uint32_t Displacement) {
   std::string Buffer;
   raw_string_ostream OS(Buffer);
 

llvm/tools/llvm-readobj/WindowsResourceDumper.cpp

 //===-- WindowsResourceDumper.cpp - Windows Resource printer --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Windows resource (.res) dumper for llvm-readobj.
 //
 //===----------------------------------------------------------------------===//
 
 #include "WindowsResourceDumper.h"
-#include "Error.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 namespace llvm {
 namespace object {
 namespace WindowsRes {
 

llvm/tools/llvm-readobj/XCOFFDumper.cpp

 //===-- XCOFFDumper.cpp - XCOFF dumping utility -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements an XCOFF specific dumper for llvm-readobj.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Error.h"
 #include "ObjDumper.h"
 #include "llvm-readobj.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace object;
 

llvm/tools/llvm-readobj/llvm-readobj.cpp

 // does not need to be identical. The point is to not make users learn yet
 // another set of flags.
 //
 // Output should be specialized for each format where appropriate.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-readobj.h"
-#include "Error.h"
 #include "ObjDumper.h"
 #include "WindowsResourceDumper.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachOUniversal.h"
static void dumpArchive(const Archive *Arc, ScopedPrinter &Writer) {
   Error Err = Error::success();
   for (auto &Child : Arc->children(Err)) {
     Expected<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();
     if (!ChildOrErr) {
       if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
         reportError(std::move(E), Arc->getFileName());
       continue;
     }
-    if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
+
+    Binary* Bin = ChildOrErr->get();
+    if (ObjectFile *Obj = dyn_cast<ObjectFile>(Bin))
       dumpObject(*Obj, Writer, Arc);
-    else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(&*ChildOrErr.get()))
+    else if (COFFImportFile *Imp = dyn_cast<COFFImportFile>(Bin))
       dumpCOFFImportFile(Imp, Writer);
     else
-      reportWarning(errorCodeToError(readobj_error::unrecognized_file_format),
-                    Arc->getFileName());
+      reportWarning(
+          createStringError(errc::invalid_argument,
+                            "unrecognized file type of " + Bin->getFileName()),
   }
   if (Err)
     reportError(std::move(Err), Arc->getFileName());
 }
 
 /// Dumps each object file in \a MachO Universal Binary;
 static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary,
                                      ScopedPrinter &Writer) {
else if (MachOUniversalBinary *UBinary =
     dumpMachOUniversalBinary(UBinary, Writer);
   else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
     dumpObject(*Obj, Writer);
   else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(&Binary))
     dumpCOFFImportFile(Import, Writer);
   else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(&Binary))
     dumpWindowsResourceFile(WinRes, Writer);
   else
-    reportError(errorCodeToError(readobj_error::unrecognized_file_format),
-                File);
+    // Not tested, because all possible file types are handled.
+    reportError(
+        createStringError(errc::invalid_argument, "unrecognized file type"),
 
   CVTypes.Binaries.push_back(std::move(*BinaryOrErr));
 }
 
 /// Registers aliases that should only be allowed by readobj.
 static void registerReadobjAliases() {
   // -s has meant --sections for a very long time in llvm-readobj despite
   // meaning --symbols in readelf.