Port the error functions from ELF to COFF.

[• rafael]

Summary

This has a few advantages

• Less C++ code (about 300 lines less).
• Less machine code (about 14 KB of text on a linux x86_64 build).
• More debugger friendly. Just set a breakpoint on the exit function and you get the complete lld stack trace of when the error was found.
• It is a more robust API. The errors are handled early and we don't get a std::error_code hot potato being passed around.
• In most cases the error function in a better position to print diagnostics (it has more context).

[ruiu]

Handling errors with "eist immediately when error" policy seems good to me, but it makes error codes defined in error.h useless since we no longer return errors as return values. Maybe we should remove them.

COFF/Driver.h

30–34

error() does not particularly belong to Driver, so piggy-backing it with Driver doesn't seem a good idea to me. I'd move it to Error.h.

[• rafael]

Move the error functions out of Driver.(h|cpp)

[ruiu]

LGTM

COFF/Error.cpp

28

Add a blank line.

COFF/Error.h

18–20

Add blank lines between definitions/declarations.

[Eugene.Zelenko]

Committed in r244215.

COFF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(COFFOptionsTableGen)
 
 add_llvm_library(lldCOFF
   Chunks.cpp
   DLL.cpp
   Driver.cpp
   DriverUtils.cpp
+  Error.cpp
   ICF.cpp
   InputFiles.cpp
   ModuleDef.cpp
   SymbolTable.cpp
   Symbols.cpp
   Writer.cpp
 
   LINK_COMPONENTS

COFF/Chunks.cpp

 //===- Chunks.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
+#include "Error.h"
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
void SectionChunk::applyRelX64(uint8_t *Off, uint16_t Type, Defined *Sym,
   case IMAGE_REL_AMD64_REL32_1:  add32(Off, S - P - 5); break;
   case IMAGE_REL_AMD64_REL32_2:  add32(Off, S - P - 6); break;
   case IMAGE_REL_AMD64_REL32_3:  add32(Off, S - P - 7); break;
   case IMAGE_REL_AMD64_REL32_4:  add32(Off, S - P - 8); break;
   case IMAGE_REL_AMD64_REL32_5:  add32(Off, S - P - 9); break;
   case IMAGE_REL_AMD64_SECTION:  add16(Off, Sym->getSectionIndex()); break;
   case IMAGE_REL_AMD64_SECREL:   add32(Off, Sym->getSecrel()); break;
   default:
-    llvm::report_fatal_error("Unsupported relocation type");
+    error("Unsupported relocation type");
   }
 }
 
 void SectionChunk::applyRelX86(uint8_t *Off, uint16_t Type, Defined *Sym,
                                uint64_t P) {
   uint64_t S = Sym->getRVA();
   switch (Type) {
   case IMAGE_REL_I386_ABSOLUTE: break;
   case IMAGE_REL_I386_DIR32:    add32(Off, S + Config->ImageBase); break;
   case IMAGE_REL_I386_DIR32NB:  add32(Off, S); break;
   case IMAGE_REL_I386_REL32:    add32(Off, S - P - 4); break;
   case IMAGE_REL_I386_SECTION:  add16(Off, Sym->getSectionIndex()); break;
   case IMAGE_REL_I386_SECREL:   add32(Off, Sym->getSecrel()); break;
   default:
-    llvm::report_fatal_error("Unsupported relocation type");
+    error("Unsupported relocation type");
   }
 }
 
 static void applyMOV(uint8_t *Off, uint16_t V) {
   or16(Off, ((V & 0x800) >> 1) | ((V >> 12) & 0xf));
   or16(Off + 2, ((V & 0x700) << 4) | (V & 0xff));
 }
 
void SectionChunk::applyRelARM(uint8_t *Off, uint16_t Type, Defined *Sym,
   switch (Type) {
   case IMAGE_REL_ARM_ADDR32:    add32(Off, S + Config->ImageBase); break;
   case IMAGE_REL_ARM_ADDR32NB:  add32(Off, S); break;
   case IMAGE_REL_ARM_MOV32T:    applyMOV32T(Off, S + Config->ImageBase); break;
   case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(Off, S - P - 4); break;
   case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(Off, S - P - 4); break;
   case IMAGE_REL_ARM_BLX23T:    applyBranch24T(Off, S - P - 4); break;
   default:
-    llvm::report_fatal_error("Unsupported relocation type");
+    error("Unsupported relocation type");
   }
 }
 
 void SectionChunk::writeTo(uint8_t *Buf) {
   if (!hasData())
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> A = getContents();

COFF/Driver.h

 #include <memory>
 #include <set>
 #include <system_error>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
 class LinkerDriver;
 extern LinkerDriver *Driver;
 
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
 using llvm::Optional;
 class InputFile;
 
 // Entry point of the COFF linker.
-bool link(llvm::ArrayRef<const char *> Args);
+void link(llvm::ArrayRef<const char *> Args);
 
 class ArgParser {
 public:
   ArgParser() : Alloc(AllocAux) {}
   // Parses command line options.
-  ErrorOr<llvm::opt::InputArgList> parse(llvm::ArrayRef<const char *> Args);
+  llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> Args);
 
   // Concatenate LINK environment varirable and given arguments and parse them.
-  ErrorOr<llvm::opt::InputArgList> parseLINK(llvm::ArrayRef<const char *> Args);
+  llvm::opt::InputArgList parseLINK(llvm::ArrayRef<const char *> Args);
 
   // Tokenizes a given string and then parses as command line options.
-  ErrorOr<llvm::opt::InputArgList> parse(StringRef S) {
-    return parse(tokenize(S));
-  }
+  llvm::opt::InputArgList parse(StringRef S) { return parse(tokenize(S)); }
 
 private:
   std::vector<const char *> tokenize(StringRef S);
 
-  ErrorOr<std::vector<const char *>>
-  replaceResponseFiles(std::vector<const char *>);
+  std::vector<const char *> replaceResponseFiles(std::vector<const char *>);
 
   llvm::BumpPtrAllocator AllocAux;
   llvm::BumpPtrStringSaver Alloc;
 };
 
 class LinkerDriver {
 public:
   LinkerDriver() : Alloc(AllocAux) {}
-  bool link(llvm::ArrayRef<const char *> Args);
+  void link(llvm::ArrayRef<const char *> Args);
 
   // Used by the resolver to parse .drectve section contents.
-  std::error_code parseDirectives(StringRef S);
+  void parseDirectives(StringRef S);
 
 private:
   llvm::BumpPtrAllocator AllocAux;
   llvm::BumpPtrStringSaver Alloc;
   ArgParser Parser;
   SymbolTable Symtab;
 
   // Opens a file. Path has to be resolved already.
-  ErrorOr<MemoryBufferRef> openFile(StringRef Path);
+  MemoryBufferRef openFile(StringRef Path);
 
   // Searches a file from search paths.
   Optional<StringRef> findFile(StringRef Filename);
   Optional<StringRef> findLib(StringRef Filename);
   StringRef doFindFile(StringRef Filename);
   StringRef doFindLib(StringRef Filename);
 
   // Parses LIB environment which contains a list of search paths.
private:
   StringRef findDefaultEntry();
   WindowsSubsystem inferSubsystem();
 
   // Driver is the owner of all opened files.
   // InputFiles have MemoryBufferRefs to them.
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
-std::error_code parseModuleDefs(MemoryBufferRef MB,
-                                llvm::BumpPtrStringSaver *Alloc);
-std::error_code writeImportLibrary();
+void parseModuleDefs(MemoryBufferRef MB, llvm::BumpPtrStringSaver *Alloc);
+void writeImportLibrary();
 
 // Functions below this line are defined in DriverUtils.cpp.
 
 void printHelp(const char *Argv0);
 
 // For /machine option.
-ErrorOr<MachineTypes> getMachineType(StringRef Arg);
+MachineTypes getMachineType(StringRef Arg);
 StringRef machineToStr(MachineTypes MT);
 
 // Parses a string in the form of "<integer>[,<integer>]".
-std::error_code parseNumbers(StringRef Arg, uint64_t *Addr,
-                             uint64_t *Size = nullptr);
+void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size = nullptr);
 
 // Parses a string in the form of "<integer>[.<integer>]".
 // Minor's default value is 0.
-std::error_code parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor);
+void parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor);
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
-std::error_code parseSubsystem(StringRef Arg, WindowsSubsystem *Sys,
-                               uint32_t *Major, uint32_t *Minor);
+void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major,
+                    uint32_t *Minor);
 
-std::error_code parseAlternateName(StringRef);
-std::error_code parseMerge(StringRef);
+void parseAlternateName(StringRef);
+void parseMerge(StringRef);
 
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
-std::error_code parseManifest(StringRef Arg);
+void parseManifest(StringRef Arg);
 
 // Parses a string in the form of "level=<string>|uiAccess=<string>"
-std::error_code parseManifestUAC(StringRef Arg);
+void parseManifestUAC(StringRef Arg);
 
 // Create a resource file containing a manifest XML.
-ErrorOr<std::unique_ptr<MemoryBuffer>> createManifestRes();
-std::error_code createSideBySideManifest();
+std::unique_ptr<MemoryBuffer> createManifestRes();
+void createSideBySideManifest();
 
 // Used for dllexported symbols.
-ErrorOr<Export> parseExport(StringRef Arg);
-std::error_code fixupExports();
+Export parseExport(StringRef Arg);
+void fixupExports();
 void assignExportOrdinals();
 
 // Parses a string in the form of "key=value" and check
 // if value matches previous values for the key.
 // This feature used in the directive section to reject
 // incompatible objects.
-std::error_code checkFailIfMismatch(StringRef Arg);
+void checkFailIfMismatch(StringRef Arg);
 
 // Convert Windows resource files (.res files) to a .obj file
 // using cvtres.exe.
-ErrorOr<std::unique_ptr<MemoryBuffer>>
+std::unique_ptr<MemoryBuffer>
 convertResToCOFF(const std::vector<MemoryBufferRef> &MBs);
 
 void touchFile(StringRef Path);
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/Driver.cpp

 using llvm::sys::fs::identify_magic;
 
 namespace lld {
 namespace coff {
 
 Configuration *Config;
 LinkerDriver *Driver;
 
-bool link(llvm::ArrayRef<const char *> Args) {
+void link(llvm::ArrayRef<const char *> Args) {
   auto C = make_unique<Configuration>();
   Config = C.get();
   auto D = make_unique<LinkerDriver>();
   Driver = D.get();
   return Driver->link(Args);
 }
 
 // Drop directory components and replace extension with ".exe".
 static std::string getOutputPath(StringRef Path) {
   auto P = Path.find_last_of("\\/");
   StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1);
   return (S.substr(0, S.rfind('.')) + ".exe").str();
 }
 
 // Opens a file. Path has to be resolved already.
 // Newly created memory buffers are owned by this driver.
-ErrorOr<MemoryBufferRef> LinkerDriver::openFile(StringRef Path) {
+MemoryBufferRef LinkerDriver::openFile(StringRef Path) {
   auto MBOrErr = MemoryBuffer::getFile(Path);
-  if (auto EC = MBOrErr.getError())
-    return EC;
-  std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
+  error(MBOrErr, Twine("Could not open ") + Path);
+  std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take ownership
   return MBRef;
 }
 
 static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
   // File type is detected by contents, not by file extension.
   file_magic Magic = identify_magic(MB.getBuffer());
   if (Magic == file_magic::archive)
     return std::unique_ptr<InputFile>(new ArchiveFile(MB));
   if (Magic == file_magic::bitcode)
     return std::unique_ptr<InputFile>(new BitcodeFile(MB));
   if (Config->OutputFile == "")
     Config->OutputFile = getOutputPath(MB.getBufferIdentifier());
   return std::unique_ptr<InputFile>(new ObjectFile(MB));
 }
 
 // Parses .drectve section contents and returns a list of files
 // specified by /defaultlib.
-std::error_code
-LinkerDriver::parseDirectives(StringRef S) {
-  auto ArgsOrErr = Parser.parse(S);
-  if (auto EC = ArgsOrErr.getError())
-    return EC;
-  llvm::opt::InputArgList Args = std::move(ArgsOrErr.get());
+void LinkerDriver::parseDirectives(StringRef S) {
+  llvm::opt::InputArgList Args = Parser.parse(S);
 
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_alternatename:
-      if (auto EC = parseAlternateName(Arg->getValue()))
-        return EC;
+      parseAlternateName(Arg->getValue());
       break;
     case OPT_defaultlib:
       if (Optional<StringRef> Path = findLib(Arg->getValue())) {
-        ErrorOr<MemoryBufferRef> MBOrErr = openFile(*Path);
-        if (auto EC = MBOrErr.getError())
-          return EC;
-        Symtab.addFile(createFile(MBOrErr.get()));
+        MemoryBufferRef MB = openFile(*Path);
+        Symtab.addFile(createFile(MB));
       }
       break;
     case OPT_export: {
-      ErrorOr<Export> E = parseExport(Arg->getValue());
-      if (auto EC = E.getError())
-        return EC;
-      if (Config->Machine == I386 && E->ExtName.startswith("_"))
-        E->ExtName = E->ExtName.substr(1);
-      Config->Exports.push_back(E.get());
+      Export E = parseExport(Arg->getValue());
+      if (Config->Machine == I386 && E.ExtName.startswith("_"))
+        E.ExtName = E.ExtName.substr(1);
+      Config->Exports.push_back(E);
       break;
     }
     case OPT_failifmismatch:
-      if (auto EC = checkFailIfMismatch(Arg->getValue()))
-        return EC;
+      checkFailIfMismatch(Arg->getValue());
       break;
     case OPT_incl:
       addUndefined(Arg->getValue());
       break;
     case OPT_merge:
-      if (auto EC = parseMerge(Arg->getValue()))
-        return EC;
+      parseMerge(Arg->getValue());
       break;
     case OPT_nodefaultlib:
       Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
       break;
     case OPT_throwingnew:
       break;
     default:
-      llvm::errs() << Arg->getSpelling() << " is not allowed in .drectve\n";
-      return make_error_code(LLDError::InvalidOption);
+      error(Twine(Arg->getSpelling()) + " is not allowed in .drectve");
     }
   }
-  return std::error_code();
 }
 
 // Find file from search paths. You can omit ".obj", this function takes
 // care of that. Note that the returned path is not guaranteed to exist.
 StringRef LinkerDriver::doFindFile(StringRef Filename) {
   bool hasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
   if (hasPathSep)
     return Filename;

 }
 
 static uint64_t getDefaultImageBase() {
   if (Config->is64())
     return Config->DLL ? 0x180000000 : 0x140000000;
   return Config->DLL ? 0x10000000 : 0x400000;
 }
 
-bool LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
+void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   // Needed for LTO.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllDisassemblers();
 
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
   // We call our own implementation of lib.exe that understands bitcode files.
   if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib"))
-    return llvm::libDriverMain(ArgsArr.slice(1)) == 0;
+    if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
+      error("lib failed");
 
   // Parse command line options.
-  auto ArgsOrErr = Parser.parseLINK(ArgsArr.slice(1));
-  if (auto EC = ArgsOrErr.getError()) {
-    llvm::errs() << EC.message() << "\n";
-    return false;
-  }
-  llvm::opt::InputArgList Args = std::move(ArgsOrErr.get());
+  llvm::opt::InputArgList Args = Parser.parseLINK(ArgsArr.slice(1));
 
   // Handle /help
   if (Args.hasArg(OPT_help)) {
     printHelp(ArgsArr[0]);
-    return true;
+    return;
   }
 
-  if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end()) {
-    llvm::errs() << "no input files.\n";
-    return false;
-  }
+  if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end())
+    error("no input files.");
 
   // Construct search path list.
   SearchPaths.push_back("");
   for (auto *Arg : Args.filtered(OPT_libpath))
     SearchPaths.push_back(Arg->getValue());
   addLibSearchPaths();
 
   // Handle /out
if (Args.hasArg(OPT_force) || Args.hasArg(OPT_force_unresolved))
     Config->Force = true;
 
   // Handle /debug
   if (Args.hasArg(OPT_debug))
     Config->Debug = true;
 
   // Handle /noentry
   if (Args.hasArg(OPT_noentry)) {
-    if (!Args.hasArg(OPT_dll)) {
-      llvm::errs() << "/noentry must be specified with /dll\n";
-      return false;
-    }
+    if (!Args.hasArg(OPT_dll))
+      error("/noentry must be specified with /dll");
     Config->NoEntry = true;
   }
 
   // Handle /dll
   if (Args.hasArg(OPT_dll)) {
     Config->DLL = true;
     Config->ManifestID = 2;
   }
 
   // Handle /fixed
   if (Args.hasArg(OPT_fixed)) {
-    if (Args.hasArg(OPT_dynamicbase)) {
-      llvm::errs() << "/fixed must not be specified with /dynamicbase\n";
-      return false;
-    }
+    if (Args.hasArg(OPT_dynamicbase))
+      error("/fixed must not be specified with /dynamicbase");
     Config->Relocatable = false;
     Config->DynamicBase = false;
   }
 
   // Handle /machine
-  if (auto *Arg = Args.getLastArg(OPT_machine)) {
-    ErrorOr<MachineTypes> MTOrErr = getMachineType(Arg->getValue());
-    if (MTOrErr.getError())
-      return false;
-    Config->Machine = MTOrErr.get();
-  }
+  if (auto *Arg = Args.getLastArg(OPT_machine))
+    Config->Machine = getMachineType(Arg->getValue());
 
   // Handle /nodefaultlib:<filename>
   for (auto *Arg : Args.filtered(OPT_nodefaultlib))
     Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
 
   // Handle /nodefaultlib
   if (Args.hasArg(OPT_nodefaultlib_all))
     Config->NoDefaultLibAll = true;
 
   // Handle /base
-  if (auto *Arg = Args.getLastArg(OPT_base)) {
-    if (auto EC = parseNumbers(Arg->getValue(), &Config->ImageBase)) {
-      llvm::errs() << "/base: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_base))
+    parseNumbers(Arg->getValue(), &Config->ImageBase);
 
   // Handle /stack
-  if (auto *Arg = Args.getLastArg(OPT_stack)) {
-    if (auto EC = parseNumbers(Arg->getValue(), &Config->StackReserve,
-                               &Config->StackCommit)) {
-      llvm::errs() << "/stack: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_stack))
+    parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit);
 
   // Handle /heap
-  if (auto *Arg = Args.getLastArg(OPT_heap)) {
-    if (auto EC = parseNumbers(Arg->getValue(), &Config->HeapReserve,
-                               &Config->HeapCommit)) {
-      llvm::errs() << "/heap: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_heap))
+    parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit);
 
   // Handle /version
-  if (auto *Arg = Args.getLastArg(OPT_version)) {
-    if (auto EC = parseVersion(Arg->getValue(), &Config->MajorImageVersion,
-                               &Config->MinorImageVersion)) {
-      llvm::errs() << "/version: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_version))
+    parseVersion(Arg->getValue(), &Config->MajorImageVersion,
+                 &Config->MinorImageVersion);
 
   // Handle /subsystem
-  if (auto *Arg = Args.getLastArg(OPT_subsystem)) {
-    if (auto EC = parseSubsystem(Arg->getValue(), &Config->Subsystem,
-                                 &Config->MajorOSVersion,
-                                 &Config->MinorOSVersion)) {
-      llvm::errs() << "/subsystem: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_subsystem))
+    parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion,
+                   &Config->MinorOSVersion);
 
   // Handle /alternatename
   for (auto *Arg : Args.filtered(OPT_alternatename))
-    if (parseAlternateName(Arg->getValue()))
-      return false;
+    parseAlternateName(Arg->getValue());
 
   // Handle /include
   for (auto *Arg : Args.filtered(OPT_incl))
     addUndefined(Arg->getValue());
 
   // Handle /implib
   if (auto *Arg = Args.getLastArg(OPT_implib))
     Config->Implib = Arg->getValue();
 
   // Handle /opt
   for (auto *Arg : Args.filtered(OPT_opt)) {
     std::string S = StringRef(Arg->getValue()).lower();
     if (S == "noref") {
       Config->DoGC = false;
       continue;
     }
     if (S == "lldicf") {
       Config->ICF = true;
       continue;
     }
     if (S != "ref" && S != "icf" && S != "noicf" &&
         S != "lbr" && S != "nolbr" &&
         !StringRef(S).startswith("icf=")) {
-      llvm::errs() << "/opt: unknown option: " << S << "\n";
-      return false;
+      error(Twine("/opt: unknown option: ") + S);
     }
   }
 
   // Handle /failifmismatch
   for (auto *Arg : Args.filtered(OPT_failifmismatch))
-    if (checkFailIfMismatch(Arg->getValue()))
-      return false;
+    checkFailIfMismatch(Arg->getValue());
 
   // Handle /merge
   for (auto *Arg : Args.filtered(OPT_merge))
-    if (parseMerge(Arg->getValue()))
-      return false;
+    parseMerge(Arg->getValue());
 
   // Handle /manifest
-  if (auto *Arg = Args.getLastArg(OPT_manifest_colon)) {
-    if (auto EC = parseManifest(Arg->getValue())) {
-      llvm::errs() << "/manifest: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_manifest_colon))
+    parseManifest(Arg->getValue());
 
   // Handle /manifestuac
-  if (auto *Arg = Args.getLastArg(OPT_manifestuac)) {
-    if (auto EC = parseManifestUAC(Arg->getValue())) {
-      llvm::errs() << "/manifestuac: " << EC.message() << "\n";
-      return false;
-    }
-  }
+  if (auto *Arg = Args.getLastArg(OPT_manifestuac))
+    parseManifestUAC(Arg->getValue());
 
   // Handle /manifestdependency
   if (auto *Arg = Args.getLastArg(OPT_manifestdependency))
     Config->ManifestDependency = Arg->getValue();
 
   // Handle /manifestfile
   if (auto *Arg = Args.getLastArg(OPT_manifestfile))
     Config->ManifestFile = Arg->getValue();
void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   std::vector<StringRef> Paths;
   std::vector<MemoryBufferRef> MBs;
   for (auto *Arg : Args.filtered(OPT_INPUT))
     if (Optional<StringRef> Path = findFile(Arg->getValue()))
       Paths.push_back(*Path);
   for (auto *Arg : Args.filtered(OPT_defaultlib))
     if (Optional<StringRef> Path = findLib(Arg->getValue()))
       Paths.push_back(*Path);
-  for (StringRef Path : Paths) {
-    ErrorOr<MemoryBufferRef> MBOrErr = openFile(Path);
-    if (auto EC = MBOrErr.getError()) {
-      llvm::errs() << "cannot open " << Path << ": " << EC.message() << "\n";
-      return false;
-    }
-    MBs.push_back(MBOrErr.get());
-  }
+  for (StringRef Path : Paths)
+    MBs.push_back(openFile(Path));
 
   // Windows specific -- Create a resource file containing a manifest file.
   if (Config->Manifest == Configuration::Embed) {
-    auto MBOrErr = createManifestRes();
-    if (MBOrErr.getError())
-      return false;
-    std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
+    std::unique_ptr<MemoryBuffer> MB = createManifestRes();
     MBs.push_back(MB->getMemBufferRef());
     OwningMBs.push_back(std::move(MB)); // take ownership
   }
 
   // Windows specific -- Input files can be Windows resource files (.res files).
   // We invoke cvtres.exe to convert resource files to a regular COFF file
   // then link the result file normally.
   std::vector<MemoryBufferRef> Resources;
   auto NotResource = [](MemoryBufferRef MB) {
     return identify_magic(MB.getBuffer()) != file_magic::windows_resource;
   };
   auto It = std::stable_partition(MBs.begin(), MBs.end(), NotResource);
   if (It != MBs.end()) {
     Resources.insert(Resources.end(), It, MBs.end());
     MBs.erase(It, MBs.end());
   }
 
   // Read all input files given via the command line. Note that step()
   // doesn't read files that are specified by directive sections.
   for (MemoryBufferRef MB : MBs)
     Symtab.addFile(createFile(MB));
-  if (auto EC = Symtab.step()) {
-    llvm::errs() << EC.message() << "\n";
-    return false;
-  }
+  Symtab.step();
 
   // Determine machine type and check if all object files are
   // for the same CPU type. Note that this needs to be done before
   // any call to mangle().
   for (std::unique_ptr<InputFile> &File : Symtab.getFiles()) {
     MachineTypes MT = File->getMachineType();
     if (MT == IMAGE_FILE_MACHINE_UNKNOWN)
       continue;
     if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
       Config->Machine = MT;
       continue;
     }
-    if (Config->Machine != MT) {
-      llvm::errs() << File->getShortName() << ": machine type "
-                   << machineToStr(MT) << " conflicts with "
-                   << machineToStr(Config->Machine) << "\n";
-      return false;
-    }
+    if (Config->Machine != MT)
+      error(Twine(File->getShortName()) + ": machine type " + machineToStr(MT) +
+            " conflicts with " + machineToStr(Config->Machine));
   }
   if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     llvm::errs() << "warning: /machine is not specified. x64 is assumed.\n";
     Config->Machine = AMD64;
   }
 
   // Windows specific -- Convert Windows resource files to a COFF file.
   if (!Resources.empty()) {
-    auto MBOrErr = convertResToCOFF(Resources);
-    if (MBOrErr.getError())
-      return false;
-    std::unique_ptr<MemoryBuffer> MB = std::move(MBOrErr.get());
+    std::unique_ptr<MemoryBuffer> MB = convertResToCOFF(Resources);
     Symtab.addFile(createFile(MB->getMemBufferRef()));
     OwningMBs.push_back(std::move(MB)); // take ownership
   }
 
   // Handle /largeaddressaware
   if (Config->is64() || Args.hasArg(OPT_largeaddressaware))
     Config->LargeAddressAware = true;
 
   // Handle /highentropyva
   if (Config->is64() && !Args.hasArg(OPT_highentropyva_no))
     Config->HighEntropyVA = true;
 
   // Handle /entry and /dll
   if (auto *Arg = Args.getLastArg(OPT_entry)) {
     Config->Entry = addUndefined(mangle(Arg->getValue()));
   } else if (Args.hasArg(OPT_dll) && !Config->NoEntry) {
     StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12"
                                             : "_DllMainCRTStartup";
     Config->Entry = addUndefined(S);
   } else if (!Config->NoEntry) {
     // Windows specific -- If entry point name is not given, we need to
     // infer that from user-defined entry name.
     StringRef S = findDefaultEntry();
-    if (S.empty()) {
-      llvm::errs() << "entry point must be defined\n";
-      return false;
-    }
+    if (S.empty())
+      error("entry point must be defined");
     Config->Entry = addUndefined(S);
     if (Config->Verbose)
       llvm::outs() << "Entry name inferred: " << S << "\n";
   }
 
   // Handle /export
   for (auto *Arg : Args.filtered(OPT_export)) {
-    ErrorOr<Export> E = parseExport(Arg->getValue());
-    if (E.getError())
-      return false;
-    if (Config->Machine == I386 && !E->Name.startswith("_@?"))
-      E->Name = mangle(E->Name);
-    Config->Exports.push_back(E.get());
+    Export E = parseExport(Arg->getValue());
+    if (Config->Machine == I386 && !E.Name.startswith("_@?"))
+      E.Name = mangle(E.Name);
+    Config->Exports.push_back(E);
   }
 
   // Handle /def
   if (auto *Arg = Args.getLastArg(OPT_deffile)) {
-    ErrorOr<MemoryBufferRef> MBOrErr = openFile(Arg->getValue());
-    if (auto EC = MBOrErr.getError()) {
-      llvm::errs() << "/def: " << EC.message() << "\n";
-      return false;
-    }
+    MemoryBufferRef MB = openFile(Arg->getValue());
     // parseModuleDefs mutates Config object.
-    if (parseModuleDefs(MBOrErr.get(), &Alloc))
-      return false;
+    parseModuleDefs(MB, &Alloc);
   }
 
   // Handle /delayload
   for (auto *Arg : Args.filtered(OPT_delayload)) {
     Config->DelayLoads.insert(StringRef(Arg->getValue()).lower());
     if (Config->Machine == I386) {
       Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8");
     } else {
       Config->DelayLoadHelper = addUndefined("__delayLoadHelper2");
     }
   }
 
   // Set default image base if /base is not given.
   if (Config->ImageBase == uint64_t(-1))
     Config->ImageBase = getDefaultImageBase();
 
   Symtab.addRelative(mangle("__ImageBase"), 0);
   if (Config->Machine == I386) {
     Config->SEHTable = Symtab.addRelative("___safe_se_handler_table", 0);
     Config->SEHCount = Symtab.addAbsolute("___safe_se_handler_count", 0);
   }
   Config->LoadConfigUsed = mangle("_load_config_used");
 
   // Read as much files as we can from directives sections.
-  if (auto EC = Symtab.run()) {
-    llvm::errs() << EC.message() << "\n";
-    return false;
-  }
+  Symtab.run();
 
   // Resolve auxiliary symbols until we get a convergence.
   // (Trying to resolve a symbol may trigger a Lazy symbol to load a new file.
   // A new file may contain a directive section to add new command line options.
   // That's why we have to repeat until converge.)
   for (;;) {
     // Windows specific -- if entry point is not found,
     // search for its mangled names.
for (;;) {
     }
 
     // Windows specific -- if __load_config_used can be resolved, resolve it.
     if (Symtab.find(Config->LoadConfigUsed))
       addUndefined(Config->LoadConfigUsed);
 
     if (Symtab.queueEmpty())
       break;
-    if (auto EC = Symtab.run()) {
-      llvm::errs() << EC.message() << "\n";
-      return false;
-    }
+    Symtab.run();
   }
 
   // Do LTO by compiling bitcode input files to a native COFF file
   // then link that file.
-  if (auto EC = Symtab.addCombinedLTOObject()) {
-    llvm::errs() << EC.message() << "\n";
-    return false;
-  }
+  Symtab.addCombinedLTOObject();
 
   // Make sure we have resolved all symbols.
-  if (Symtab.reportRemainingUndefines(/*Resolve=*/true))
-    return false;
+  Symtab.reportRemainingUndefines(/*Resolve=*/true);
 
   // Windows specific -- if no /subsystem is given, we need to infer
   // that from entry point name.
   if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
     Config->Subsystem = inferSubsystem();
-    if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
-      llvm::errs() << "subsystem must be defined\n";
-      return false;
-    }
+    if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
+      error("subsystem must be defined");
   }
 
   // Handle /safeseh.
   if (Args.hasArg(OPT_safeseh)) {
     for (ObjectFile *File : Symtab.ObjectFiles) {
       if (File->SEHCompat)
         continue;
-      llvm::errs() << "/safeseh: " << File->getName()
-                   << " is not compatible with SEH\n";
-      return false;
+      error(Twine("/safeseh: ") + File->getName() +
+            " is not compatible with SEH");
     }
   }
 
   // Windows specific -- when we are creating a .dll file, we also
   // need to create a .lib file.
   if (!Config->Exports.empty()) {
-    if (fixupExports())
-      return false;
-    if (writeImportLibrary())
-      return false;
+    fixupExports();
+    writeImportLibrary();
     assignExportOrdinals();
   }
 
   // Windows specific -- Create a side-by-side manifest file.
   if (Config->Manifest == Configuration::SideBySide)
-    if (createSideBySideManifest())
-      return false;
+    createSideBySideManifest();
 
   // Create a dummy PDB file to satisfy build sytem rules.
   if (auto *Arg = Args.getLastArg(OPT_pdb))
     touchFile(Arg->getValue());
 
   // Write the result.
-  if (auto EC = writeResult(&Symtab)) {
-    llvm::errs() << EC.message() << "\n";
-    return false;
-  }
+  writeResult(&Symtab);
 
   // Create a symbol map file containing symbol VAs and their names
   // to help debugging.
   if (auto *Arg = Args.getLastArg(OPT_lldmap)) {
     std::error_code EC;
     llvm::raw_fd_ostream Out(Arg->getValue(), EC, OpenFlags::F_Text);
-    if (EC) {
-      llvm::errs() << EC.message() << "\n";
-      return false;
-    }
+    error(EC, "Could not create the symbol map");
     Symtab.printMap(Out);
   }
   // Call exit to avoid calling destructors.
   exit(0);
 }
 
 } // namespace coff
 } // namespace lld

COFF/DriverUtils.cpp

 class Executor {
 public:
   explicit Executor(StringRef S) : Saver(Alloc), Prog(Saver.save(S)) {}
   void add(StringRef S)    { Args.push_back(Saver.save(S)); }
   void add(std::string &S) { Args.push_back(Saver.save(S)); }
   void add(Twine S)        { Args.push_back(Saver.save(S)); }
   void add(const char *S)  { Args.push_back(Saver.save(S)); }
 
-  std::error_code run() {
+  void run() {
     ErrorOr<std::string> ExeOrErr = llvm::sys::findProgramByName(Prog);
-    if (auto EC = ExeOrErr.getError()) {
-      llvm::errs() << "unable to find " << Prog << " in PATH: "
-                   << EC.message() << "\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
+    error(ExeOrErr, Twine("unable to find ") + Prog + " in PATH: ");
     const char *Exe = Saver.save(ExeOrErr.get());
     Args.insert(Args.begin(), Exe);
     Args.push_back(nullptr);
     if (llvm::sys::ExecuteAndWait(Args[0], Args.data()) != 0) {
       for (const char *S : Args)
         if (S)
           llvm::errs() << S << " ";
-      llvm::errs() << "failed\n";
-      return make_error_code(LLDError::InvalidOption);
+      error("failed");
     }
-    return std::error_code();
   }
 
 private:
   llvm::BumpPtrAllocator Alloc;
   llvm::BumpPtrStringSaver Saver;
   StringRef Prog;
   std::vector<const char *> Args;
 };
 
 } // anonymous namespace
 
 // Returns /machine's value.
-ErrorOr<MachineTypes> getMachineType(StringRef S) {
+MachineTypes getMachineType(StringRef S) {
   MachineTypes MT = StringSwitch<MachineTypes>(S.lower())
                         .Case("x64", AMD64)
                         .Case("amd64", AMD64)
                         .Case("x86", I386)
                         .Case("i386", I386)
                         .Case("arm", ARMNT)
                         .Default(IMAGE_FILE_MACHINE_UNKNOWN);
   if (MT != IMAGE_FILE_MACHINE_UNKNOWN)
     return MT;
-  llvm::errs() << "unknown /machine argument: " << S << "\n";
-  return make_error_code(LLDError::InvalidOption);
+  error(Twine("unknown /machine argument: ") + S);
 }
 
 StringRef machineToStr(MachineTypes MT) {
   switch (MT) {
   case ARMNT:
     return "arm";
   case AMD64:
     return "x64";
   case I386:
     return "x86";
   default:
     llvm_unreachable("unknown machine type");
   }
 }
 
 // Parses a string in the form of "<integer>[,<integer>]".
-std::error_code parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size) {
+void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size) {
   StringRef S1, S2;
   std::tie(S1, S2) = Arg.split(',');
-  if (S1.getAsInteger(0, *Addr)) {
-    llvm::errs() << "invalid number: " << S1 << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
-  if (Size && !S2.empty() && S2.getAsInteger(0, *Size)) {
-    llvm::errs() << "invalid number: " << S2 << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
-  return std::error_code();
+  if (S1.getAsInteger(0, *Addr))
+    error(Twine("invalid number: ") + S1);
+  if (Size && !S2.empty() && S2.getAsInteger(0, *Size))
+    error(Twine("invalid number: ") + S2);
 }
 
 // Parses a string in the form of "<integer>[.<integer>]".
 // If second number is not present, Minor is set to 0.
-std::error_code parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor) {
+void parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor) {
   StringRef S1, S2;
   std::tie(S1, S2) = Arg.split('.');
-  if (S1.getAsInteger(0, *Major)) {
-    llvm::errs() << "invalid number: " << S1 << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (S1.getAsInteger(0, *Major))
+    error(Twine("invalid number: ") + S1);
   *Minor = 0;
-  if (!S2.empty() && S2.getAsInteger(0, *Minor)) {
-    llvm::errs() << "invalid number: " << S2 << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
-  return std::error_code();
+  if (!S2.empty() && S2.getAsInteger(0, *Minor))
+    error(Twine("invalid number: ") + S2);
 }
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
-std::error_code parseSubsystem(StringRef Arg, WindowsSubsystem *Sys,
-                               uint32_t *Major, uint32_t *Minor) {
+void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major,
+                    uint32_t *Minor) {
   StringRef SysStr, Ver;
   std::tie(SysStr, Ver) = Arg.split(',');
   *Sys = StringSwitch<WindowsSubsystem>(SysStr.lower())
     .Case("boot_application", IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION)
     .Case("console", IMAGE_SUBSYSTEM_WINDOWS_CUI)
     .Case("efi_application", IMAGE_SUBSYSTEM_EFI_APPLICATION)
     .Case("efi_boot_service_driver", IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER)
     .Case("efi_rom", IMAGE_SUBSYSTEM_EFI_ROM)
     .Case("efi_runtime_driver", IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER)
     .Case("native", IMAGE_SUBSYSTEM_NATIVE)
     .Case("posix", IMAGE_SUBSYSTEM_POSIX_CUI)
     .Case("windows", IMAGE_SUBSYSTEM_WINDOWS_GUI)
     .Default(IMAGE_SUBSYSTEM_UNKNOWN);
-  if (*Sys == IMAGE_SUBSYSTEM_UNKNOWN) {
-    llvm::errs() << "unknown subsystem: " << SysStr << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (*Sys == IMAGE_SUBSYSTEM_UNKNOWN)
+    error(Twine("unknown subsystem: ") + SysStr);
   if (!Ver.empty())
-    if (auto EC = parseVersion(Ver, Major, Minor))
-      return EC;
-  return std::error_code();
+    parseVersion(Ver, Major, Minor);
 }
 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
-std::error_code parseAlternateName(StringRef S) {
+void parseAlternateName(StringRef S) {
   StringRef From, To;
   std::tie(From, To) = S.split('=');
-  if (From.empty() || To.empty()) {
-    llvm::errs() << "/alternatename: invalid argument: " << S << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (From.empty() || To.empty())
+    error(Twine("/alternatename: invalid argument: ") + S);
   auto It = Config->AlternateNames.find(From);
-  if (It != Config->AlternateNames.end() && It->second != To) {
-    llvm::errs() << "/alternatename: conflicts: " << S << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (It != Config->AlternateNames.end() && It->second != To)
+    error(Twine("/alternatename: conflicts: ") + S);
   Config->AlternateNames.insert(It, std::make_pair(From, To));
-  return std::error_code();
 }
 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
-std::error_code parseMerge(StringRef S) {
+void parseMerge(StringRef S) {
   StringRef From, To;
   std::tie(From, To) = S.split('=');
-  if (From.empty() || To.empty()) {
-    llvm::errs() << "/merge: invalid argument: " << S << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (From.empty() || To.empty())
+    error(Twine("/merge: invalid argument: ") + S);
   auto Pair = Config->Merge.insert(std::make_pair(From, To));
   bool Inserted = Pair.second;
   if (!Inserted) {
     StringRef Existing = Pair.first->second;
     if (Existing != To)
       llvm::errs() << "warning: " << S << ": already merged into "
                    << Existing << "\n";
   }
-  return std::error_code();
 }
 
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
 // Results are directly written to Config.
-std::error_code parseManifest(StringRef Arg) {
+void parseManifest(StringRef Arg) {
   if (Arg.equals_lower("no")) {
     Config->Manifest = Configuration::No;
-    return std::error_code();
+    return;
   }
   if (!Arg.startswith_lower("embed"))
-    return make_error_code(LLDError::InvalidOption);
+    error(Twine("Invalid option ") + Arg);
   Config->Manifest = Configuration::Embed;
   Arg = Arg.substr(strlen("embed"));
   if (Arg.empty())
-    return std::error_code();
+    return;
   if (!Arg.startswith_lower(",id="))
-    return make_error_code(LLDError::InvalidOption);
+    error(Twine("Invalid option ") + Arg);
   Arg = Arg.substr(strlen(",id="));
   if (Arg.getAsInteger(0, Config->ManifestID))
-    return make_error_code(LLDError::InvalidOption);
-  return std::error_code();
+    error(Twine("Invalid option ") + Arg);
 }
 
 // Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
 // Results are directly written to Config.
-std::error_code parseManifestUAC(StringRef Arg) {
+void parseManifestUAC(StringRef Arg) {
   if (Arg.equals_lower("no")) {
     Config->ManifestUAC = false;
-    return std::error_code();
+    return;
   }
   for (;;) {
     Arg = Arg.ltrim();
     if (Arg.empty())
-      return std::error_code();
+      return;
     if (Arg.startswith_lower("level=")) {
       Arg = Arg.substr(strlen("level="));
       std::tie(Config->ManifestLevel, Arg) = Arg.split(" ");
       continue;
     }
     if (Arg.startswith_lower("uiaccess=")) {
       Arg = Arg.substr(strlen("uiaccess="));
       std::tie(Config->ManifestUIAccess, Arg) = Arg.split(" ");
       continue;
     }
-    return make_error_code(LLDError::InvalidOption);
+    error(Twine("Invalid option ") + Arg);
   }
 }
 
 // Quote each line with "". Existing double-quote is converted
 // to two double-quotes.
 static void quoteAndPrint(raw_ostream &Out, StringRef S) {
   while (!S.empty()) {
     StringRef Line;
if (Config->ManifestUAC) {
     }
   }
   OS << "</assembly>\n";
   OS.flush();
   return S;
 }
 
 // Create a resource file containing a manifest XML.
-ErrorOr<std::unique_ptr<MemoryBuffer>> createManifestRes() {
+std::unique_ptr<MemoryBuffer> createManifestRes() {
   // Create a temporary file for the resource script file.
   SmallString<128> RCPath;
-  if (sys::fs::createTemporaryFile("tmp", "rc", RCPath)) {
-    llvm::errs() << "cannot create a temporary file\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  std::error_code EC = sys::fs::createTemporaryFile("tmp", "rc", RCPath);
+  error(EC, "cannot create a temporary file");
   FileRemover RCRemover(RCPath);
 
   // Open the temporary file for writing.
-  std::error_code EC;
   llvm::raw_fd_ostream Out(RCPath, EC, sys::fs::F_Text);
-  if (EC) {
-    llvm::errs() << "failed to open " << RCPath << ": " << EC.message() << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  error(EC, Twine("failed to open ") + RCPath);
 
   // Write resource script to the RC file.
   Out << "#define LANG_ENGLISH 9\n"
       << "#define SUBLANG_DEFAULT 1\n"
       << "#define APP_MANIFEST " << Config->ManifestID << "\n"
       << "#define RT_MANIFEST 24\n"
       << "LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT\n"
       << "APP_MANIFEST RT_MANIFEST {\n";
   quoteAndPrint(Out, createManifestXml());
   Out << "}\n";
   Out.close();
 
   // Create output resource file.
   SmallString<128> ResPath;
-  if (sys::fs::createTemporaryFile("tmp", "res", ResPath)) {
-    llvm::errs() << "cannot create a temporary file\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  EC = sys::fs::createTemporaryFile("tmp", "res", ResPath);
+  error(EC, "cannot create a temporary file");
 
   Executor E("rc.exe");
   E.add("/fo");
   E.add(ResPath.str());
   E.add("/nologo");
   E.add(RCPath.str());
-  if (auto EC = E.run())
-    return EC;
-  return MemoryBuffer::getFile(ResPath);
+  E.run();
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Ret = MemoryBuffer::getFile(ResPath);
+  error(Ret, Twine("Could not open ") + ResPath);
+  return std::move(*Ret);
 }
 
-std::error_code createSideBySideManifest() {
+void createSideBySideManifest() {
   std::string Path = Config->ManifestFile;
   if (Path == "")
     Path = (Twine(Config->OutputFile) + ".manifest").str();
   std::error_code EC;
   llvm::raw_fd_ostream Out(Path, EC, llvm::sys::fs::F_Text);
-  if (EC) {
-    llvm::errs() << EC.message() << "\n";
-    return EC;
-  }
+  error(EC, "failed to create manifest");
   Out << createManifestXml();
-  return std::error_code();
 }
 
 // Parse a string in the form of
 // "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]".
 // Used for parsing /export arguments.
-ErrorOr<Export> parseExport(StringRef Arg) {
+Export parseExport(StringRef Arg) {
   Export E;
   StringRef Rest;
   std::tie(E.Name, Rest) = Arg.split(",");
   if (E.Name.empty())
     goto err;
   if (E.Name.find('=') != StringRef::npos) {
     std::tie(E.ExtName, E.Name) = E.Name.split("=");
     if (E.Name.empty())
if (Tok.startswith("@")) {
       E.Ordinal = Ord;
       continue;
     }
     goto err;
   }
   return E;
 
 err:
-  llvm::errs() << "invalid /export: " << Arg << "\n";
-  return make_error_code(LLDError::InvalidOption);
+  error(Twine("invalid /export: ") + Arg);
 }
 
 // Performs error checking on all /export arguments.
 // It also sets ordinals.
-std::error_code fixupExports() {
+void fixupExports() {
   // Symbol ordinals must be unique.
   std::set<uint16_t> Ords;
   for (Export &E : Config->Exports) {
     if (E.Ordinal == 0)
       continue;
-    if (!Ords.insert(E.Ordinal).second) {
-      llvm::errs() << "duplicate export ordinal: " << E.Name << "\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
+    if (!Ords.insert(E.Ordinal).second)
+      error(Twine("duplicate export ordinal: ") + E.Name);
   }
 
   for (Export &E : Config->Exports) {
     if (!E.ExtName.empty()) {
       E.ExtDLLName = E.ExtName;
       E.ExtLibName = E.ExtName;
       continue;
     }
void fixupExports() {
   }
   Config->Exports = std::move(V);
 
   // Sort by name.
   std::sort(Config->Exports.begin(), Config->Exports.end(),
             [](const Export &A, const Export &B) {
               return A.ExtDLLName < B.ExtDLLName;
             });
-  return std::error_code();
 }
 
 void assignExportOrdinals() {
   // Assign unique ordinals if default (= 0).
   uint16_t Max = 0;
   for (Export &E : Config->Exports)
     Max = std::max(Max, E.Ordinal);
   for (Export &E : Config->Exports)
     if (E.Ordinal == 0)
       E.Ordinal = ++Max;
 }
 
 // Parses a string in the form of "key=value" and check
 // if value matches previous values for the same key.
-std::error_code checkFailIfMismatch(StringRef Arg) {
+void checkFailIfMismatch(StringRef Arg) {
   StringRef K, V;
   std::tie(K, V) = Arg.split('=');
-  if (K.empty() || V.empty()) {
-    llvm::errs() << "/failifmismatch: invalid argument: " << Arg << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (K.empty() || V.empty())
+    error(Twine("/failifmismatch: invalid argument: ") + Arg);
   StringRef Existing = Config->MustMatch[K];
-  if (!Existing.empty() && V != Existing) {
-    llvm::errs() << "/failifmismatch: mismatch detected: "
-                 << Existing << " and " << V << " for key " << K << "\n";
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (!Existing.empty() && V != Existing)
+    error(Twine("/failifmismatch: mismatch detected: ") + Existing + " and " +
+          V + " for key " + K);
   Config->MustMatch[K] = V;
-  return std::error_code();
 }
 
 // Convert Windows resource files (.res files) to a .obj file
 // using cvtres.exe.
-ErrorOr<std::unique_ptr<MemoryBuffer>>
+std::unique_ptr<MemoryBuffer>
 convertResToCOFF(const std::vector<MemoryBufferRef> &MBs) {
   // Create an output file path.
   SmallString<128> Path;
   if (llvm::sys::fs::createTemporaryFile("resource", "obj", Path))
-    return make_error_code(LLDError::InvalidOption);
+    error("Could not create temporary file");
 
   // Execute cvtres.exe.
   Executor E("cvtres.exe");
   E.add("/machine:" + machineToStr(Config->Machine));
   E.add("/readonly");
   E.add("/nologo");
   E.add("/out:" + Path);
   for (MemoryBufferRef MB : MBs)
     E.add(MB.getBufferIdentifier());
-  if (auto EC = E.run())
-    return EC;
-  return MemoryBuffer::getFile(Path);
+  E.run();
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Ret = MemoryBuffer::getFile(Path);
+  error(Ret, Twine("Could not open ") + Path);
+  return std::move(*Ret);
 }
 
 static std::string writeToTempFile(StringRef Contents) {
   SmallString<128> Path;
   int FD;
   if (llvm::sys::fs::createTemporaryFile("tmp", "def", FD, Path)) {
     llvm::errs() << "failed to create a temporary file\n";
     return "";
if (E.Private)
       OS << " PRIVATE";
     OS << "\n";
   }
   OS.flush();
   return S;
 }
 
 // Creates a .def file and runs lib.exe on it to create an import library.
-std::error_code writeImportLibrary() {
+void writeImportLibrary() {
   std::string Contents = createModuleDefinitionFile();
   std::string Def = writeToTempFile(Contents);
   llvm::FileRemover TempFile(Def);
 
   Executor E("lib.exe");
   E.add("/nologo");
   E.add("/machine:" + machineToStr(Config->Machine));
   E.add(Twine("/def:") + Def);
   if (Config->Implib.empty()) {
     SmallString<128> Out = StringRef(Config->OutputFile);
     sys::path::replace_extension(Out, ".lib");
     E.add("/out:" + Out);
   } else {
     E.add("/out:" + Config->Implib);
   }
-  return E.run();
+  E.run();
 }
 
 void touchFile(StringRef Path) {
   int FD;
-  if (sys::fs::openFileForWrite(Path, FD, sys::fs::F_Append))
-    report_fatal_error("failed to create a file");
+  std::error_code EC = sys::fs::openFileForWrite(Path, FD, sys::fs::F_Append);
+  error(EC, "failed to create a file");
   sys::Process::SafelyCloseFileDescriptor(FD);
 }
 
 // Create OptTable
 
 // Create prefix string literals used in Options.td
 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
 #include "Options.inc"

 };
 
 class COFFOptTable : public llvm::opt::OptTable {
 public:
   COFFOptTable() : OptTable(infoTable, llvm::array_lengthof(infoTable), true) {}
 };
 
 // Parses a given list of options.
-ErrorOr<llvm::opt::InputArgList>
-ArgParser::parse(ArrayRef<const char *> ArgsArr) {
+llvm::opt::InputArgList ArgParser::parse(ArrayRef<const char *> ArgsArr) {
   // First, replace respnose files (@<file>-style options).
-  auto ArgvOrErr = replaceResponseFiles(ArgsArr);
-  if (auto EC = ArgvOrErr.getError()) {
-    llvm::errs() << "error while reading response file: " << EC.message()
-                 << "\n";
-    return EC;
-  }
-  std::vector<const char *> Argv = std::move(ArgvOrErr.get());
+  std::vector<const char *> Argv = replaceResponseFiles(ArgsArr);
 
   // Make InputArgList from string vectors.
   COFFOptTable Table;
   unsigned MissingIndex;
   unsigned MissingCount;
   llvm::opt::InputArgList Args =
       Table.ParseArgs(Argv, MissingIndex, MissingCount);
-  if (MissingCount) {
-    llvm::errs() << "missing arg value for \""
-                 << Args.getArgString(MissingIndex) << "\", expected "
-                 << MissingCount
-                 << (MissingCount == 1 ? " argument.\n" : " arguments.\n");
-    return make_error_code(LLDError::InvalidOption);
-  }
+  if (MissingCount)
+    error(Twine("missing arg value for \"") + Args.getArgString(MissingIndex) +
+          "\", expected " + Twine(MissingCount) +
+          (MissingCount == 1 ? " argument." : " arguments."));
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
     llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
-  return std::move(Args);
+  return Args;
 }
 
-ErrorOr<llvm::opt::InputArgList>
-ArgParser::parseLINK(ArrayRef<const char *> Args) {
+llvm::opt::InputArgList ArgParser::parseLINK(ArrayRef<const char *> Args) {
   // Concatenate LINK env and given arguments and parse them.
   Optional<std::string> Env = Process::GetEnv("LINK");
   if (!Env)
     return parse(Args);
   std::vector<const char *> V = tokenize(*Env);
   V.insert(V.end(), Args.begin(), Args.end());
   return parse(V);
 }
 
 std::vector<const char *> ArgParser::tokenize(StringRef S) {
   SmallVector<const char *, 16> Tokens;
   BumpPtrStringSaver Saver(AllocAux);
   llvm::cl::TokenizeWindowsCommandLine(S, Saver, Tokens);
   return std::vector<const char *>(Tokens.begin(), Tokens.end());
 }
 
 // Creates a new command line by replacing options starting with '@'
 // character. '@<filename>' is replaced by the file's contents.
-ErrorOr<std::vector<const char *>>
+std::vector<const char *>
 ArgParser::replaceResponseFiles(std::vector<const char *> Argv) {
   SmallVector<const char *, 256> Tokens(Argv.data(), Argv.data() + Argv.size());
   BumpPtrStringSaver Saver(AllocAux);
   ExpandResponseFiles(Saver, TokenizeWindowsCommandLine, Tokens);
   return std::vector<const char *>(Tokens.begin(), Tokens.end());
 }
 
 void printHelp(const char *Argv0) {
   COFFOptTable Table;
   Table.PrintHelp(llvm::outs(), Argv0, "LLVM Linker", false);
 }
 
 } // namespace coff
 } // namespace lld

COFF/Error.h

 //===- Error.h ------------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_ERROR_H
 #define LLD_COFF_ERROR_H
 
-#include <string>
-#include <system_error>
-#include "llvm/Support/ErrorHandling.h"
+#include "lld/Core/LLVM.h"
 
 namespace lld {
 namespace coff {
 
-enum class LLDError {
-  InvalidOption = 1,
-  InvalidFile,
-  BrokenFile,
-  DuplicateSymbols,
-};
-
-class LLDErrorCategory : public std::error_category {
-public:
-  const char *name() const LLVM_NOEXCEPT override { return "lld"; }
-
-  std::string message(int EV) const override {
-    switch (static_cast<LLDError>(EV)) {
-    case LLDError::InvalidOption:
-      return "Invalid option";
-    case LLDError::InvalidFile:
-      return "Invalid file";
-    case LLDError::BrokenFile:
-      return "Broken file";
-    case LLDError::DuplicateSymbols:
-      return "Duplicate symbols";
-    }
-    llvm_unreachable("unknown error");
-  }
-};
-
-inline std::error_code make_error_code(LLDError Err) {
-  static LLDErrorCategory C;
-  return std::error_code(static_cast<int>(Err), C);
+LLVM_ATTRIBUTE_NORETURN void error(const Twine &Msg);
+void error(std::error_code EC, const Twine &Prefix);
+template <typename T> void error(const ErrorOr<T> &V, const Twine &Prefix) {
+  error(V.getError(), Prefix);
 }
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/Error.cpp

+//===- Error.cpp ----------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace lld {
+namespace coff {
+
+void error(const Twine &Msg) {
+  llvm::errs() << Msg << "\n";
+  exit(1);
+}
+
+void error(std::error_code EC, const Twine &Prefix) {
+  if (!EC)
+    return;
+  error(Prefix + ": " + EC.message());
+}
+}
+}

COFF/InputFiles.h

public:
   // Returns the filename.
   StringRef getName() { return MB.getBufferIdentifier(); }
 
   // Returns symbols defined by this file.
   virtual std::vector<SymbolBody *> &getSymbols() = 0;
 
   // Reads a file (constructors don't do that). Returns an error if a
   // file is broken.
-  virtual std::error_code parse() = 0;
+  virtual void parse() = 0;
 
   // Returns the CPU type this file was compiled to.
   virtual MachineTypes getMachineType() { return IMAGE_FILE_MACHINE_UNKNOWN; }
 
   // Returns a short, human-friendly filename. If this is a member of
   // an archive file, a returned value includes parent's filename.
   // Used for logging or debugging.
   std::string getShortName();
private:
   StringRef ParentName;
 };
 
 // .lib or .a file.
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
-  std::error_code parse() override;
+  void parse() override;
 
   // Returns a memory buffer for a given symbol. An empty memory buffer
   // is returned if we have already returned the same memory buffer.
   // (So that we don't instantiate same members more than once.)
-  ErrorOr<MemoryBufferRef> getMember(const Archive::Symbol *Sym);
+  MemoryBufferRef getMember(const Archive::Symbol *Sym);
 
   std::vector<Lazy *> &getLazySymbols() { return LazySymbols; }
 
   // All symbols returned by ArchiveFiles are of Lazy type.
   std::vector<SymbolBody *> &getSymbols() override {
     llvm_unreachable("internal error");
   }
 
 private:
   std::unique_ptr<Archive> File;
   std::string Filename;
   std::vector<Lazy *> LazySymbols;
   std::map<uint64_t, std::atomic_flag> Seen;
   llvm::MallocAllocator Alloc;
 };
 
 // .obj or .o file. This may be a member of an archive file.
 class ObjectFile : public InputFile {
 public:
   explicit ObjectFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
-  std::error_code parse() override;
+  void parse() override;
   MachineTypes getMachineType() override;
   std::vector<Chunk *> &getChunks() { return Chunks; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
   // Returns a SymbolBody object for the SymbolIndex'th symbol in the
   // underlying object file.
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) {
     return SparseSymbolBodies[SymbolIndex];
   }
 
   // Returns the underying COFF file.
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
 
   // True if this object file is compatible with SEH.
   // COFF-specific and x86-only.
   bool SEHCompat = false;
 
   // The list of safe exception handlers listed in .sxdata section.
   // COFF-specific and x86-only.
   std::set<SymbolBody *> SEHandlers;
 
 private:
-  std::error_code initializeChunks();
-  std::error_code initializeSymbols();
-  std::error_code initializeSEH();
+  void initializeChunks();
+  void initializeSymbols();
+  void initializeSEH();
 
   Defined *createDefined(COFFSymbolRef Sym, const void *Aux, bool IsFirst);
   Undefined *createUndefined(COFFSymbolRef Sym);
   Undefined *createWeakExternal(COFFSymbolRef Sym, const void *Aux);
 
   std::unique_ptr<COFFObjectFile> COFFObj;
   llvm::BumpPtrAllocator Alloc;
   const coff_section *SXData = nullptr;

 class ImportFile : public InputFile {
 public:
   explicit ImportFile(MemoryBufferRef M)
       : InputFile(ImportKind, M), StringAlloc(StringAllocAux) {}
   static bool classof(const InputFile *F) { return F->kind() == ImportKind; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
 
 private:
-  std::error_code parse() override;
+  void parse() override;
 
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   llvm::BumpPtrAllocator StringAllocAux;
   llvm::BumpPtrStringSaver StringAlloc;
 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
   MachineTypes getMachineType() override;
 
   LTOModule *getModule() const { return M.get(); }
   LTOModule *releaseModule() { return M.release(); }
 
 private:
-  std::error_code parse() override;
+  void parse() override;
 
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   std::unique_ptr<LTOModule> M;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/InputFiles.cpp

 std::string InputFile::getShortName() {
   if (ParentName == "")
     return getName().lower();
   std::string Res = (getBasename(ParentName) + "(" +
                      getBasename(getName()) + ")").str();
   return StringRef(Res).lower();
 }
 
-std::error_code ArchiveFile::parse() {
+void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   auto ArchiveOrErr = Archive::create(MB);
-  if (auto EC = ArchiveOrErr.getError())
-    return EC;
+  error(ArchiveOrErr, "Failed to parse static library");
   File = std::move(ArchiveOrErr.get());
 
   // Allocate a buffer for Lazy objects.
   size_t NumSyms = File->getNumberOfSymbols();
   size_t BufSize = NumSyms * sizeof(Lazy);
   Lazy *Buf = (Lazy *)Alloc.Allocate(BufSize, llvm::alignOf<Lazy>());
   LazySymbols.reserve(NumSyms);
 
   // Read the symbol table to construct Lazy objects.
   uint32_t I = 0;
   for (const Archive::Symbol &Sym : File->symbols()) {
     auto *B = new (&Buf[I++]) Lazy(this, Sym);
     // Skip special symbol exists in import library files.
     if (B->getName() != "__NULL_IMPORT_DESCRIPTOR")
       LazySymbols.push_back(B);
   }
 
   // Seen is a map from member files to boolean values. Initially
   // all members are mapped to false, which indicates all these files
   // are not read yet.
   for (const Archive::Child &Child : File->children())
     Seen[Child.getChildOffset()].clear();
-  return std::error_code();
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 // This function is thread-safe.
-ErrorOr<MemoryBufferRef> ArchiveFile::getMember(const Archive::Symbol *Sym) {
+MemoryBufferRef ArchiveFile::getMember(const Archive::Symbol *Sym) {
   auto ItOrErr = Sym->getMember();
-  if (auto EC = ItOrErr.getError())
-    return EC;
+  error(ItOrErr,
+        Twine("Could not get the member for symbol ") + Sym->getName());
   Archive::child_iterator It = ItOrErr.get();
 
   // Return an empty buffer if we have already returned the same buffer.
   if (Seen[It->getChildOffset()].test_and_set())
     return MemoryBufferRef();
-  return It->getMemoryBufferRef();
+  ErrorOr<MemoryBufferRef> Ret = It->getMemoryBufferRef();
+  error(Ret, Twine("Could not get the buffer for the member defining symbol ") +
+                 Sym->getName());
+  return *Ret;
 }
 
-std::error_code ObjectFile::parse() {
+void ObjectFile::parse() {
   // Parse a memory buffer as a COFF file.
   auto BinOrErr = createBinary(MB);
-  if (auto EC = BinOrErr.getError())
-    return EC;
+  error(BinOrErr, "Failed to parse object file");
   std::unique_ptr<Binary> Bin = std::move(BinOrErr.get());
 
   if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {
     Bin.release();
     COFFObj.reset(Obj);
   } else {
-    llvm::errs() << getName() << " is not a COFF file.\n";
-    return make_error_code(LLDError::InvalidFile);
+    error(Twine(getName()) + " is not a COFF file.");
   }
 
   // Read section and symbol tables.
-  if (auto EC = initializeChunks())
-    return EC;
-  if (auto EC = initializeSymbols())
-    return EC;
-  return initializeSEH();
+  initializeChunks();
+  initializeSymbols();
+  initializeSEH();
 }
 
-std::error_code ObjectFile::initializeChunks() {
+void ObjectFile::initializeChunks() {
   uint32_t NumSections = COFFObj->getNumberOfSections();
   Chunks.reserve(NumSections);
   SparseChunks.resize(NumSections + 1);
   for (uint32_t I = 1; I < NumSections + 1; ++I) {
     const coff_section *Sec;
     StringRef Name;
-    if (auto EC = COFFObj->getSection(I, Sec)) {
-      llvm::errs() << "getSection failed: " << Name << ": "
-                   << EC.message() << "\n";
-      return make_error_code(LLDError::BrokenFile);
-    }
-    if (auto EC = COFFObj->getSectionName(Sec, Name)) {
-      llvm::errs() << "getSectionName failed: " << Name << ": "
-                   << EC.message() << "\n";
-      return make_error_code(LLDError::BrokenFile);
-    }
+    std::error_code EC = COFFObj->getSection(I, Sec);
+    error(EC, Twine("getSection failed: ") + Name);
+    EC = COFFObj->getSectionName(Sec, Name);
+    error(EC, Twine("getSectionName failed: ") + Name);
     if (Name == ".sxdata") {
       SXData = Sec;
       continue;
     }
     if (Name == ".drectve") {
       ArrayRef<uint8_t> Data;
       COFFObj->getSectionContents(Sec, Data);
       Directives = std::string((const char *)Data.data(), Data.size());
       continue;
     }
     // Skip non-DWARF debug info. MSVC linker converts the sections into
     // a PDB file, but we don't support that.
     if (Name == ".debug" || Name.startswith(".debug$"))
       continue;
     // We want to preserve DWARF debug sections only when /debug is on.
     if (!Config->Debug && Name.startswith(".debug"))
       continue;
     if (Sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
       continue;
     auto *C = new (Alloc) SectionChunk(this, Sec);
     Chunks.push_back(C);
     SparseChunks[I] = C;
   }
-  return std::error_code();
 }
 
-std::error_code ObjectFile::initializeSymbols() {
+void ObjectFile::initializeSymbols() {
   uint32_t NumSymbols = COFFObj->getNumberOfSymbols();
   SymbolBodies.reserve(NumSymbols);
   SparseSymbolBodies.resize(NumSymbols);
   int32_t LastSectionNumber = 0;
   for (uint32_t I = 0; I < NumSymbols; ++I) {
     // Get a COFFSymbolRef object.
     auto SymOrErr = COFFObj->getSymbol(I);
-    if (auto EC = SymOrErr.getError()) {
-      llvm::errs() << "broken object file: " << getName() << ": "
-                   << EC.message() << "\n";
-      return make_error_code(LLDError::BrokenFile);
-    }
+    error(SymOrErr, Twine("broken object file: ") + getName());
+
     COFFSymbolRef Sym = SymOrErr.get();
 
     const void *AuxP = nullptr;
     if (Sym.getNumberOfAuxSymbols())
       AuxP = COFFObj->getSymbol(I + 1)->getRawPtr();
     bool IsFirst = (LastSectionNumber != Sym.getSectionNumber());
 
     SymbolBody *Body = nullptr;
     if (Sym.isUndefined()) {
       Body = createUndefined(Sym);
     } else if (Sym.isWeakExternal()) {
       Body = createWeakExternal(Sym, AuxP);
     } else {
       Body = createDefined(Sym, AuxP, IsFirst);
     }
     if (Body) {
       SymbolBodies.push_back(Body);
       SparseSymbolBodies[I] = Body;
     }
     I += Sym.getNumberOfAuxSymbols();
     LastSectionNumber = Sym.getSectionNumber();
   }
-  return std::error_code();
 }
 
 Undefined *ObjectFile::createUndefined(COFFSymbolRef Sym) {
   StringRef Name;
   COFFObj->getSymbolName(Sym, Name);
   return new (Alloc) Undefined(Name);
 }
 
Defined *ObjectFile::createDefined(COFFSymbolRef Sym, const void *AuxP,
 
   auto *B = new (Alloc) DefinedRegular(this, Sym, SC);
   if (SC->isCOMDAT() && Sym.getValue() == 0 && !AuxP)
     SC->setSymbol(B);
 
   return B;
 }
 
-std::error_code ObjectFile::initializeSEH() {
+void ObjectFile::initializeSEH() {
   if (!SEHCompat || !SXData)
-    return std::error_code();
+    return;
   ArrayRef<uint8_t> A;
   COFFObj->getSectionContents(SXData, A);
-  if (A.size() % 4 != 0) {
-    llvm::errs() << ".sxdata must be an array of symbol table indices\n";
-    return make_error_code(LLDError::BrokenFile);
-  }
+  if (A.size() % 4 != 0)
+    error(".sxdata must be an array of symbol table indices");
   auto *I = reinterpret_cast<const ulittle32_t *>(A.data());
   auto *E = reinterpret_cast<const ulittle32_t *>(A.data() + A.size());
   for (; I != E; ++I)
     SEHandlers.insert(SparseSymbolBodies[*I]);
-  return std::error_code();
 }
 
 MachineTypes ObjectFile::getMachineType() {
   if (COFFObj)
     return static_cast<MachineTypes>(COFFObj->getMachine());
   return IMAGE_FILE_MACHINE_UNKNOWN;
 }
 
 StringRef ltrim1(StringRef S, const char *Chars) {
   if (!S.empty() && strchr(Chars, S[0]))
     return S.substr(1);
   return S;
 }
 
-std::error_code ImportFile::parse() {
+void ImportFile::parse() {
   const char *Buf = MB.getBufferStart();
   const char *End = MB.getBufferEnd();
   const auto *Hdr = reinterpret_cast<const coff_import_header *>(Buf);
 
   // Check if the total size is valid.
-  if ((size_t)(End - Buf) != (sizeof(*Hdr) + Hdr->SizeOfData)) {
-    llvm::errs() << "broken import library\n";
-    return make_error_code(LLDError::BrokenFile);
-  }
+  if ((size_t)(End - Buf) != (sizeof(*Hdr) + Hdr->SizeOfData))
+    error("broken import library");
 
   // Read names and create an __imp_ symbol.
   StringRef Name = StringAlloc.save(StringRef(Buf + sizeof(*Hdr)));
   StringRef ImpName = StringAlloc.save(Twine("__imp_") + Name);
   StringRef DLLName(Buf + sizeof(coff_import_header) + Name.size() + 1);
   StringRef ExtName;
   switch (Hdr->getNameType()) {
   case IMPORT_ORDINAL:
void ImportFile::parse() {
 
   // If type is function, we need to create a thunk which jump to an
   // address pointed by the __imp_ symbol. (This allows you to call
   // DLL functions just like regular non-DLL functions.)
   if (Hdr->getType() == llvm::COFF::IMPORT_CODE) {
     auto *B = new (Alloc) DefinedImportThunk(Name, ImpSym, Hdr->Machine);
     SymbolBodies.push_back(B);
   }
-  return std::error_code();
 }
 
-std::error_code BitcodeFile::parse() {
+void BitcodeFile::parse() {
   std::string Err;
   M.reset(LTOModule::createFromBuffer(MB.getBufferStart(),
                                       MB.getBufferSize(),
                                       llvm::TargetOptions(), Err));
-  if (!Err.empty()) {
-    llvm::errs() << Err << '\n';
-    return make_error_code(LLDError::BrokenFile);
-  }
+  if (!Err.empty())
+    error(Err);
 
   llvm::BumpPtrStringSaver Saver(Alloc);
   for (unsigned I = 0, E = M->getSymbolCount(); I != E; ++I) {
     lto_symbol_attributes Attrs = M->getSymbolAttributes(I);
     if ((Attrs & LTO_SYMBOL_SCOPE_MASK) == LTO_SYMBOL_SCOPE_INTERNAL)
       continue;
 
     StringRef SymName = Saver.save(M->getSymbolName(I));
     int SymbolDef = Attrs & LTO_SYMBOL_DEFINITION_MASK;
     if (SymbolDef == LTO_SYMBOL_DEFINITION_UNDEFINED) {
       SymbolBodies.push_back(new (Alloc) Undefined(SymName));
     } else {
       bool Replaceable =
           (SymbolDef == LTO_SYMBOL_DEFINITION_TENTATIVE || // common
            (Attrs & LTO_SYMBOL_COMDAT) ||                  // comdat
            (SymbolDef == LTO_SYMBOL_DEFINITION_WEAK &&     // weak external
             (Attrs & LTO_SYMBOL_ALIAS)));
       SymbolBodies.push_back(new (Alloc) DefinedBitcode(this, SymName,
                                                         Replaceable));
     }
   }
 
   Directives = M->getLinkerOpts();
-  return std::error_code();
 }
 
 MachineTypes BitcodeFile::getMachineType() {
   if (!M)
     return IMAGE_FILE_MACHINE_UNKNOWN;
   switch (Triple(M->getTargetTriple()).getArch()) {
   case Triple::x86_64:
     return AMD64;

COFF/ModuleDef.cpp

 private:
   StringRef Buf;
 };
 
 class Parser {
 public:
   explicit Parser(StringRef S, BumpPtrStringSaver *A) : Lex(S), Alloc(A) {}
 
-  std::error_code parse() {
+  void parse() {
     do {
-      if (auto EC = parseOne())
-        return EC;
+      parseOne();
     } while (Tok.K != Eof);
-    return std::error_code();
   }
 
 private:
   void read() {
     if (Stack.empty()) {
       Tok = Lex.lex();
       return;
     }
     Tok = Stack.back();
     Stack.pop_back();
   }
 
-  std::error_code readAsInt(uint64_t *I) {
+  void readAsInt(uint64_t *I) {
     read();
-    if (Tok.K != Identifier || Tok.Value.getAsInteger(10, *I)) {
-      llvm::errs() << "integer expected\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
-    return std::error_code();
+    if (Tok.K != Identifier || Tok.Value.getAsInteger(10, *I))
+      error("integer expected");
   }
 
-  std::error_code expect(Kind Expected, StringRef Msg) {
+  void expect(Kind Expected, StringRef Msg) {
     read();
-    if (Tok.K != Expected) {
-      llvm::errs() << Msg << "\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
-    return std::error_code();
+    if (Tok.K != Expected)
+      error(Msg);
   }
 
   void unget() { Stack.push_back(Tok); }
 
-  std::error_code parseOne() {
+  void parseOne() {
     read();
     switch (Tok.K) {
     case Eof:
-      return std::error_code();
+      return;
     case KwExports:
       for (;;) {
         read();
         if (Tok.K != Identifier) {
           unget();
-          return std::error_code();
+          return;
         }
-        if (auto EC = parseExport())
-          return EC;
+        parseExport();
       }
     case KwHeapsize:
-      if (auto EC = parseNumbers(&Config->HeapReserve, &Config->HeapCommit))
-        return EC;
-      return std::error_code();
+      parseNumbers(&Config->HeapReserve, &Config->HeapCommit);
+      return;
     case KwLibrary:
-      if (auto EC = parseName(&Config->OutputFile, &Config->ImageBase))
-        return EC;
+      parseName(&Config->OutputFile, &Config->ImageBase);
       if (!StringRef(Config->OutputFile).endswith_lower(".dll"))
         Config->OutputFile += ".dll";
-      return std::error_code();
+      return;
     case KwStacksize:
-      if (auto EC = parseNumbers(&Config->StackReserve, &Config->StackCommit))
-        return EC;
-      return std::error_code();
+      parseNumbers(&Config->StackReserve, &Config->StackCommit);
+      return;
     case KwName:
-      if (auto EC = parseName(&Config->OutputFile, &Config->ImageBase))
-        return EC;
-      return std::error_code();
+      parseName(&Config->OutputFile, &Config->ImageBase);
+      return;
     case KwVersion:
-      if (auto EC = parseVersion(&Config->MajorImageVersion,
-                                 &Config->MinorImageVersion))
-        return EC;
-      return std::error_code();
+      parseVersion(&Config->MajorImageVersion, &Config->MinorImageVersion);
+      return;
     default:
-      llvm::errs() << "unknown directive: " << Tok.Value << "\n";
-      return make_error_code(LLDError::InvalidOption);
+      error(Twine("unknown directive: ") + Tok.Value);
     }
   }
 
-  std::error_code parseExport() {
+  void parseExport() {
     Export E;
     E.Name = Tok.Value;
     read();
     if (Tok.K == Equal) {
       read();
-      if (Tok.K != Identifier) {
-        llvm::errs() << "identifier expected, but got " << Tok.Value << "\n";
-        return make_error_code(LLDError::InvalidOption);
-      }
+      if (Tok.K != Identifier)
+        error(Twine("identifier expected, but got ") + Tok.Value);
       E.ExtName = E.Name;
       E.Name = Tok.Value;
     } else {
       unget();
     }
 
     if (Config->Machine == I386 && !E.Name.startswith("_@?"))
       E.Name = Alloc->save("_" + E.Name);
for (;;) {
         continue;
       }
       if (Tok.K == KwPrivate) {
         E.Private = true;
         continue;
       }
       unget();
       Config->Exports.push_back(E);
-      return std::error_code();
+      return;
     }
   }
 
   // HEAPSIZE/STACKSIZE reserve[,commit]
-  std::error_code parseNumbers(uint64_t *Reserve, uint64_t *Commit) {
-    if (auto EC = readAsInt(Reserve))
-      return EC;
+  void parseNumbers(uint64_t *Reserve, uint64_t *Commit) {
+    readAsInt(Reserve);
     read();
     if (Tok.K != Comma) {
       unget();
       Commit = 0;
-      return std::error_code();
+      return;
     }
-    if (auto EC = readAsInt(Commit))
-      return EC;
-    return std::error_code();
+    readAsInt(Commit);
   }
 
   // NAME outputPath [BASE=address]
-  std::error_code parseName(std::string *Out, uint64_t *Baseaddr) {
+  void parseName(std::string *Out, uint64_t *Baseaddr) {
     read();
     if (Tok.K == Identifier) {
       *Out = Tok.Value;
     } else {
       *Out = "";
       unget();
-      return std::error_code();
+      return;
     }
     read();
     if (Tok.K == KwBase) {
-      if (auto EC = expect(Equal, "'=' expected"))
-        return EC;
-      if (auto EC = readAsInt(Baseaddr))
-        return EC;
+      expect(Equal, "'=' expected");
+      readAsInt(Baseaddr);
     } else {
       unget();
       *Baseaddr = 0;
     }
-    return std::error_code();
   }
 
   // VERSION major[.minor]
-  std::error_code parseVersion(uint32_t *Major, uint32_t *Minor) {
+  void parseVersion(uint32_t *Major, uint32_t *Minor) {
     read();
-    if (Tok.K != Identifier) {
-      llvm::errs() << "identifier expected, but got " << Tok.Value << "\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
+    if (Tok.K != Identifier)
+      error(Twine("identifier expected, but got ") + Tok.Value);
     StringRef V1, V2;
     std::tie(V1, V2) = Tok.Value.split('.');
-    if (V1.getAsInteger(10, *Major)) {
-      llvm::errs() << "integer expected, but got " << Tok.Value << "\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
-    if (V2.empty()) {
+    if (V1.getAsInteger(10, *Major))
+      error(Twine("integer expected, but got ") + Tok.Value);
+    if (V2.empty())
       *Minor = 0;
-    } else if (V2.getAsInteger(10, *Minor)) {
-      llvm::errs() << "integer expected, but got " << Tok.Value << "\n";
-      return make_error_code(LLDError::InvalidOption);
-    }
-    return std::error_code();
+    else if (V2.getAsInteger(10, *Minor))
+      error(Twine("integer expected, but got ") + Tok.Value);
   }
 
   Lexer Lex;
   Token Tok;
   std::vector<Token> Stack;
   BumpPtrStringSaver *Alloc;
 };
 
 } // anonymous namespace
 
-std::error_code parseModuleDefs(MemoryBufferRef MB, BumpPtrStringSaver *Alloc) {
-  return Parser(MB.getBuffer(), Alloc).parse();
+void parseModuleDefs(MemoryBufferRef MB, BumpPtrStringSaver *Alloc) {
+  Parser(MB.getBuffer(), Alloc).parse();
 }
 
 } // namespace coff
 } // namespace lld

COFF/SymbolTable.h

 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in resolve().
 class SymbolTable {
 public:
   void addFile(std::unique_ptr<InputFile> File);
   std::vector<std::unique_ptr<InputFile>> &getFiles() { return Files; }
-  std::error_code step();
-  std::error_code run();
+  void step();
+  void run();
   bool queueEmpty();
 
   // Print an error message on undefined symbols. If Resolve is true, try to
   // resolve any undefined symbols and update the symbol table accordingly.
-  bool reportRemainingUndefines(bool Resolve);
+  void reportRemainingUndefines(bool Resolve);
 
   // Returns a list of chunks of selected symbols.
   std::vector<Chunk *> getChunks();
 
   // Returns a symbol for a given name. Returns a nullptr if not found.
   Symbol *find(StringRef Name);
   Symbol *findUnderscore(StringRef Name);
 
   // Occasionally we have to resolve an undefined symbol to its
   // mangled symbol. This function tries to find a mangled name
   // for U from the symbol table, and if found, set the symbol as
   // a weak alias for U.
   void mangleMaybe(Undefined *U);
   StringRef findMangle(StringRef Name);
 
   // Print a layout map to OS.
   void printMap(llvm::raw_ostream &OS);
 
   // Build a COFF object representing the combined contents of BitcodeFiles
   // and add it to the symbol table. Called after all files are added and
   // before the writer writes results to a file.
-  std::error_code addCombinedLTOObject();
+  void addCombinedLTOObject();
 
   // The writer needs to handle DLL import libraries specially in
   // order to create the import descriptor table.
   std::vector<ImportFile *> ImportFiles;
 
   // The writer needs to infer the machine type from the object files.
   std::vector<ObjectFile *> ObjectFiles;
 
   // Creates an Undefined symbol for a given name.
   Undefined *addUndefined(StringRef Name);
   DefinedRelative *addRelative(StringRef Name, uint64_t VA);
   DefinedAbsolute *addAbsolute(StringRef Name, uint64_t VA);
 
   // A list of chunks which to be added to .rdata.
   std::vector<Chunk *> LocalImportChunks;
 
 private:
-  std::error_code readArchives();
-  std::error_code readObjects();
+  void readArchives();
+  void readObjects();
 
-  std::error_code addSymbol(SymbolBody *New);
+  void addSymbol(SymbolBody *New);
   void addLazy(Lazy *New, std::vector<Symbol *> *Accum);
   Symbol *insert(SymbolBody *New);
   StringRef findByPrefix(StringRef Prefix);
 
-  std::error_code addMemberFile(Lazy *Body);
-  ErrorOr<ObjectFile *> createLTOObject(llvm::LTOCodeGenerator *CG);
+  void addMemberFile(Lazy *Body);
+  ObjectFile *createLTOObject(llvm::LTOCodeGenerator *CG);
 
   llvm::DenseMap<StringRef, Symbol *> Symtab;
 
   std::vector<std::unique_ptr<InputFile>> Files;
   std::vector<ArchiveFile *> ArchiveQueue;
   std::vector<InputFile *> ObjectQueue;
 
   std::vector<BitcodeFile *> BitcodeFiles;
   std::unique_ptr<MemoryBuffer> LTOMB;
   llvm::BumpPtrAllocator Alloc;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

COFF/SymbolTable.cpp

if (auto *F = dyn_cast<ObjectFile>(File)) {
     ObjectFiles.push_back(F);
   } else if (auto *F = dyn_cast<BitcodeFile>(File)) {
     BitcodeFiles.push_back(F);
   } else {
     ImportFiles.push_back(cast<ImportFile>(File));
   }
 }
 
-std::error_code SymbolTable::step() {
+void SymbolTable::step() {
   if (queueEmpty())
-    return std::error_code();
-  if (auto EC = readObjects())
-    return EC;
-  if (auto EC = readArchives())
-    return EC;
-  return std::error_code();
+    return;
+  readObjects();
+  readArchives();
 }
 
-std::error_code SymbolTable::run() {
+void SymbolTable::run() {
   while (!queueEmpty())
-    if (auto EC = step())
-      return EC;
-  return std::error_code();
+    step();
 }
 
-std::error_code SymbolTable::readArchives() {
+void SymbolTable::readArchives() {
   if (ArchiveQueue.empty())
-    return std::error_code();
+    return;
 
   // Add lazy symbols to the symbol table. Lazy symbols that conflict
   // with existing undefined symbols are accumulated in LazySyms.
   std::vector<Symbol *> LazySyms;
   for (ArchiveFile *File : ArchiveQueue) {
     if (Config->Verbose)
       llvm::outs() << "Reading " << File->getShortName() << "\n";
-    if (auto EC = File->parse())
-      return EC;
+    File->parse();
     for (Lazy *Sym : File->getLazySymbols())
       addLazy(Sym, &LazySyms);
   }
   ArchiveQueue.clear();
 
   // Add archive member files to ObjectQueue that should resolve
   // existing undefined symbols.
   for (Symbol *Sym : LazySyms)
-    if (auto EC = addMemberFile(cast<Lazy>(Sym->Body)))
-      return EC;
-  return std::error_code();
+    addMemberFile(cast<Lazy>(Sym->Body));
 }
 
-std::error_code SymbolTable::readObjects() {
+void SymbolTable::readObjects() {
   if (ObjectQueue.empty())
-    return std::error_code();
+    return;
 
   // Add defined and undefined symbols to the symbol table.
   std::vector<StringRef> Directives;
   for (size_t I = 0; I < ObjectQueue.size(); ++I) {
     InputFile *File = ObjectQueue[I];
     if (Config->Verbose)
       llvm::outs() << "Reading " << File->getShortName() << "\n";
-    if (auto EC = File->parse())
-      return EC;
+    File->parse();
     // Adding symbols may add more files to ObjectQueue
     // (but not to ArchiveQueue).
     for (SymbolBody *Sym : File->getSymbols())
       if (Sym->isExternal())
-        if (auto EC = addSymbol(Sym))
-          return EC;
+        addSymbol(Sym);
     StringRef S = File->getDirectives();
     if (!S.empty()) {
       Directives.push_back(S);
       if (Config->Verbose)
         llvm::outs() << "Directives: " << File->getShortName()
                      << ": " << S << "\n";
     }
   }
   ObjectQueue.clear();
 
   // Parse directive sections. This may add files to
   // ArchiveQueue and ObjectQueue.
   for (StringRef S : Directives)
-    if (auto EC = Driver->parseDirectives(S))
-      return EC;
-  return std::error_code();
+    Driver->parseDirectives(S);
 }
 
 bool SymbolTable::queueEmpty() {
   return ArchiveQueue.empty() && ObjectQueue.empty();
 }
 
-bool SymbolTable::reportRemainingUndefines(bool Resolve) {
+void SymbolTable::reportRemainingUndefines(bool Resolve) {
   llvm::SmallPtrSet<SymbolBody *, 8> Undefs;
   for (auto &I : Symtab) {
     Symbol *Sym = I.second;
     auto *Undef = dyn_cast<Undefined>(Sym->Body);
     if (!Undef)
       continue;
     StringRef Name = Undef->getName();
     // A weak alias may have been resolved, so check for that.
for (auto &I : Symtab) {
     }
     // Remaining undefined symbols are not fatal if /force is specified.
     // They are replaced with dummy defined symbols.
     if (Config->Force && Resolve)
       Sym->Body = new (Alloc) DefinedAbsolute(Name, 0);
     Undefs.insert(Sym->Body);
   }
   if (Undefs.empty())
-    return false;
+    return;
   for (Undefined *U : Config->GCRoot)
     if (Undefs.count(U->repl()))
       llvm::errs() << "<root>: undefined symbol: " << U->getName() << "\n";
   for (std::unique_ptr<InputFile> &File : Files)
     if (!isa<ArchiveFile>(File.get()))
       for (SymbolBody *Sym : File->getSymbols())
         if (Undefs.count(Sym->repl()))
           llvm::errs() << File->getShortName() << ": undefined symbol: "
                        << Sym->getName() << "\n";
-  return !Config->Force;
+  if (!Config->Force)
+    error("Link failed");
 }
 
 void SymbolTable::addLazy(Lazy *New, std::vector<Symbol *> *Accum) {
   Symbol *Sym = insert(New);
   if (Sym->Body == New)
     return;
   for (;;) {
     SymbolBody *Existing = Sym->Body;
     if (isa<Defined>(Existing))
       return;
     if (Lazy *L = dyn_cast<Lazy>(Existing))
       if (L->getFileIndex() < New->getFileIndex())
         return;
     if (!Sym->Body.compare_exchange_strong(Existing, New))
       continue;
     New->setBackref(Sym);
     if (isa<Undefined>(Existing))
       Accum->push_back(Sym);
     return;
   }
 }
 
-std::error_code SymbolTable::addSymbol(SymbolBody *New) {
+void SymbolTable::addSymbol(SymbolBody *New) {
   // Find an existing symbol or create and insert a new one.
   assert(isa<Defined>(New) || isa<Undefined>(New));
   Symbol *Sym = insert(New);
   if (Sym->Body == New)
-    return std::error_code();
+    return;
 
   for (;;) {
     SymbolBody *Existing = Sym->Body;
 
     // If we have an undefined symbol and a lazy symbol,
     // let the lazy symbol to read a member file.
     if (auto *L = dyn_cast<Lazy>(Existing)) {
       // Undefined symbols with weak aliases need not to be resolved,
       // since they would be replaced with weak aliases if they remain
       // undefined.
       if (auto *U = dyn_cast<Undefined>(New))
-        if (!U->WeakAlias)
-          return addMemberFile(L);
+        if (!U->WeakAlias) {
+          addMemberFile(L);
+          return;
+        }
       if (!Sym->Body.compare_exchange_strong(Existing, New))
         continue;
-      return std::error_code();
+      return;
     }
 
     // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
     // equivalent (conflicting), or more preferable, respectively.
     int Comp = Existing->compare(New);
-    if (Comp == 0) {
-      llvm::errs() << "duplicate symbol: " << Existing->getDebugName()
-                   << " and " << New->getDebugName() << "\n";
-      return make_error_code(LLDError::DuplicateSymbols);
-    }
+    if (Comp == 0)
+      error(Twine("duplicate symbol: ") + Existing->getDebugName() + " and " +
+            New->getDebugName());
     if (Comp < 0)
       if (!Sym->Body.compare_exchange_strong(Existing, New))
         continue;
-    return std::error_code();
+    return;
   }
 }
 
 Symbol *SymbolTable::insert(SymbolBody *New) {
   Symbol *&Sym = Symtab[New->getName()];
   if (Sym) {
     New->setBackref(Sym);
     return Sym;
   }
   Sym = new (Alloc) Symbol(New);
   New->setBackref(Sym);
   return Sym;
 }
 
 // Reads an archive member file pointed by a given symbol.
-std::error_code SymbolTable::addMemberFile(Lazy *Body) {
-  auto FileOrErr = Body->getMember();
-  if (auto EC = FileOrErr.getError())
-    return EC;
-  std::unique_ptr<InputFile> File = std::move(FileOrErr.get());
+void SymbolTable::addMemberFile(Lazy *Body) {
+  std::unique_ptr<InputFile> File = Body->getMember();
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (!File)
-    return std::error_code();
+    return;
   if (Config->Verbose)
     llvm::outs() << "Loaded " << File->getShortName() << " for "
                  << Body->getName() << "\n";
   addFile(std::move(File));
-  return std::error_code();
 }
 
 std::vector<Chunk *> SymbolTable::getChunks() {
   std::vector<Chunk *> Res;
   for (ObjectFile *File : ObjectFiles) {
     std::vector<Chunk *> &V = File->getChunks();
     Res.insert(Res.end(), V.begin(), V.end());
   }
for (ObjectFile *File : ObjectFiles) {
     for (SymbolBody *Body : File->getSymbols())
       if (auto *R = dyn_cast<DefinedRegular>(Body))
         if (R->isLive())
           OS << Twine::utohexstr(Config->ImageBase + R->getRVA())
              << " " << R->getName() << "\n";
   }
 }
 
-std::error_code SymbolTable::addCombinedLTOObject() {
+void SymbolTable::addCombinedLTOObject() {
   if (BitcodeFiles.empty())
-    return std::error_code();
+    return;
 
   // Diagnose any undefined symbols early, but do not resolve weak externals,
   // as resolution breaks the invariant that each Symbol points to a unique
   // SymbolBody, which we rely on to replace DefinedBitcode symbols correctly.
-  if (reportRemainingUndefines(/*Resolve=*/false))
-    return make_error_code(LLDError::BrokenFile);
+  reportRemainingUndefines(/*Resolve=*/false);
 
   // Create an object file and add it to the symbol table by replacing any
   // DefinedBitcode symbols with the definitions in the object file.
   LTOCodeGenerator CG;
-  auto FileOrErr = createLTOObject(&CG);
-  if (auto EC = FileOrErr.getError())
-    return EC;
-  ObjectFile *Obj = FileOrErr.get();
+  ObjectFile *Obj = createLTOObject(&CG);
 
   for (SymbolBody *Body : Obj->getSymbols()) {
     if (!Body->isExternal())
       continue;
     // We should not see any new undefined symbols at this point, but we'll
     // diagnose them later in reportRemainingUndefines().
     StringRef Name = Body->getName();
     Symbol *Sym = insert(Body);
 
     if (isa<DefinedBitcode>(Sym->Body)) {
       Sym->Body = Body;
       continue;
     }
     if (auto *L = dyn_cast<Lazy>(Sym->Body)) {
       // We may see new references to runtime library symbols such as __chkstk
       // here. These symbols must be wholly defined in non-bitcode files.
-      if (auto EC = addMemberFile(L))
-        return EC;
+      addMemberFile(L);
       continue;
     }
     SymbolBody *Existing = Sym->Body;
     int Comp = Existing->compare(Body);
-    if (Comp == 0) {
-      llvm::errs() << "LTO: unexpected duplicate symbol: " << Name << "\n";
-      return make_error_code(LLDError::BrokenFile);
-    }
+    if (Comp == 0)
+      error(Twine("LTO: unexpected duplicate symbol: ") + Name);
     if (Comp < 0)
       Sym->Body = Body;
   }
 
   size_t NumBitcodeFiles = BitcodeFiles.size();
-  if (auto EC = run())
-    return EC;
-  if (BitcodeFiles.size() != NumBitcodeFiles) {
-    llvm::errs() << "LTO: late loaded symbol created new bitcode reference\n";
-    return make_error_code(LLDError::BrokenFile);
-  }
-
-  return std::error_code();
+  run();
+  if (BitcodeFiles.size() != NumBitcodeFiles)
+    error("LTO: late loaded symbol created new bitcode reference");
 }
 
 // Combine and compile bitcode files and then return the result
 // as a regular COFF object file.
-ErrorOr<ObjectFile *> SymbolTable::createLTOObject(LTOCodeGenerator *CG) {
+ObjectFile *SymbolTable::createLTOObject(LTOCodeGenerator *CG) {
   // All symbols referenced by non-bitcode objects must be preserved.
   for (ObjectFile *File : ObjectFiles)
     for (SymbolBody *Body : File->getSymbols())
       if (auto *S = dyn_cast<DefinedBitcode>(Body->repl()))
         CG->addMustPreserveSymbol(S->getName());
 
   // Likewise for bitcode symbols which we initially resolved to non-bitcode.
   for (BitcodeFile *File : BitcodeFiles)
ObjectFile *SymbolTable::createLTOObject(LTOCodeGenerator *CG) {
   }
 
   CG->setModule(BitcodeFiles[0]->releaseModule());
   for (unsigned I = 1, E = BitcodeFiles.size(); I != E; ++I)
     CG->addModule(BitcodeFiles[I]->getModule());
 
   std::string ErrMsg;
   LTOMB = CG->compile(false, false, false, ErrMsg); // take MB ownership
-  if (!LTOMB) {
-    llvm::errs() << ErrMsg << '\n';
-    return make_error_code(LLDError::BrokenFile);
-  }
+  if (!LTOMB)
+    error(ErrMsg);
   auto *Obj = new ObjectFile(LTOMB->getMemBufferRef());
   Files.emplace_back(Obj);
   ObjectFiles.push_back(Obj);
-  if (auto EC = Obj->parse())
-    return EC;
+  Obj->parse();
   return Obj;
 }
 
 } // namespace coff
 } // namespace lld

COFF/Symbols.h

 public:
   Lazy(ArchiveFile *F, const Archive::Symbol S)
       : SymbolBody(LazyKind, S.getName()), File(F), Sym(S) {}
 
   static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
 
   // Returns an object file for this symbol, or a nullptr if the file
   // was already returned.
-  ErrorOr<std::unique_ptr<InputFile>> getMember();
+  std::unique_ptr<InputFile> getMember();
 
   int getFileIndex() { return File->Index; }
 
 private:
   ArchiveFile *File;
   const Archive::Symbol Sym;
 };
 

COFF/Symbols.cpp

DefinedImportThunk::DefinedImportThunk(StringRef Name, DefinedImportData *S,
   switch (Machine) {
   case AMD64: Data.reset(new ImportThunkChunkX64(S)); return;
   case I386:  Data.reset(new ImportThunkChunkX86(S)); return;
   case ARMNT: Data.reset(new ImportThunkChunkARM(S)); return;
   default:    llvm_unreachable("unknown machine type");
   }
 }
 
-ErrorOr<std::unique_ptr<InputFile>> Lazy::getMember() {
-  auto MBRefOrErr = File->getMember(&Sym);
-  if (auto EC = MBRefOrErr.getError())
-    return EC;
-  MemoryBufferRef MBRef = MBRefOrErr.get();
+std::unique_ptr<InputFile> Lazy::getMember() {
+  MemoryBufferRef MBRef = File->getMember(&Sym);
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())
     return std::unique_ptr<InputFile>(nullptr);
 
   file_magic Magic = identify_magic(MBRef.getBuffer());
   if (Magic == file_magic::coff_import_library)
     return std::unique_ptr<InputFile>(new ImportFile(MBRef));
 
   std::unique_ptr<InputFile> Obj;
-  if (Magic == file_magic::coff_object) {
+  if (Magic == file_magic::coff_object)
     Obj.reset(new ObjectFile(MBRef));
-  } else if (Magic == file_magic::bitcode) {
+  else if (Magic == file_magic::bitcode)
     Obj.reset(new BitcodeFile(MBRef));
-  } else {
-    llvm::errs() << File->getName() << ": unknown file type\n";
-    return make_error_code(LLDError::InvalidFile);
-  }
+  else
+    error(Twine(File->getName()) + ": unknown file type");
 
   Obj->setParentName(File->getName());
-  return std::move(Obj);
+  return Obj;
 }
 
 Defined *Undefined::getWeakAlias() {
   // A weak alias may be a weak alias to another symbol, so check recursively.
   for (SymbolBody *A = WeakAlias; A; A = cast<Undefined>(A)->WeakAlias)
     if (auto *D = dyn_cast<Defined>(A->repl()))
       return D;
   return nullptr;
 }
 
 } // namespace coff
 } // namespace lld

COFF/Writer.h

 #include <vector>
 
 namespace lld {
 namespace coff {
 
 class Chunk;
 class OutputSection;
 
-std::error_code writeResult(SymbolTable *T);
+void writeResult(SymbolTable *T);
 
 // Implemented in ICF.cpp.
 void doICF(const std::vector<Chunk *> &Chunks);
 
 }
 }
 
 #endif

COFF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Config.h"
 #include "DLL.h"
+#include "Error.h"
 #include "InputFiles.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"

 static const int DOSStubSize = 64;
 static const int NumberfOfDataDirectory = 16;
 
 namespace {
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
   Writer(SymbolTable *T) : Symtab(T) {}
-  std::error_code run();
+  void run();
 
 private:
   void markLive();
   void dedupCOMDATs();
   void createSections();
   void createMiscChunks();
   void createImportTables();
   void createExportTable();
   void assignAddresses();
   void removeEmptySections();
   void createSymbolAndStringTable();
-  std::error_code openFile(StringRef OutputPath);
+  void openFile(StringRef OutputPath);
   template <typename PEHeaderTy> void writeHeader();
   void fixSafeSEHSymbols();
   void writeSections();
   void sortExceptionTable();
   void applyRelocations();
 
   llvm::Optional<coff_symbol16> createSymbol(Defined *D);
   size_t addEntryToStringTable(StringRef Str);
private:
 
   std::vector<std::unique_ptr<Chunk>> Chunks;
 };
 } // anonymous namespace
 
 namespace lld {
 namespace coff {
 
-std::error_code writeResult(SymbolTable *T) { return Writer(T).run(); }
+void writeResult(SymbolTable *T) { Writer(T).run(); }
 
 // OutputSection represents a section in an output file. It's a
 // container of chunks. OutputSection and Chunk are 1:N relationship.
 // Chunks cannot belong to more than one OutputSections. The writer
 // creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and RVAs.
 class OutputSection {
 public:
if (StringTableOff) {
     strncpy(Hdr->Name, Name.data(),
             std::min(Name.size(), (size_t)COFF::NameSize));
   }
 }
 
 uint64_t Defined::getSecrel() {
   if (auto *D = dyn_cast<DefinedRegular>(this))
     return getRVA() - D->getChunk()->getOutputSection()->getRVA();
-  llvm::report_fatal_error("SECREL relocation points to a non-regular symbol");
+  error("SECREL relocation points to a non-regular symbol");
 }
 
 uint64_t Defined::getSectionIndex() {
   if (auto *D = dyn_cast<DefinedRegular>(this))
     return D->getChunk()->getOutputSection()->SectionIndex;
-  llvm::report_fatal_error("SECTION relocation points to a non-regular symbol");
+  error("SECTION relocation points to a non-regular symbol");
 }
 
 bool Defined::isExecutable() {
   const auto X = IMAGE_SCN_MEM_EXECUTE;
   if (auto *D = dyn_cast<DefinedRegular>(this))
     return D->getChunk()->getOutputSection()->getPermissions() & X;
   return isa<DefinedImportThunk>(this);
 }
 
 } // namespace coff
 } // namespace lld
 
 // The main function of the writer.
-std::error_code Writer::run() {
+void Writer::run() {
   markLive();
   dedupCOMDATs();
   createSections();
   createMiscChunks();
   createImportTables();
   createExportTable();
   if (Config->Relocatable)
     createSection(".reloc");
   assignAddresses();
   removeEmptySections();
   createSymbolAndStringTable();
-  if (auto EC = openFile(Config->OutputFile))
-    return EC;
+  openFile(Config->OutputFile);
   if (Config->is64()) {
     writeHeader<pe32plus_header>();
   } else {
     writeHeader<pe32_header>();
   }
   fixSafeSEHSymbols();
   writeSections();
   sortExceptionTable();
-  return Buffer->commit();
+  error(Buffer->commit(), "Failed to write the output file");
 }
 
 // Set live bit on for each reachable chunk. Unmarked (unreachable)
 // COMDAT chunks will be ignored in the next step, so that they don't
 // come to the final output file.
 void Writer::markLive() {
   if (!Config->DoGC)
     return;
for (size_t I = 0; I != NumberOfSymbols; ++I)
     SymbolTable[I] = OutputSymtab[I];
   // Create the string table, it follows immediately after the symbol table.
   // The first 4 bytes is length including itself.
   Buf = reinterpret_cast<uint8_t *>(&SymbolTable[NumberOfSymbols]);
   write32le(Buf, Strtab.size() + 4);
   memcpy(Buf + 4, Strtab.data(), Strtab.size());
 }
 
-std::error_code Writer::openFile(StringRef Path) {
-  if (auto EC = FileOutputBuffer::create(Path, FileSize, Buffer,
-                                         FileOutputBuffer::F_executable)) {
-    llvm::errs() << "failed to open " << Path << ": " << EC.message() << "\n";
-    return EC;
-  }
-  return std::error_code();
+void Writer::openFile(StringRef Path) {
+  std::error_code EC = FileOutputBuffer::create(Path, FileSize, Buffer,
+                                                FileOutputBuffer::F_executable);
+  error(EC, Twine("failed to open ") + Path);
 }
 
 void Writer::fixSafeSEHSymbols() {
   if (!SEHTable)
     return;
   Config->SEHTable->setRVA(SEHTable->getRVA());
   Config->SEHCount->setVA(SEHTable->getSize() / 4);
 }

include/lld/Driver/Driver.h

public:
   }
 
 private:
   WinLinkDriver() = delete;
 };
 
 /// Driver for Windows 'link.exe' command line options
 namespace coff {
-bool link(llvm::ArrayRef<const char *> args);
+void link(llvm::ArrayRef<const char *> args);
 }
 
 namespace elf2 {
 void link(llvm::ArrayRef<const char *> args);
 }
 
 /// Driver for lld unit tests
 class CoreDriver : public Driver {

lib/Driver/UniversalDriver.cpp

bool UniversalDriver::link(llvm::MutableArrayRef<const char *> args,
   case Flavor::gnu_ld2:
     elf2::link(args);
     return true;
   case Flavor::darwin_ld:
     return DarwinLdDriver::linkMachO(args, diagnostics);
   case Flavor::win_link:
     return WinLinkDriver::linkPECOFF(args, diagnostics);
   case Flavor::win_link2:
-    return coff::link(args);
+    coff::link(args);
+    return true;
   case Flavor::core:
     return CoreDriver::link(args, diagnostics);
   case Flavor::invalid:
     diagnostics << "Select the appropriate flavor\n";
     table.PrintHelp(llvm::outs(), programName.data(), "LLVM Linker", false);
     return false;
   }
   llvm_unreachable("Unrecognised flavor");
 }
 
 } // end namespace lld