[Darwin] Use errorHandler from liblldCommon

[modocache]

Summary

Error handling in liblldCore and the Darwin toolchain prints to an
output stream. A TODO in the project explained that a diagnostics
interface resembling Clang's should be added.

For now, the simple diagnostics interface defined in liblldCommon seems
like an improvement. It prints colors when they're available, uses locks
for thread-safety, and abstracts away the "error: " and newline
literal strings that litter the Darwin toolchain code.

To use the liblldCommon error handler, a link dependency is added to
the liblldDriver library.

Test Plan:

1. check-lld
2. Invoke ld64.lld -r in a terminal that supports color output. Confirm that "ld64.lld: error: -arch not specified and could not be inferred" is output, and that the "error:" is colored red!

[modocache]

Oops! I fixed a typo in the error limit exceeded message.

[smeenai]

Makes sense to me, but I want @ruiu to look over it.

lib/Driver/DarwinLdDriver.cpp

327

Do you need the explicit Twine constructor calls?

[ruiu]

LGTM

Thank you for doing this. Though we probably should discuss the future plan at some point, this seems like a pure improvement to me.

[modocache]

Thanks for the reviews! I'm updating this so that it no longer includes the warning I added in D47994. I'll commit in in a second.

include/lld/Common/Driver.h

 }
 
 namespace elf {
 bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 
 namespace mach_o {
-bool link(llvm::ArrayRef<const char *> Args,
+bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 
 namespace wasm {
 bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 }
 
 #endif

include/lld/Core/LinkingContext.h

 #define LLD_CORE_LINKING_CONTEXT_H
 
 #include "lld/Core/Node.h"
 #include "lld/Core/Reader.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace lld {
 
public:
   /// linker command line, using the -u option.
   ArrayRef<StringRef> initialUndefinedSymbols() const {
     return _initialUndefinedSymbols;
   }
 
   /// After all set* methods are called, the Driver calls this method
   /// to validate that there are no missing options or invalid combinations
   /// of options.  If there is a problem, a description of the problem
-  /// is written to the supplied stream.
+  /// is written to the global error handler.
   ///
   /// \returns true if there is an error with the current settings.
-  bool validate(raw_ostream &diagnostics);
+  bool validate();
 
   /// Formats symbol name for use in error messages.
   virtual std::string demangle(StringRef symbolName) const = 0;
 
   /// @}
   /// \name Methods used by Driver::link()
   /// @{
 
protected:
   StringRefVector _initialUndefinedSymbols;
   std::vector<std::unique_ptr<Node>> _nodes;
   mutable llvm::BumpPtrAllocator _allocator;
   mutable uint64_t _nextOrdinal = 0;
   Registry _registry;
 
 private:
   /// Validate the subclass bits. Only called by validate.
-  virtual bool validateImpl(raw_ostream &diagnostics) = 0;
+  virtual bool validateImpl() = 0;
 };
 
 } // end namespace lld
 
 #endif // LLD_CORE_LINKING_CONTEXT_H

include/lld/Core/TODO.txt

 include/lld/Core
 ~~~~~~~~~~~~~~~~
 
 * The yaml reader/writer interfaces should be changed to return
   an explanatory string if there is an error.  The existing error_code
   abstraction only works for returning low level OS errors.  It does not
   work for describing formatting issues.
 
-* We need to design a diagnostics interface.  It would be nice to share code
-  with Clang_ where possible.
-
 * We need to add more attributes to File.  In particular, we need cpu
   and OS information (like target triples).  We should also provide explicit
   support for `LLVM IR module flags metadata`__.
 
 .. __: http://llvm.org/docs/LangRef.html#module_flags
 .. _Clang: http://clang.llvm.org/docs/InternalsManual.html#Diagnostics

include/lld/ReaderWriter/MachOLinkingContext.h

public:
 
   /// Initializes the context to sane default values given the specified output
   /// file type, arch, os, and minimum os version.  This should be called before
   /// other setXXX() methods.
   void configure(HeaderFileType type, Arch arch, OS os, uint32_t minOSVersion,
                  bool exportDynamicSymbols);
 
   void addPasses(PassManager &pm) override;
-  bool validateImpl(raw_ostream &diagnostics) override;
+  bool validateImpl() override;
   std::string demangle(StringRef symbolName) const override;
 
   void createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   /// Creates a new file which is owned by the context.  Returns a pointer to
   /// the new file.
   template <class T, class... Args>
   typename std::enable_if<!std::is_array<T>::value, T *>::type

lib/Core/LinkingContext.cpp

 #include <algorithm>
 
 namespace lld {
 
 LinkingContext::LinkingContext() = default;
 
 LinkingContext::~LinkingContext() = default;
 
-bool LinkingContext::validate(raw_ostream &diagnostics) {
-  return validateImpl(diagnostics);
+bool LinkingContext::validate() {
+  return validateImpl();
 }
 
 llvm::Error LinkingContext::writeFile(const File &linkedFile) const {
   return this->writer().writeFile(linkedFile, _outputPath);
 }
 
 std::unique_ptr<File> LinkingContext::createEntrySymbolFile() const {
   return createEntrySymbolFile("<command line option -e>");

lib/Driver/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS DarwinLdOptions.td)
 tablegen(LLVM DarwinLdOptions.inc -gen-opt-parser-defs)
 add_public_tablegen_target(DriverOptionsTableGen)
 
 add_lld_library(lldDriver
   DarwinLdDriver.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLD_INCLUDE_DIR}/lld/Driver
 
   LINK_COMPONENTS
     Option
     Support
 
   LINK_LIBS
+    lldCommon
     lldCore
     lldMachO
     lldReaderWriter
     lldYAML
   )
 
 add_dependencies(lldDriver DriverOptionsTableGen)

lib/Driver/DarwinLdDriver.cpp

 //===- lib/Driver/DarwinLdDriver.cpp --------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// Concrete instance of the Driver for darwin's ld.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "lld/Common/Args.h"
+#include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Instrumentation.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Node.h"
 #include "lld/Core/PassManager.h"
if (auto *archive = dyn_cast<ArchiveLibraryFile>(file.get())) {
     if (std::error_code ec = archive->parseAllMembers(members))
       return makeErrorFile(file->path(), ec);
   } else {
     members.push_back(std::move(file));
   }
   return members;
 }
 
-std::vector<std::unique_ptr<File>>
-loadFile(MachOLinkingContext &ctx, StringRef path,
-         raw_ostream &diag, bool wholeArchive, bool upwardDylib) {
+std::vector<std::unique_ptr<File>> loadFile(MachOLinkingContext &ctx,
+                                            StringRef path, bool wholeArchive,
+                                            bool upwardDylib) {
   if (ctx.logInputFiles())
-    diag << path << "\n";
+    message(path);
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = ctx.getMemoryBuffer(path);
   if (std::error_code ec = mbOrErr.getError())
     return makeErrorFile(path, ec);
   ErrorOr<std::unique_ptr<File>> fileOrErr =
       ctx.registry().loadFile(std::move(mbOrErr.get()));
   if (std::error_code ec = fileOrErr.getError())
     return makeErrorFile(path, ec);
if (sep != '/') {
     std::replace(fixedPath.begin(), fixedPath.end(), sep, '/');
     return fixedPath;
   } else {
     return path;
   }
 }
 
 static void addFile(StringRef path, MachOLinkingContext &ctx,
-                    bool loadWholeArchive,
-                    bool upwardDylib, raw_ostream &diag) {
+                    bool loadWholeArchive, bool upwardDylib) {
   std::vector<std::unique_ptr<File>> files =
-      loadFile(ctx, path, diag, loadWholeArchive, upwardDylib);
+      loadFile(ctx, path, loadWholeArchive, upwardDylib);
   for (std::unique_ptr<File> &file : files)
     ctx.getNodes().push_back(llvm::make_unique<FileNode>(std::move(file)));
 }
 
 // Export lists are one symbol per line.  Blank lines are ignored.
 // Trailing comments start with #.
 static std::error_code parseExportsList(StringRef exportFilePath,
-                                        MachOLinkingContext &ctx,
-                                        raw_ostream &diagnostics) {
+                                        MachOLinkingContext &ctx) {
   // Map in export list file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                    MemoryBuffer::getFileOrSTDIN(exportFilePath);
   if (std::error_code ec = mb.getError())
     return ec;
   ctx.addInputFileDependency(exportFilePath);
   StringRef buffer = mb->get()->getBuffer();
   while (!buffer.empty()) {

 /// Order files are one symbol per line. Blank lines are ignored.
 /// Trailing comments start with #. Symbol names can be prefixed with an
 /// architecture name and/or .o leaf name.  Examples:
 ///     _foo
 ///     bar.o:_bar
 ///     libfrob.a(bar.o):_bar
 ///     x86_64:_foo64
 static std::error_code parseOrderFile(StringRef orderFilePath,
-                                      MachOLinkingContext &ctx,
-                                      raw_ostream &diagnostics) {
+                                      MachOLinkingContext &ctx) {
   // Map in order file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                    MemoryBuffer::getFileOrSTDIN(orderFilePath);
   if (std::error_code ec = mb.getError())
     return ec;
   ctx.addInputFileDependency(orderFilePath);
   StringRef buffer = mb->get()->getBuffer();
   while (!buffer.empty()) {

 // In this variant, the path is to a text file which contains one file path
 // per line.  There are no comments or trimming of whitespace.
 //
 //   -fileList <path>,<dir>
 // In this variant, the path is to a text file which contains a partial path
 // per line. The <dir> prefix is prepended to each partial path.
 //
 static llvm::Error loadFileList(StringRef fileListPath,
-                                MachOLinkingContext &ctx, bool forceLoad,
-                                raw_ostream &diagnostics) {
+                                MachOLinkingContext &ctx, bool forceLoad) {
   // If there is a comma, split off <dir>.
   std::pair<StringRef, StringRef> opt = fileListPath.split(',');
   StringRef filePath = opt.first;
   StringRef dirName = opt.second;
   ctx.addInputFileDependency(filePath);
   // Map in file list file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> mb =
                                         MemoryBuffer::getFileOrSTDIN(filePath);
if (!dirName.empty()) {
       path = ctx.copy(line);
     }
     if (!ctx.pathExists(path)) {
       return llvm::make_error<GenericError>(Twine("File not found '")
                                             + path
                                             + "'");
     }
     if (ctx.testingFileUsage()) {
-      diagnostics << "Found filelist entry " << canonicalizePath(path) << '\n';
+      message("Found filelist entry " + canonicalizePath(path));
     }
-    addFile(path, ctx, forceLoad, false, diagnostics);
+    addFile(path, ctx, forceLoad, false);
     buffer = lineAndRest.second;
   }
   return llvm::Error::success();
 }
 
 /// Parse number assuming it is base 16, but allow 0x prefix.
 static bool parseNumberBase16(StringRef numStr, uint64_t &baseAddress) {
   if (numStr.startswith_lower("0x"))
if (!ctx.llvmOptions().empty()) {
     args[numArgs + 1] = nullptr;
     llvm::cl::ParseCommandLineOptions(numArgs + 1, args);
   }
 }
 
 namespace lld {
 namespace mach_o {
 
-bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx,
-           raw_ostream &diagnostics) {
+bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx) {
   // Parse command line options using DarwinLdOptions.td
   DarwinLdOptTable table;
   unsigned missingIndex;
   unsigned missingCount;
   llvm::opt::InputArgList parsedArgs =
       table.ParseArgs(args.slice(1), missingIndex, missingCount);
   if (missingCount) {
-    diagnostics << "error: missing arg value for '"
-                << parsedArgs.getArgString(missingIndex) << "' expected "
-                << missingCount << " argument(s).\n";
+    error("missing arg value for '" +
+          Twine(parsedArgs.getArgString(missingIndex)) + "' expected " +
+          Twine(missingCount) + " argument(s).");
     return false;
   }
 
   for (auto unknownArg : parsedArgs.filtered(OPT_UNKNOWN)) {
-    diagnostics << "warning: ignoring unknown argument: "
-                << unknownArg->getAsString(parsedArgs) << "\n";
+    warn("ignoring unknown argument: " +
+         Twine(unknownArg->getAsString(parsedArgs)));
   }
 
+  errorHandler().Verbose = parsedArgs.hasArg(OPT_v);
+  errorHandler().ErrorLimit = args::getInteger(parsedArgs, OPT_error_limit, 20);
+
   // Figure out output kind ( -dylib, -r, -bundle, -preload, or -static )
   llvm::MachO::HeaderFileType fileType = llvm::MachO::MH_EXECUTE;
   bool isStaticExecutable = false;
   if (llvm::opt::Arg *kind = parsedArgs.getLastArg(
           OPT_dylib, OPT_relocatable, OPT_bundle, OPT_static, OPT_preload)) {
     switch (kind->getOption().getID()) {
     case OPT_dylib:
       fileType = llvm::MachO::MH_DYLIB;
if (llvm::opt::Arg *kind = parsedArgs.getLastArg(
     }
   }
 
   // Handle -arch xxx
   MachOLinkingContext::Arch arch = MachOLinkingContext::arch_unknown;
   if (llvm::opt::Arg *archStr = parsedArgs.getLastArg(OPT_arch)) {
     arch = MachOLinkingContext::archFromName(archStr->getValue());
     if (arch == MachOLinkingContext::arch_unknown) {
-      diagnostics << "error: unknown arch named '" << archStr->getValue()
-                  << "'\n";
+      error("unknown arch named '" + Twine(archStr->getValue()) + "'");
       return false;
     }
   }
   // If no -arch specified, scan input files to find first non-fat .o file.
   if (arch == MachOLinkingContext::arch_unknown) {
     for (auto &inFile : parsedArgs.filtered(OPT_INPUT)) {
       // This is expensive because it opens and maps the file.  But that is
       // ok because no -arch is rare.
       if (MachOLinkingContext::isThinObjectFile(inFile->getValue(), arch))
         break;
     }
     if (arch == MachOLinkingContext::arch_unknown &&
         !parsedArgs.getLastArg(OPT_test_file_usage)) {
       // If no -arch and no options at all, print usage message.
       if (parsedArgs.size() == 0)
         table.PrintHelp(llvm::outs(), args[0], "LLVM Linker", false);
       else
-        diagnostics << "error: -arch not specified and could not be inferred\n";
+        error("-arch not specified and could not be inferred");
       return false;
     }
   }
 
   // Handle -macosx_version_min or -ios_version_min
   MachOLinkingContext::OS os = MachOLinkingContext::OS::unknown;
   uint32_t minOSVersion = 0;
   if (llvm::opt::Arg *minOS =
           parsedArgs.getLastArg(OPT_macosx_version_min, OPT_ios_version_min,
                                 OPT_ios_simulator_version_min)) {
     switch (minOS->getOption().getID()) {
     case OPT_macosx_version_min:
       os = MachOLinkingContext::OS::macOSX;
       if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
                                                   minOSVersion)) {
-        diagnostics << "error: malformed macosx_version_min value\n";
+        error("malformed macosx_version_min value");
         return false;
       }
       break;
     case OPT_ios_version_min:
       os = MachOLinkingContext::OS::iOS;
       if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
                                                   minOSVersion)) {
-        diagnostics << "error: malformed ios_version_min value\n";
+        error("malformed ios_version_min value");
         return false;
       }
       break;
     case OPT_ios_simulator_version_min:
       os = MachOLinkingContext::OS::iOS_simulator;
       if (MachOLinkingContext::parsePackedVersion(minOS->getValue(),
                                                   minOSVersion)) {
-        diagnostics << "error: malformed ios_simulator_version_min value\n";
+        error("malformed ios_simulator_version_min value");
         return false;
       }
       break;
     }
   } else {
     // No min-os version on command line, check environment variables
   }
 
if (llvm::opt::Arg *outpath = parsedArgs.getLastArg(OPT_output))
     ctx.setOutputPath(outpath->getValue());
   else
     ctx.setOutputPath("a.out");
 
   // Handle -image_base XXX and -seg1addr XXXX
   if (llvm::opt::Arg *imageBase = parsedArgs.getLastArg(OPT_image_base)) {
     uint64_t baseAddress;
     if (parseNumberBase16(imageBase->getValue(), baseAddress)) {
-      diagnostics << "error: image_base expects a hex number\n";
+      error("image_base expects a hex number");
       return false;
     } else if (baseAddress < ctx.pageZeroSize()) {
-      diagnostics << "error: image_base overlaps with __PAGEZERO\n";
+      error("image_base overlaps with __PAGEZERO");
       return false;
     } else if (baseAddress % ctx.pageSize()) {
-      diagnostics << "error: image_base must be a multiple of page size ("
-                  << "0x" << llvm::utohexstr(ctx.pageSize()) << ")\n";
+      error("image_base must be a multiple of page size (0x" +
+            llvm::utohexstr(ctx.pageSize()) + ")");
       return false;
     }
 
     ctx.setBaseAddress(baseAddress);
   }
 
   // Handle -dead_strip
   if (parsedArgs.getLastArg(OPT_dead_strip))
bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx) {
 
   // Handle -mark_dead_strippable_dylib
   if (parsedArgs.getLastArg(OPT_mark_dead_strippable_dylib))
     ctx.setDeadStrippableDylib(true);
 
   // Handle -compatibility_version and -current_version
   if (llvm::opt::Arg *vers = parsedArgs.getLastArg(OPT_compatibility_version)) {
     if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB) {
-      diagnostics
-          << "error: -compatibility_version can only be used with -dylib\n";
+      error("-compatibility_version can only be used with -dylib");
       return false;
     }
     uint32_t parsedVers;
     if (MachOLinkingContext::parsePackedVersion(vers->getValue(), parsedVers)) {
-      diagnostics << "error: -compatibility_version value is malformed\n";
+      error("-compatibility_version value is malformed");
       return false;
     }
     ctx.setCompatibilityVersion(parsedVers);
   }
 
   if (llvm::opt::Arg *vers = parsedArgs.getLastArg(OPT_current_version)) {
     if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB) {
-      diagnostics << "-current_version can only be used with -dylib\n";
+      error("-current_version can only be used with -dylib");
       return false;
     }
     uint32_t parsedVers;
     if (MachOLinkingContext::parsePackedVersion(vers->getValue(), parsedVers)) {
-      diagnostics << "error: -current_version value is malformed\n";
+      error("-current_version value is malformed");
       return false;
     }
     ctx.setCurrentVersion(parsedVers);
   }
 
   // Handle -bundle_loader
   if (llvm::opt::Arg *loader = parsedArgs.getLastArg(OPT_bundle_loader))
     ctx.setBundleLoader(loader->getValue());
 
   // Handle -sectalign segname sectname align
   for (auto &alignArg : parsedArgs.filtered(OPT_sectalign)) {
     const char* segName   = alignArg->getValue(0);
     const char* sectName  = alignArg->getValue(1);
     const char* alignStr  = alignArg->getValue(2);
     if ((alignStr[0] == '0') && (alignStr[1] == 'x'))
       alignStr += 2;
     unsigned long long alignValue;
     if (llvm::getAsUnsignedInteger(alignStr, 16, alignValue)) {
-      diagnostics << "error: -sectalign alignment value '"
-                  << alignStr << "' not a valid number\n";
+      error("-sectalign alignment value '" + Twine(alignStr) +
+            "' not a valid number");
       return false;
     }
     uint16_t align = 1 << llvm::countTrailingZeros(alignValue);
     if (!llvm::isPowerOf2_64(alignValue)) {
-      diagnostics << "warning: alignment for '-sectalign "
-                  << segName << " " << sectName
-                  << llvm::format(" 0x%llX", alignValue)
-                  << "' is not a power of two, using "
-                  << llvm::format("0x%08X", align) << "\n";
+      std::string Msg;
+      llvm::raw_string_ostream OS(Msg);
+      OS << "alignment for '-sectalign " << segName << " " << sectName
+         << "' is not a power of two, using " << llvm::format("0x%08X", align);
+      OS.flush();
+      warn(Msg);
     }
     ctx.addSectionAlignment(segName, sectName, align);
   }
 
   // Handle -mllvm
   for (auto &llvmArg : parsedArgs.filtered(OPT_mllvm)) {
     ctx.appendLLVMOption(llvmArg->getValue());
   }
bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx) {
   // Handle -demangle option.
   if (parsedArgs.getLastArg(OPT_demangle))
     ctx.setDemangleSymbols(true);
 
   // Handle -keep_private_externs
   if (parsedArgs.getLastArg(OPT_keep_private_externs)) {
     ctx.setKeepPrivateExterns(true);
     if (ctx.outputMachOType() != llvm::MachO::MH_OBJECT)
-      diagnostics << "warning: -keep_private_externs only used in -r mode\n";
+      warn("-keep_private_externs only used in -r mode");
   }
 
   // Handle -dependency_info <path> used by Xcode.
-  if (llvm::opt::Arg *depInfo = parsedArgs.getLastArg(OPT_dependency_info)) {
-    if (std::error_code ec = ctx.createDependencyFile(depInfo->getValue())) {
-      diagnostics << "warning: " << ec.message()
-                  << ", processing '-dependency_info "
-                  << depInfo->getValue()
-                  << "'\n";
-    }
-  }
+  if (llvm::opt::Arg *depInfo = parsedArgs.getLastArg(OPT_dependency_info))
+    if (std::error_code ec = ctx.createDependencyFile(depInfo->getValue()))
+      warn(ec.message() + ", processing '-dependency_info " +
+           depInfo->getValue());
 
   // In -test_file_usage mode, we'll be given an explicit list of paths that
   // exist. We'll also be expected to print out information about how we located
   // libraries and so on that the user specified, but not to actually do any
   // linking.
   if (parsedArgs.getLastArg(OPT_test_file_usage)) {
     ctx.setTestingFileUsage();
 
if (!parsedArgs.hasArg(OPT_Z)) {
     ctx.addModifiedSearchDir("/usr/lib", true);
     ctx.addModifiedSearchDir("/usr/local/lib", true);
     ctx.addFrameworkSearchDir("/Library/Frameworks", true);
     ctx.addFrameworkSearchDir("/System/Library/Frameworks", true);
   }
 
   // Now that we've constructed the final set of search paths, print out those
   // search paths in verbose mode.
-  if (parsedArgs.getLastArg(OPT_v)) {
-    diagnostics << "Library search paths:\n";
+  if (errorHandler().Verbose) {
+    message("Library search paths:");
     for (auto path : ctx.searchDirs()) {
-      diagnostics << "    " << path << '\n';
+      message("    " + path);
     }
-    diagnostics << "Framework search paths:\n";
+    message("Framework search paths:");
     for (auto path : ctx.frameworkDirs()) {
-      diagnostics << "    " << path << '\n';
+      message("    " + path);
     }
   }
 
   // Handle -exported_symbols_list <file>
   for (auto expFile : parsedArgs.filtered(OPT_exported_symbols_list)) {
     if (ctx.exportMode() == MachOLinkingContext::ExportMode::blackList) {
-      diagnostics << "error: -exported_symbols_list cannot be combined "
-                  << "with -unexported_symbol[s_list]\n";
-       return false;
+      error("-exported_symbols_list cannot be combined with "
+            "-unexported_symbol[s_list]");
     }
     ctx.setExportMode(MachOLinkingContext::ExportMode::whiteList);
-    if (std::error_code ec = parseExportsList(expFile->getValue(), ctx,
-                                              diagnostics)) {
-      diagnostics << "error: " << ec.message()
-                  << ", processing '-exported_symbols_list "
-                  << expFile->getValue()
-                  << "'\n";
+    if (std::error_code ec = parseExportsList(expFile->getValue(), ctx)) {
+      error(ec.message() + ", processing '-exported_symbols_list " +
+            expFile->getValue());
       return false;
     }
   }
 
   // Handle -exported_symbol <symbol>
   for (auto symbol : parsedArgs.filtered(OPT_exported_symbol)) {
     if (ctx.exportMode() == MachOLinkingContext::ExportMode::blackList) {
-      diagnostics << "error: -exported_symbol cannot be combined "
-                  << "with -unexported_symbol[s_list]\n";
-       return false;
+      error("-exported_symbol cannot be combined with "
+            "-unexported_symbol[s_list]");
     }
     ctx.setExportMode(MachOLinkingContext::ExportMode::whiteList);
     ctx.addExportSymbol(symbol->getValue());
   }
 
   // Handle -unexported_symbols_list <file>
   for (auto expFile : parsedArgs.filtered(OPT_unexported_symbols_list)) {
     if (ctx.exportMode() == MachOLinkingContext::ExportMode::whiteList) {
-      diagnostics << "error: -unexported_symbols_list cannot be combined "
-                  << "with -exported_symbol[s_list]\n";
-       return false;
+      error("-unexported_symbols_list cannot be combined with "
+            "-exported_symbol[s_list]");
     }
     ctx.setExportMode(MachOLinkingContext::ExportMode::blackList);
-    if (std::error_code ec = parseExportsList(expFile->getValue(), ctx,
-                                              diagnostics)) {
-      diagnostics << "error: " << ec.message()
-                  << ", processing '-unexported_symbols_list "
-                  << expFile->getValue()
-                  << "'\n";
+    if (std::error_code ec = parseExportsList(expFile->getValue(), ctx)) {
+      error(ec.message() + ", processing '-unexported_symbols_list " +
+            expFile->getValue());
       return false;
     }
   }
 
   // Handle -unexported_symbol <symbol>
   for (auto symbol : parsedArgs.filtered(OPT_unexported_symbol)) {
     if (ctx.exportMode() == MachOLinkingContext::ExportMode::whiteList) {
-      diagnostics << "error: -unexported_symbol cannot be combined "
-                  << "with -exported_symbol[s_list]\n";
-       return false;
+      error("-unexported_symbol cannot be combined with "
+            "-exported_symbol[s_list]");
     }
     ctx.setExportMode(MachOLinkingContext::ExportMode::blackList);
     ctx.addExportSymbol(symbol->getValue());
   }
 
   // Handle obosolete -multi_module and -single_module
   if (llvm::opt::Arg *mod =
           parsedArgs.getLastArg(OPT_multi_module, OPT_single_module)) {
-    if (mod->getOption().getID() == OPT_multi_module) {
-      diagnostics << "warning: -multi_module is obsolete and being ignored\n";
-    }
-    else {
-      if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB) {
-        diagnostics << "warning: -single_module being ignored. "
-                       "It is only for use when producing a dylib\n";
-      }
-    }
+    if (mod->getOption().getID() == OPT_multi_module)
+      warn("-multi_module is obsolete and being ignored");
+    else if (ctx.outputMachOType() != llvm::MachO::MH_DYLIB)
+      warn("-single_module being ignored. It is only for use when producing a "
+           "dylib");
   }
 
   // Handle obsolete ObjC options: -objc_gc_compaction, -objc_gc, -objc_gc_only
   if (parsedArgs.getLastArg(OPT_objc_gc_compaction)) {
-    diagnostics << "error: -objc_gc_compaction is not supported\n";
+    error("-objc_gc_compaction is not supported");
     return false;
   }
 
   if (parsedArgs.getLastArg(OPT_objc_gc)) {
-    diagnostics << "error: -objc_gc is not supported\n";
+    error("-objc_gc is not supported");
     return false;
   }
 
   if (parsedArgs.getLastArg(OPT_objc_gc_only)) {
-    diagnostics << "error: -objc_gc_only is not supported\n";
+    error("-objc_gc_only is not supported");
     return false;
   }
 
   // Handle -pie or -no_pie
   if (llvm::opt::Arg *pie = parsedArgs.getLastArg(OPT_pie, OPT_no_pie)) {
     switch (ctx.outputMachOType()) {
     case llvm::MachO::MH_EXECUTE:
       switch (ctx.os()) {
       case MachOLinkingContext::OS::macOSX:
         if ((minOSVersion < 0x000A0500) &&
             (pie->getOption().getID() == OPT_pie)) {
-          diagnostics << "-pie can only be used when targeting "
-                         "Mac OS X 10.5 or later\n";
+          error("-pie can only be used when targeting Mac OS X 10.5 or later");
           return false;
         }
         break;
       case MachOLinkingContext::OS::iOS:
         if ((minOSVersion < 0x00040200) &&
             (pie->getOption().getID() == OPT_pie)) {
-          diagnostics << "-pie can only be used when targeting "
-                         "iOS 4.2 or later\n";
+          error("-pie can only be used when targeting iOS 4.2 or later");
           return false;
         }
         break;
       case MachOLinkingContext::OS::iOS_simulator:
         if (pie->getOption().getID() == OPT_no_pie) {
-          diagnostics << "iOS simulator programs must be built PIE\n";
+          error("iOS simulator programs must be built PIE");
           return false;
         }
         break;
       case MachOLinkingContext::OS::unknown:
         break;
       }
       ctx.setPIE(pie->getOption().getID() == OPT_pie);
       break;
     case llvm::MachO::MH_PRELOAD:
       break;
     case llvm::MachO::MH_DYLIB:
     case llvm::MachO::MH_BUNDLE:
-      diagnostics << "warning: " << pie->getSpelling() << " being ignored. "
-                  << "It is only used when linking main executables\n";
+      warn(pie->getSpelling() +
+           " being ignored. It is only used when linking main executables");
       break;
     default:
-      diagnostics << pie->getSpelling()
-                  << " can only used when linking main executables\n";
+      error(pie->getSpelling() +
+            " can only used when linking main executables");
       return false;
     }
   }
 
   // Handle -version_load_command or -no_version_load_command
   {
     bool flagOn = false;
     bool flagOff = false;
// Handle -data_in_code_info or -no_data_in_code_info
     }
   }
 
   // Handle sdk_version
   if (llvm::opt::Arg *arg = parsedArgs.getLastArg(OPT_sdk_version)) {
     uint32_t sdkVersion = 0;
     if (MachOLinkingContext::parsePackedVersion(arg->getValue(),
                                                 sdkVersion)) {
-      diagnostics << "error: malformed sdkVersion value\n";
+      error("malformed sdkVersion value");
       return false;
     }
     ctx.setSdkVersion(sdkVersion);
   } else if (ctx.generateVersionLoadCommand()) {
     // If we don't have an sdk version, but were going to emit a load command
     // with min_version, then we need to give an warning as we have no sdk
     // version to put in that command.
     // FIXME: We need to decide whether to make this an error.
-    diagnostics << "warning: -sdk_version is required when emitting "
-                   "min version load command.  "
-                   "Setting sdk version to match provided min version\n";
+    warn("-sdk_version is required when emitting min version load command.  "
+         "Setting sdk version to match provided min version");
     ctx.setSdkVersion(ctx.osMinVersion());
   }
 
   // Handle source_version
   if (llvm::opt::Arg *arg = parsedArgs.getLastArg(OPT_source_version)) {
     uint64_t version = 0;
     if (MachOLinkingContext::parsePackedVersion(arg->getValue(),
                                                 version)) {
-      diagnostics << "error: malformed source_version value\n";
+      error("malformed source_version value");
       return false;
     }
     ctx.setSourceVersion(version);
   }
 
   // Handle stack_size
   if (llvm::opt::Arg *stackSize = parsedArgs.getLastArg(OPT_stack_size)) {
     uint64_t stackSizeVal;
     if (parseNumberBase16(stackSize->getValue(), stackSizeVal)) {
-      diagnostics << "error: stack_size expects a hex number\n";
+      error("stack_size expects a hex number");
       return false;
     }
     if ((stackSizeVal % ctx.pageSize()) != 0) {
-      diagnostics << "error: stack_size must be a multiple of page size ("
-                  << "0x" << llvm::utohexstr(ctx.pageSize()) << ")\n";
+      error("stack_size must be a multiple of page size (0x" +
+            llvm::utohexstr(ctx.pageSize()) + ")");
       return false;
     }
 
     ctx.setStackSize(stackSizeVal);
   }
 
   // Handle debug info handling options: -S
   if (parsedArgs.hasArg(OPT_S))
     ctx.setDebugInfoMode(MachOLinkingContext::DebugInfoMode::noDebugMap);
 
   // Handle -order_file <file>
   for (auto orderFile : parsedArgs.filtered(OPT_order_file)) {
-    if (std::error_code ec = parseOrderFile(orderFile->getValue(), ctx,
-                                              diagnostics)) {
-      diagnostics << "error: " << ec.message()
-                  << ", processing '-order_file "
-                  << orderFile->getValue()
-                  << "'\n";
+    if (std::error_code ec = parseOrderFile(orderFile->getValue(), ctx)) {
+      error(ec.message() + ", processing '-order_file " + orderFile->getValue()
+            + "'");
       return false;
     }
   }
 
   // Handle -flat_namespace.
   if (llvm::opt::Arg *ns =
           parsedArgs.getLastArg(OPT_flat_namespace, OPT_twolevel_namespace)) {
     if (ns->getOption().getID() == OPT_flat_namespace)
       ctx.setUseFlatNamespace(true);
   }
 
   // Handle -undefined
   if (llvm::opt::Arg *undef = parsedArgs.getLastArg(OPT_undefined)) {
     MachOLinkingContext::UndefinedMode UndefMode;
     if (StringRef(undef->getValue()).equals("error"))
       UndefMode = MachOLinkingContext::UndefinedMode::error;
     else if (StringRef(undef->getValue()).equals("warning"))
       UndefMode = MachOLinkingContext::UndefinedMode::warning;
     else if (StringRef(undef->getValue()).equals("suppress"))
       UndefMode = MachOLinkingContext::UndefinedMode::suppress;
     else if (StringRef(undef->getValue()).equals("dynamic_lookup"))
       UndefMode = MachOLinkingContext::UndefinedMode::dynamicLookup;
     else {
-      diagnostics << "error: invalid option to -undefined "
-                     "[ warning | error | suppress | dynamic_lookup ]\n";
+      error("invalid option to -undefined [ warning | error | suppress | "
+            "dynamic_lookup ]");
       return false;
     }
 
     if (ctx.useFlatNamespace()) {
       // If we're using -flat_namespace then 'warning', 'suppress' and
       // 'dynamic_lookup' are all equivalent, so map them to 'suppress'.
       if (UndefMode != MachOLinkingContext::UndefinedMode::error)
         UndefMode = MachOLinkingContext::UndefinedMode::suppress;
     } else {
       // If we're using -twolevel_namespace then 'warning' and 'suppress' are
       // illegal. Emit a diagnostic if they've been (mis)used.
       if (UndefMode == MachOLinkingContext::UndefinedMode::warning ||
           UndefMode == MachOLinkingContext::UndefinedMode::suppress) {
-        diagnostics << "error: can't use -undefined warning or suppress with "
-                       "-twolevel_namespace\n";
+        error("can't use -undefined warning or suppress with "
+              "-twolevel_namespace");
         return false;
       }
     }
 
     ctx.setUndefinedMode(UndefMode);
   }
 
   // Handle -no_objc_category_merging.
   if (parsedArgs.getLastArg(OPT_no_objc_category_merging))
     ctx.setMergeObjCCategories(false);
 
   // Handle -rpath <path>
   if (parsedArgs.hasArg(OPT_rpath)) {
     switch (ctx.outputMachOType()) {
       case llvm::MachO::MH_EXECUTE:
       case llvm::MachO::MH_DYLIB:
       case llvm::MachO::MH_BUNDLE:
         if (!ctx.minOS("10.5", "2.0")) {
-          if (ctx.os() == MachOLinkingContext::OS::macOSX) {
-            diagnostics << "error: -rpath can only be used when targeting "
-                           "OS X 10.5 or later\n";
-          } else {
-            diagnostics << "error: -rpath can only be used when targeting "
-                           "iOS 2.0 or later\n";
-          }
+          if (ctx.os() == MachOLinkingContext::OS::macOSX)
+            error("-rpath can only be used when targeting OS X 10.5 or later");
+          else
+            error("-rpath can only be used when targeting iOS 2.0 or later");
           return false;
         }
         break;
       default:
-        diagnostics << "error: -rpath can only be used when creating "
-                       "a dynamic final linked image\n";
+        error("-rpath can only be used when creating a dynamic final linked "
+              "image");
         return false;
     }
 
     for (auto rPath : parsedArgs.filtered(OPT_rpath)) {
       ctx.addRpath(rPath->getValue());
     }
   }
 
   // Parse the LLVM options before we process files in case the file handling
   // makes use of things like LLVM_DEBUG().
   parseLLVMOptions(ctx);
 
   // Handle input files and sectcreate.
   for (auto &arg : parsedArgs) {
     bool upward;
     llvm::Optional<StringRef> resolvedPath;
     switch (arg->getOption().getID()) {
     default:
       continue;
     case OPT_INPUT:
-      addFile(arg->getValue(), ctx, globalWholeArchive, false, diagnostics);
+      addFile(arg->getValue(), ctx, globalWholeArchive, false);
       break;
     case OPT_upward_library:
-      addFile(arg->getValue(), ctx, false, true, diagnostics);
+      addFile(arg->getValue(), ctx, false, true);
       break;
     case OPT_force_load:
-      addFile(arg->getValue(), ctx, true, false, diagnostics);
+      addFile(arg->getValue(), ctx, true, false);
       break;
     case OPT_l:
     case OPT_upward_l:
       upward = (arg->getOption().getID() == OPT_upward_l);
       resolvedPath = ctx.searchLibrary(arg->getValue());
       if (!resolvedPath) {
-        diagnostics << "Unable to find library for " << arg->getSpelling()
-                    << arg->getValue() << "\n";
+        error("Unable to find library for " + arg->getSpelling() +
+              arg->getValue());
         return false;
       } else if (ctx.testingFileUsage()) {
-        diagnostics << "Found " << (upward ? "upward " : " ") << "library "
-                   << canonicalizePath(resolvedPath.getValue()) << '\n';
+        message(Twine("Found ") + (upward ? "upward " : " ") + "library " +
+                canonicalizePath(resolvedPath.getValue()));
       }
-      addFile(resolvedPath.getValue(), ctx, globalWholeArchive,
-              upward, diagnostics);
+      addFile(resolvedPath.getValue(), ctx, globalWholeArchive, upward);
       break;
     case OPT_framework:
     case OPT_upward_framework:
       upward = (arg->getOption().getID() == OPT_upward_framework);
       resolvedPath = ctx.findPathForFramework(arg->getValue());
       if (!resolvedPath) {
-        diagnostics << "Unable to find framework for "
-                    << arg->getSpelling() << " " << arg->getValue() << "\n";
+        error("Unable to find framework for " + arg->getSpelling() + " " +
+              arg->getValue());
         return false;
       } else if (ctx.testingFileUsage()) {
-        diagnostics << "Found " << (upward ? "upward " : " ") << "framework "
-                    << canonicalizePath(resolvedPath.getValue()) << '\n';
+        message(Twine("Found ") + (upward ? "upward " : " ") + "framework " +
+                canonicalizePath(resolvedPath.getValue()));
       }
-      addFile(resolvedPath.getValue(), ctx, globalWholeArchive,
-              upward, diagnostics);
+      addFile(resolvedPath.getValue(), ctx, globalWholeArchive, upward);
       break;
     case OPT_filelist:
-      if (auto ec = loadFileList(arg->getValue(),
-                                 ctx, globalWholeArchive,
-                                 diagnostics)) {
+      if (auto ec = loadFileList(arg->getValue(), ctx, globalWholeArchive)) {
         handleAllErrors(std::move(ec), [&](const llvm::ErrorInfoBase &EI) {
-          diagnostics << "error: ";
-          EI.log(diagnostics);
-          diagnostics << ", processing '-filelist " << arg->getValue() << "'\n";
+          error(EI.message() + ", processing '-filelist " + arg->getValue());
         });
         return false;
       }
       break;
     case OPT_sectcreate: {
         const char* seg  = arg->getValue(0);
         const char* sect = arg->getValue(1);
         const char* fileName = arg->getValue(2);
 
         ErrorOr<std::unique_ptr<MemoryBuffer>> contentOrErr =
           MemoryBuffer::getFile(fileName);
 
         if (!contentOrErr) {
-          diagnostics << "error: can't open -sectcreate file " << fileName << "\n";
+          error("can't open -sectcreate file " + Twine(fileName));
           return false;
         }
 
         ctx.addSectCreateSection(seg, sect, std::move(*contentOrErr));
       }
       break;
     }
   }
 
   if (ctx.getNodes().empty()) {
-    diagnostics << "No input files\n";
+    error("No input files");
     return false;
   }
 
   // Validate the combination of options used.
-  return ctx.validate(diagnostics);
+  return ctx.validate();
 }
 
 static void createFiles(MachOLinkingContext &ctx, bool Implicit) {
   std::vector<std::unique_ptr<File>> Files;
   if (Implicit)
     ctx.createImplicitFiles(Files);
   else
     ctx.createInternalFiles(Files);
   for (auto i = Files.rbegin(), e = Files.rend(); i != e; ++i) {
     auto &members = ctx.getNodes();
     members.insert(members.begin(), llvm::make_unique<FileNode>(std::move(*i)));
   }
 }
 
 /// This is where the link is actually performed.
-bool link(llvm::ArrayRef<const char *> args, raw_ostream &diagnostics) {
+bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
+          raw_ostream &Error) {
+  errorHandler().LogName = args[0];
+  errorHandler().ErrorLimitExceededMsg =
+      "too many errors emitted, stopping now (use "
+      "'-error-limit 0' to see all errors)";
+  errorHandler().ErrorOS = &Error;
+  errorHandler().ExitEarly = CanExitEarly;
+  errorHandler().ColorDiagnostics = Error.has_colors();
+
   MachOLinkingContext ctx;
-  if (!parse(args, ctx, diagnostics))
+  if (!parse(args, ctx))
     return false;
   if (ctx.doNothing())
     return true;
   if (ctx.getNodes().empty())
     return false;
 
   for (std::unique_ptr<Node> &ie : ctx.getNodes())
     if (FileNode *node = dyn_cast<FileNode>(ie.get()))
bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
 
   // Run passes on linked atoms.
   ScopedTask passTask(getDefaultDomain(), "Passes");
   PassManager pm;
   ctx.addPasses(pm);
   if (auto ec = pm.runOnFile(*merged)) {
     // FIXME: This should be passed to logAllUnhandledErrors but it needs
     // to be passed a Twine instead of a string.
-    diagnostics << "Failed to run passes on file '" << ctx.outputPath()
-                << "': ";
-    logAllUnhandledErrors(std::move(ec), diagnostics, std::string());
+    *errorHandler().ErrorOS << "Failed to run passes on file '"
+                            << ctx.outputPath() << "': ";
+    logAllUnhandledErrors(std::move(ec), *errorHandler().ErrorOS,
+                          std::string());
     return false;
   }
 
   passTask.end();
 
   // Give linked atoms to Writer to generate output file.
   ScopedTask writeTask(getDefaultDomain(), "Write");
   if (auto ec = ctx.writeFile(*merged)) {
     // FIXME: This should be passed to logAllUnhandledErrors but it needs
     // to be passed a Twine instead of a string.
-    diagnostics << "Failed to write file '" << ctx.outputPath() << "': ";
-    logAllUnhandledErrors(std::move(ec), diagnostics, std::string());
+    *errorHandler().ErrorOS << "Failed to write file '" << ctx.outputPath()
+                            << "': ";
+    logAllUnhandledErrors(std::move(ec), *errorHandler().ErrorOS,
+                          std::string());
     return false;
   }
 
+  // Call exit() if we can to avoid calling destructors.
+  if (CanExitEarly)
+    exitLld(errorCount() ? 1 : 0);
+
+
   return true;
 }
 
 } // end namespace mach_o
 } // end namespace lld

lib/Driver/DarwinLdOptions.td

 def rpath : Separate<["-"], "rpath">,
      MetaVarName<"<path>">,
      HelpText<"Add path to the runpath search path list for image being created">;
 
 def t : Flag<["-"], "t">,
      HelpText<"Print the names of the input files as ld processes them">;
 def v : Flag<["-"], "v">,
      HelpText<"Print linker information">;
+def error_limit : Separate<["-", "--"], "error-limit">,
+     MetaVarName<"<number>">,
+     HelpText<"Maximum number of errors to emit before stopping (0 = no limit)">;
+
 
 // Obsolete options
 def grp_obsolete : OptionGroup<"obsolete">, HelpText<"OBSOLETE OPTIONS">;
 def single_module : Flag<["-"], "single_module">,
      HelpText<"Default for dylibs">, Group<grp_obsolete>;
 def multi_module : Flag<["-"], "multi_module">,
      HelpText<"Unsupported way to build dylibs">, Group<grp_obsolete>;
 def objc_gc_compaction : Flag<["-"], "objc_gc_compaction">,
      HelpText<"Unsupported ObjC GC option">, Group<grp_obsolete>;
 def objc_gc : Flag<["-"], "objc_gc">,
      HelpText<"Unsupported ObjC GC option">, Group<grp_obsolete>;
 def objc_gc_only : Flag<["-"], "objc_gc_only">,
      HelpText<"Unsupported ObjC GC option">, Group<grp_obsolete>;

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 //===- lib/ReaderWriter/MachO/MachOLinkingContext.cpp ---------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "lld/Common/ErrorHandler.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "ArchHandler.h"
 #include "File.h"
 #include "FlatNamespaceFile.h"
 #include "MachONormalizedFile.h"
 #include "MachOPasses.h"
 #include "SectCreateFile.h"
 #include "lld/Common/Driver.h"
for (StringRef dir : frameworkDirs()) {
     llvm::sys::path::append(fullPath, Twine(fwName) + ".framework", fwName);
     if (fileExists(fullPath))
       return fullPath.str().copy(_allocator);
   }
 
   return llvm::None;
 }
 
-bool MachOLinkingContext::validateImpl(raw_ostream &diagnostics) {
+bool MachOLinkingContext::validateImpl() {
   // TODO: if -arch not specified, look at arch of first .o file.
 
   if (_currentVersion && _outputMachOType != MH_DYLIB) {
-    diagnostics << "error: -current_version can only be used with dylibs\n";
+    error("-current_version can only be used with dylibs");
     return false;
   }
 
   if (_compatibilityVersion && _outputMachOType != MH_DYLIB) {
-    diagnostics
-        << "error: -compatibility_version can only be used with dylibs\n";
+    error("-compatibility_version can only be used with dylibs");
     return false;
   }
 
   if (_deadStrippableDylib && _outputMachOType != MH_DYLIB) {
-    diagnostics
-        << "error: -mark_dead_strippable_dylib can only be used with dylibs.\n";
+    error("-mark_dead_strippable_dylib can only be used with dylibs");
     return false;
   }
 
   if (!_bundleLoader.empty() && outputMachOType() != MH_BUNDLE) {
-    diagnostics
-        << "error: -bundle_loader can only be used with Mach-O bundles\n";
+    error("-bundle_loader can only be used with Mach-O bundles");
     return false;
   }
 
   // If -exported_symbols_list used, all exported symbols must be defined.
   if (_exportMode == ExportMode::whiteList) {
     for (const auto &symbol : _exportedSymbols)
       addInitialUndefinedSymbol(symbol.getKey());
   }

tools/lld/lld.cpp

int main(int Argc, const char **Argv) {
   switch (parseFlavor(Args)) {
   case Gnu:
     if (isPETarget(Args))
       return !mingw::link(Args);
     return !elf::link(Args, canExitEarly());
   case WinLink:
     return !coff::link(Args, canExitEarly());
   case Darwin:
-    return !mach_o::link(Args);
+    return !mach_o::link(Args, canExitEarly());
   case Wasm:
     return !wasm::link(Args, canExitEarly());
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld64.lld (macOS) or lld-link (Windows) instead.");
   }
 }

unittests/DriverTests/DarwinLdDriverTest.cpp

 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace lld;
 
 namespace lld {
 namespace mach_o {
-bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx,
-           raw_ostream &diagnostics);
+bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx);
 }
 }
 
 namespace {
 class DarwinLdParserTest : public testing::Test {
 protected:
   int inputFileCount() { return _ctx.getNodes().size(); }
 
   std::string inputFile(int index) {
     Node &node = *_ctx.getNodes()[index];
     if (node.kind() == Node::Kind::File)
       return cast<FileNode>(&node)->getFile()->path();
     llvm_unreachable("not handling other types of input files");
   }
 
   bool parse(std::vector<const char *> args) {
     args.insert(args.begin(), "ld");
-    std::string errorMessage;
-    raw_string_ostream os(errorMessage);
-    return mach_o::parse(args, _ctx, os);
+    return mach_o::parse(args, _ctx);
   }
 
   MachOLinkingContext _ctx;
 };
 }
 
 TEST_F(DarwinLdParserTest, Basic) {
   EXPECT_TRUE(parse({"foo.o", "bar.o", "-arch", "i386"}));