Make it possible to redirect not only errs() but also outs()

[ruiu]

Summary

This patch adds a new parmeter to lld::*::link() so that we can pass
an raw_ostream object representing stdout. Previously, lld::*::link()
took only an stderr object.

Justification for making stdoutOS and stderrOS mandatory: I wanted to
make link() functions to take stdout and stderr in that order.
However, if we change the function signature from

bool link(ArrayRef<const char *> args, bool canExitEarly,
          raw_ostream &stderrOS = llvm::errs());

to

bool link(ArrayRef<const char *> args, bool canExitEarly,
          raw_ostream &stdoutOS = llvm::outs(),
          raw_ostream &stderrOS = llvm::errs());

, then the meaning of existing code that passes stderrOS silently
changes (stderrOS would be interpreted as stdoutOS). So, I chose to
make existing code not to compile, so that developers can fix their
code.

[blackhole12]

I can confirm this change would satisfy my use-case, although another reviewer ought to look over it.

[MaskRay]

The description should probably mention that this change is for people who use lld as a library (D70287). They call lld::*::link, instead of lld's main().

lld/lib/Driver/DarwinLdDriver.cpp

1147

I think we can just use stdoutOS and stderrOS, there is no need for consistency with local variable names. Note that args is also not capitalized...

[ruiu]

lld/lib/Driver/DarwinLdDriver.cpp

1147

Yeah, I can use the variables directly, but I found that *stdoutOS << "something" look a bit awkward, and you can remove * if you make them functions.

[jrtc27]

This broke -DBUILD_SHARED_LIBS=ON for me; lld::errs() lives in Common, but Core has also been modified to use it, and Common depends on Core, not vice versa:

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:226 (lld/lib/Core/Resolver.cpp:226)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:255 (lld/lib/Core/Resolver.cpp:255)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:256 (lld/lib/Core/Resolver.cpp:256)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:269 (lld/lib/Core/Resolver.cpp:269)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:270 (lld/lib/Core/Resolver.cpp:270)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:282 (lld/lib/Core/Resolver.cpp:282)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:283 (lld/lib/Core/Resolver.cpp:283)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:427 (lld/lib/Core/Resolver.cpp:427)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::checkUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:434 (lld/lib/Core/Resolver.cpp:434)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::checkUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by SymbolTable.cpp:160 (lld/lib/Core/SymbolTable.cpp:160)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/SymbolTable.cpp.o:(lld::SymbolTable::addByName(lld::Atom const&))

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by SymbolTable.cpp:166 (lld/lib/Core/SymbolTable.cpp:166)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/SymbolTable.cpp.o:(lld::SymbolTable::addByName(lld::Atom const&))

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by SymbolTable.cpp:190 (lld/lib/Core/SymbolTable.cpp:190)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/SymbolTable.cpp.o:(lld::SymbolTable::addByName(lld::Atom const&))
collect2: error: ld returned 1 exit status

[MaskRay]

In D70292#1749676, @jrtc27 wrote:

This broke -DBUILD_SHARED_LIBS=ON for me; lld::errs() lives in Common, but Core has also been modified to use it, and Common depends on Core, not vice versa:

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:226 (lld/lib/Core/Resolver.cpp:226)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:255 (lld/lib/Core/Resolver.cpp:255)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:256 (lld/lib/Core/Resolver.cpp:256)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:269 (lld/lib/Core/Resolver.cpp:269)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:270 (lld/lib/Core/Resolver.cpp:270)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:282 (lld/lib/Core/Resolver.cpp:282)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:283 (lld/lib/Core/Resolver.cpp:283)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::resolveUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:427 (lld/lib/Core/Resolver.cpp:427)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::checkUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by Resolver.cpp:434 (lld/lib/Core/Resolver.cpp:434)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/Resolver.cpp.o:(lld::Resolver::checkUndefines())

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by SymbolTable.cpp:160 (lld/lib/Core/SymbolTable.cpp:160)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/SymbolTable.cpp.o:(lld::SymbolTable::addByName(lld::Atom const&))

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by SymbolTable.cpp:166 (lld/lib/Core/SymbolTable.cpp:166)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/SymbolTable.cpp.o:(lld::SymbolTable::addByName(lld::Atom const&))

ld.lld: error: undefined symbol: lld::errs()
>>> referenced by SymbolTable.cpp:190 (lld/lib/Core/SymbolTable.cpp:190)
>>>               tools/lld/lib/Core/CMakeFiles/lldCore.dir/SymbolTable.cpp.o:(lld::SymbolTable::addByName(lld::Atom const&))
collect2: error: ld returned 1 exit status

My -DBUILD_SHARED_LIBS=ON build has the same problem. I think we need to move code around to fix this.

[thopre]

I've raised PR44093 for a separate issue introduced by this commit. A tentative fix (that solve the problem for us) has been posted to phabricator.

lld/COFF/Driver.cpp

 namespace lld {
 namespace coff {
 
 static Timer inputFileTimer("Input File Reading", Timer::root());
 
 Configuration *config;
 LinkerDriver *driver;
 
-bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &diag) {
+bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
+          raw_ostream &stderrOS) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
-  errorHandler().errorOS = &diag;
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now"
       " (use /errorlimit:0 to see all errors)";
   errorHandler().exitEarly = canExitEarly;
-  enableColors(diag.has_colors());
+  enableColors(stderrOS.has_colors());
+
+  lld::stdoutOS = &stdoutOS;
+  lld::stderrOS = &stderrOS;
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
   driver = make<LinkerDriver>();
 
   driver->link(args);
 
   // Call exit() if we can to avoid calling destructors.
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
 
   config->showSummary = args.hasArg(OPT_summary);
 
   ScopedTimer t(Timer::root());
   // Handle --version, which is an lld extension. This option is a bit odd
   // because it doesn't start with "/", but we deliberately chose "--" to
   // avoid conflict with /version and for compatibility with clang-cl.
   if (args.hasArg(OPT_dash_dash_version)) {
-    outs() << getLLDVersion() << "\n";
+    lld::outs() << getLLDVersion() << "\n";
     return;
   }
 
   // Handle /lldmingw early, since it can potentially affect how other
   // options are handled.
   config->mingw = args.hasArg(OPT_lldmingw);
 
   // Handle /linkrepro and /reproduce.

lld/COFF/DriverUtils.cpp

 
 std::vector<const char *> ArgParser::tokenize(StringRef s) {
   SmallVector<const char *, 16> tokens;
   cl::TokenizeWindowsCommandLine(s, saver, tokens);
   return std::vector<const char *>(tokens.begin(), tokens.end());
 }
 
 void printHelp(const char *argv0) {
-  COFFOptTable().PrintHelp(outs(),
+  COFFOptTable().PrintHelp(lld::outs(),
                            (std::string(argv0) + " [options] file...").c_str(),
                            "LLVM Linker", false);
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/Writer.cpp

void Writer::sortExceptionTable() {
   }
   if (config->machine == ARMNT || config->machine == ARM64) {
     struct Entry { ulittle32_t begin, unwind; };
     parallelSort(
         MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
         [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
     return;
   }
-  errs() << "warning: don't know how to handle .pdata.\n";
+  lld::errs() << "warning: don't know how to handle .pdata.\n";
 }
 
 // The CRT section contains, among other things, the array of function
 // pointers that initialize every global variable that is not trivially
 // constructed. The CRT calls them one after the other prior to invoking
 // main().
 //
 // As per C++ spec, 3.6.2/2.3,

lld/Common/ErrorHandler.cpp

 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #endif
 
 using namespace llvm;
 using namespace lld;
 
 // The functions defined in this file can be called from multiple threads,
-// but outs() or errs() are not thread-safe. We protect them using a mutex.
+// but lld::outs() or lld::errs() are not thread-safe. We protect them using a
+// mutex.
 static std::mutex mu;
 
 // We want to separate multi-line messages with a newline. `sep` is "\n"
 // if the last messages was multi-line. Otherwise "".
 static StringRef sep;
 
 static StringRef getSeparator(const Twine &msg) {
   if (StringRef(msg.str()).contains('\n'))
     return "\n";
   return "";
 }
 
+raw_ostream *lld::stdoutOS;
+raw_ostream *lld::stderrOS;
+
+raw_ostream &lld::outs() { return stdoutOS ? *stdoutOS : llvm::outs(); }
+raw_ostream &lld::errs() { return stderrOS ? *stderrOS : llvm::errs(); }
+
 ErrorHandler &lld::errorHandler() {
   static ErrorHandler handler;
   return handler;
 }
 
-void lld::enableColors(bool enable) {
-  errorHandler().errorOS->enable_colors(enable);
-}
+void lld::enableColors(bool enable) { lld::errs().enable_colors(enable); }
 
 void lld::exitLld(int val) {
   // Delete any temporary file, while keeping the memory mapping open.
   if (errorHandler().outputBuffer)
     errorHandler().outputBuffer->discard();
 
   // Dealloc/destroy ManagedStatic variables before calling
   // _exit(). In a non-LTO build, this is a nop. In an LTO
   // build allows us to get the output of -time-passes.
   llvm_shutdown();
 
-  outs().flush();
-  errs().flush();
+  lld::outs().flush();
+  lld::errs().flush();
   _exit(val);
 }
 
 void lld::diagnosticHandler(const DiagnosticInfo &di) {
   SmallString<128> s;
   raw_svector_ostream os(s);
   DiagnosticPrinterRawOStream dp(os);
   di.print(dp);
std::string ErrorHandler::getLocation(const Twine &msg) {
 
   return logName;
 }
 
 void ErrorHandler::log(const Twine &msg) {
   if (!verbose)
     return;
   std::lock_guard<std::mutex> lock(mu);
-  *errorOS << logName << ": " << msg << "\n";
+  lld::errs() << logName << ": " << msg << "\n";
 }
 
 void ErrorHandler::message(const Twine &msg) {
   std::lock_guard<std::mutex> lock(mu);
-  outs() << msg << "\n";
-  outs().flush();
+  lld::outs() << msg << "\n";
+  lld::outs().flush();
 }
 
 void ErrorHandler::warn(const Twine &msg) {
   if (fatalWarnings) {
     error(msg);
     return;
   }
 
   std::lock_guard<std::mutex> lock(mu);
-  *errorOS << sep << getLocation(msg) << ": " << Colors::MAGENTA
+  lld::errs() << sep << getLocation(msg) << ": " << Colors::MAGENTA
               << "warning: " << Colors::RESET << msg << "\n";
   sep = getSeparator(msg);
 }
 
 void ErrorHandler::error(const Twine &msg) {
   // If Visual Studio-style error message mode is enabled,
   // this particular error is printed out as two errors.
   if (vsDiagnostics) {
     static std::regex re(R"(^(duplicate symbol: .*))"
                          R"((\n>>> defined at \S+:\d+.*\n>>>.*))"
                          R"((\n>>> defined at \S+:\d+.*\n>>>.*))");
     std::string str = msg.str();
     std::smatch m;
 
     if (std::regex_match(str, m, re)) {
       error(m.str(1) + m.str(2));
       error(m.str(1) + m.str(3));
       return;
     }
   }
 
   std::lock_guard<std::mutex> lock(mu);
 
   if (errorLimit == 0 || errorCount < errorLimit) {
-    *errorOS << sep << getLocation(msg) << ": " << Colors::RED
+    lld::errs() << sep << getLocation(msg) << ": " << Colors::RED
                 << "error: " << Colors::RESET << msg << "\n";
   } else if (errorCount == errorLimit) {
-    *errorOS << sep << getLocation(msg) << ": " << Colors::RED
+    lld::errs() << sep << getLocation(msg) << ": " << Colors::RED
                 << "error: " << Colors::RESET << errorLimitExceededMsg << "\n";
     if (exitEarly)
       exitLld(1);
   }
 
   sep = getSeparator(msg);
   ++errorCount;
 }
 
 void ErrorHandler::fatal(const Twine &msg) {
   error(msg);
   exitLld(1);
 }

lld/ELF/Driver.cpp

 namespace elf {
 
 Configuration *config;
 LinkerDriver *driver;
 
 static void setConfigs(opt::InputArgList &args);
 static void readConfigs(opt::InputArgList &args);
 
-bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &error) {
+bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
+          raw_ostream &stderrOS) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
-  errorHandler().errorOS = &error;
   errorHandler().exitEarly = canExitEarly;
-  enableColors(error.has_colors());
+  enableColors(stderrOS.has_colors());
+
+  lld::stdoutOS = &stdoutOS;
+  lld::stderrOS = &stderrOS;
 
   inputSections.clear();
   outputSections.clear();
   binaryFiles.clear();
   bitcodeFiles.clear();
   objectFiles.clear();
   sharedFiles.clear();
 

lld/ELF/DriverUtils.cpp

else
       error("unknown argument '" + arg->getAsString(args) +
             "', did you mean '" + nearest + "'");
   }
   return args;
 }
 
 void printHelp() {
   ELFOptTable().PrintHelp(
-      outs(), (config->progName + " [options] file...").str().c_str(), "lld",
-      false /*ShowHidden*/, true /*ShowAllAliases*/);
-  outs() << "\n";
+      lld::outs(), (config->progName + " [options] file...").str().c_str(),
+      "lld", false /*ShowHidden*/, true /*ShowAllAliases*/);
+  lld::outs() << "\n";
 
   // Scripts generated by Libtool versions up to at least 2.4.6 (the most
   // recent version as of March 2017) expect /: supported targets:.* elf/
   // in a message for the -help option. If it doesn't match, the scripts
   // assume that the linker doesn't support very basic features such as
   // shared libraries. Therefore, we need to print out at least "elf".
-  outs() << config->progName << ": supported targets: elf\n";
+  lld::outs() << config->progName << ": supported targets: elf\n";
 }
 
 static std::string rewritePath(StringRef s) {
   if (fs::exists(s))
     return relativeToRoot(s);
   return s;
 }
 

lld/ELF/MapFile.cpp

for (BaseCommand *base : osec->sectionCommands) {
         os << indent8 << cmd->commandString << '\n';
         continue;
       }
     }
   }
 }
 
 static void print(StringRef a, StringRef b) {
-  outs() << left_justify(a, 49) << " " << b << "\n";
+  lld::outs() << left_justify(a, 49) << " " << b << "\n";
 }
 
 // Output a cross reference table to stdout. This is for --cref.
 //
 // For each global symbol, we print out a file that defines the symbol
 // followed by files that uses that symbol. Here is an example.
 //
 //     strlen     /lib/x86_64-linux-gnu/libc.so.6
for (Symbol *sym : file->getSymbols()) {
         map[sym].insert(file);
       if (auto *d = dyn_cast<Defined>(sym))
         if (!d->isLocal() && (!d->section || d->section->isLive()))
           map[d].insert(file);
     }
   }
 
   // Print out a header.
-  outs() << "Cross Reference Table\n\n";
+  lld::outs() << "Cross Reference Table\n\n";
   print("Symbol", "File");
 
   // Print out a table.
   for (auto kv : map) {
     Symbol *sym = kv.first;
     SetVector<InputFile *> &files = kv.second;
 
     print(toString(*sym), toString(sym->file));
     for (InputFile *file : files)
       if (file != sym->file)
         print("", toString(file));
   }
 }
 
 } // namespace elf
 } // namespace lld

lld/MinGW/Driver.cpp

 public:
   MinGWOptTable() : OptTable(infoTable, false) {}
   opt::InputArgList parse(ArrayRef<const char *> argv);
 };
 } // namespace
 
 static void printHelp(const char *argv0) {
   MinGWOptTable().PrintHelp(
-      outs(), (std::string(argv0) + " [options] file...").c_str(), "lld",
+      lld::outs(), (std::string(argv0) + " [options] file...").c_str(), "lld",
       false /*ShowHidden*/, true /*ShowAllAliases*/);
-  outs() << "\n";
+  lld::outs() << "\n";
 }
 
 static cl::TokenizerCallback getQuotingStyle() {
   if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
     return cl::TokenizeWindowsCommandLine;
   return cl::TokenizeGNUCommandLine;
 }
 
for (StringRef dir : searchPaths) {
     }
   }
   error("unable to find library -l" + name);
   return "";
 }
 
 // Convert Unix-ish command line arguments to Windows-ish ones and
 // then call coff::link.
-bool mingw::link(ArrayRef<const char *> argsArr, raw_ostream &diag) {
-  enableColors(diag.has_colors());
+bool mingw::link(ArrayRef<const char *> argsArr, bool canExitEarly,
+                 raw_ostream &stdoutOS, raw_ostream &stderrOS) {
+  enableColors(stderrOS.has_colors());
+  lld::stdoutOS = &stdoutOS;
+  lld::stderrOS = &stderrOS;
 
   MinGWOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
   if (errorCount())
     return false;
 
   if (args.hasArg(OPT_help)) {
case OPT_Bdynamic:
       break;
     }
   }
 
   if (errorCount())
     return false;
 
   if (args.hasArg(OPT_verbose) || args.hasArg(OPT__HASH_HASH_HASH))
-    outs() << llvm::join(linkArgs, " ") << "\n";
+    lld::outs() << llvm::join(linkArgs, " ") << "\n";
 
   if (args.hasArg(OPT__HASH_HASH_HASH))
     return true;
 
   // Repack vector of strings to vector of const char pointers for coff::link.
   std::vector<const char *> vec;
   for (const std::string &s : linkArgs)
     vec.push_back(s.c_str());
-  return coff::link(vec, true);
+  return coff::link(vec, true, stdoutOS, stderrOS);
 }

lld/include/lld/Common/Driver.h

 #define LLD_COMMON_DRIVER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace coff {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
-          llvm::raw_ostream &diag = llvm::errs());
+          llvm::raw_ostream &stdout, llvm::raw_ostream &stderr);
 }
 
 namespace mingw {
-bool link(llvm::ArrayRef<const char *> args,
-          llvm::raw_ostream &diag = llvm::errs());
+bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
+          llvm::raw_ostream &stdout, llvm::raw_ostream &stderr);
 }
 
 namespace elf {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
-          llvm::raw_ostream &diag = llvm::errs());
+          llvm::raw_ostream &stdout, llvm::raw_ostream &stderr);
 }
 
 namespace mach_o {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
-          llvm::raw_ostream &diag = llvm::errs());
+          llvm::raw_ostream &stdout, llvm::raw_ostream &stderr);
 }
 
 namespace wasm {
 bool link(llvm::ArrayRef<const char *> args, bool canExitEarly,
-          llvm::raw_ostream &diag = llvm::errs());
+          llvm::raw_ostream &stdout, llvm::raw_ostream &stderr);
 }
 }
 
 #endif

lld/include/lld/Common/ErrorHandler.h

 //
 // You should never call fatal() except for reporting a corrupted input file.
 // fatal() immediately terminates the linker, so the function is not desirable
 // if you are using lld as a subroutine in other program, and with that you
 // can find only one error at a time.
 //
 // warn() doesn't do anything but printing out a given message.
 //
-// It is not recommended to use llvm::outs() or llvm::errs() directly in lld
+// It is not recommended to use llvm::outs() or lld::errs() directly in lld
 // because they are not thread-safe. The functions declared in this file are
 // thread-safe.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COMMON_ERRORHANDLER_H
 #define LLD_COMMON_ERRORHANDLER_H
 
 #include "lld/Common/LLVM.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileOutputBuffer.h"
 
 namespace llvm {
 class DiagnosticInfo;
+class raw_ostream;
 }
 
 namespace lld {
 
+// We wrap stdout and stderr so that you can pass alternative stdout/stderr as
+// arguments to lld::*::link() functions.
+extern llvm::raw_ostream *stdoutOS;
+extern llvm::raw_ostream *stderrOS;
+
+llvm::raw_ostream &outs();
+llvm::raw_ostream &errs();
+
 class ErrorHandler {
 public:
   uint64_t errorCount = 0;
   uint64_t errorLimit = 20;
   StringRef errorLimitExceededMsg = "too many errors emitted, stopping now";
   StringRef logName = "lld";
-  llvm::raw_ostream *errorOS = &llvm::errs();
   bool exitEarly = true;
   bool fatalWarnings = false;
   bool verbose = false;
   bool vsDiagnostics = false;
 
   void error(const Twine &msg);
   LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &msg);
   void log(const Twine &msg);

lld/include/lld/Common/LLVM.h

 struct WasmGlobal;
 struct WasmGlobalType;
 struct WasmRelocation;
 struct WasmSignature;
 } // namespace wasm
 } // namespace llvm
 
 namespace lld {
+llvm::raw_ostream &outs();
+llvm::raw_ostream &errs();
+
 // Casting operators.
 using llvm::cast;
 using llvm::cast_or_null;
 using llvm::dyn_cast;
 using llvm::dyn_cast_or_null;
 using llvm::isa;
 
 // ADT's.

lld/lib/Core/Resolver.cpp

bool Resolver::resolveUndefines() {
   for (;;) {
     bool undefAdded = false;
     DEBUG_WITH_TYPE("resolver",
                     llvm::dbgs() << "Loading file #" << index << "\n");
     File *file = getFile(index);
     if (!file)
       return true;
     if (std::error_code ec = file->parse()) {
-      llvm::errs() << "Cannot open " + file->path()
-                   << ": " << ec.message() << "\n";
+      lld::errs() << "Cannot open " + file->path() << ": " << ec.message()
+                  << "\n";
       return false;
     }
     DEBUG_WITH_TYPE("resolver",
                     llvm::dbgs() << "Loaded file: " << file->path() << "\n");
     switch (file->kind()) {
     case File::kindErrorObject:
     case File::kindNormalizedObject:
     case File::kindMachObject:
case File::kindSectCreateObject: {
         break;
       seen.insert(file);
       assert(!file->hasOrdinal());
       file->setOrdinal(_ctx.getNextOrdinalAndIncrement());
       auto undefAddedOrError = handleFile(*file);
       if (auto EC = undefAddedOrError.takeError()) {
         // FIXME: This should be passed to logAllUnhandledErrors but it needs
         // to be passed a Twine instead of a string.
-        llvm::errs() << "Error in " + file->path() << ": ";
-        logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
+        lld::errs() << "Error in " + file->path() << ": ";
+        logAllUnhandledErrors(std::move(EC), lld::errs(), std::string());
         return false;
       }
       undefAdded = undefAddedOrError.get();
       break;
     }
     case File::kindArchiveLibrary: {
       if (!file->hasOrdinal())
         file->setOrdinal(_ctx.getNextOrdinalAndIncrement());
       auto undefAddedOrError = handleArchiveFile(*file);
       if (auto EC = undefAddedOrError.takeError()) {
         // FIXME: This should be passed to logAllUnhandledErrors but it needs
         // to be passed a Twine instead of a string.
-        llvm::errs() << "Error in " + file->path() << ": ";
-        logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
+        lld::errs() << "Error in " + file->path() << ": ";
+        logAllUnhandledErrors(std::move(EC), lld::errs(), std::string());
         return false;
       }
       undefAdded = undefAddedOrError.get();
       break;
     }
     case File::kindSharedLibrary:
       if (!file->hasOrdinal())
         file->setOrdinal(_ctx.getNextOrdinalAndIncrement());
       if (auto EC = handleSharedLibrary(*file)) {
         // FIXME: This should be passed to logAllUnhandledErrors but it needs
         // to be passed a Twine instead of a string.
-        llvm::errs() << "Error in " + file->path() << ": ";
-        logAllUnhandledErrors(std::move(EC), llvm::errs(), std::string());
+        lld::errs() << "Error in " + file->path() << ": ";
+        logAllUnhandledErrors(std::move(EC), lld::errs(), std::string());
         return false;
       }
       break;
     }
     _newUndefinesAdded[file] = undefAdded;
   }
 }
 
for (const UndefinedAtom *undef : undefinedAtoms) {
 
     // If the undefine is coalesced away, skip over it.
     if (_symbolTable.isCoalescedAway(undef))
       continue;
 
     // Seems like this symbol is undefined. Warn that.
     foundUndefines = true;
     if (_ctx.printRemainingUndefines()) {
-      llvm::errs() << "Undefined symbol: " << undef->file().path()
-                   << ": " << _ctx.demangle(undef->name())
-                   << "\n";
+      lld::errs() << "Undefined symbol: " << undef->file().path() << ": "
+                  << _ctx.demangle(undef->name()) << "\n";
     }
   }
   if (!foundUndefines)
     return false;
   if (_ctx.printRemainingUndefines())
-    llvm::errs() << "symbol(s) not found\n";
+    lld::errs() << "symbol(s) not found\n";
   return true;
 }
 
 // remove from _atoms all coaleseced away atoms
 void Resolver::removeCoalescedAwayAtoms() {
   DEBUG_WITH_TYPE("resolver",
                   llvm::dbgs() << "******** Removing coalesced away atoms:\n");
   ScopedTask task(getDefaultDomain(), "removeCoalescedAwayAtoms");

lld/lib/Core/SymbolTable.cpp

case NCR_DupDef: {
     }
     case MCR_SameSize: {
       uint64_t existingSize = existingDef->sectionSize();
       uint64_t newSize = newDef->sectionSize();
       if (existingSize == newSize) {
         useNew = true;
         break;
       }
-      llvm::errs() << "Size mismatch: "
-                   << existing->name() << " (" << existingSize << ") "
-                   << newAtom.name() << " (" << newSize << ")\n";
+      lld::errs() << "Size mismatch: " << existing->name() << " ("
+                  << existingSize << ") " << newAtom.name() << " (" << newSize
+                  << ")\n";
       LLVM_FALLTHROUGH;
     }
     case MCR_Error:
-      llvm::errs() << "Duplicate symbols: "
-                   << existing->name()
-                   << ":"
-                   << existing->file().path()
-                   << " and "
-                   << newAtom.name()
-                   << ":"
-                   << newAtom.file().path()
-                   << "\n";
+      lld::errs() << "Duplicate symbols: " << existing->name() << ":"
+                  << existing->file().path() << " and " << newAtom.name() << ":"
+                  << newAtom.file().path() << "\n";
       llvm::report_fatal_error("duplicate symbol error");
       break;
     }
     break;
   }
   case NCR_DupUndef: {
     const UndefinedAtom* existingUndef = cast<UndefinedAtom>(existing);
     const UndefinedAtom* newUndef = cast<UndefinedAtom>(&newAtom);
 
     bool sameCanBeNull = (existingUndef->canBeNull() == newUndef->canBeNull());
     if (sameCanBeNull)
       useNew = false;
     else
       useNew = (newUndef->canBeNull() < existingUndef->canBeNull());
     break;
   }
   case NCR_DupShLib: {
     useNew = false;
     break;
   }
   case NCR_Error:
-    llvm::errs() << "SymbolTable: error while merging " << name << "\n";
+    lld::errs() << "SymbolTable: error while merging " << name << "\n";
     llvm::report_fatal_error("duplicate symbol error");
     break;
   }
 
   if (useNew) {
     // Update name table to use new atom.
     _nameTable[name] = &newAtom;
     // Add existing atom to replacement table.

lld/lib/Driver/DarwinLdDriver.cpp

if (!prefixAndSym.second.empty()) {
         if (!ctx.archName().equals(prefix))
           continue;
         prefix = "";
       }
     } else
      sym = prefixAndSym.first;
     if (!sym.empty()) {
       ctx.appendOrderedSymbol(sym, prefix);
-      //llvm::errs() << sym << ", prefix=" << prefix << "\n";
+      // lld::errs() << sym << ", prefix=" << prefix << "\n";
     }
   }
   return std::error_code();
 }
 
 //
 // There are two variants of the  -filelist option:
 //
for (auto &inFile : parsedArgs.filtered(OPT_INPUT)) {
       // 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(),
+        table.PrintHelp(lld::outs(),
                         (std::string(args[0]) + " [options] file...").c_str(),
                         "LLVM Linker", false);
       } else {
         error("-arch not specified and could not be inferred");
       }
       return false;
     }
   }
static void createFiles(MachOLinkingContext &ctx, bool Implicit) {
   for (auto i = Files.rbegin(), e = Files.rend(); i != e; ++i) {
     auto &members = ctx.getNodes();
     members.insert(members.begin(), std::make_unique<FileNode>(std::move(*i)));
   }
 }
 
 /// This is where the link is actually performed.
 bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly,
-          raw_ostream &Error) {
+          raw_ostream &StdoutOS, raw_ostream &StderrOS) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "'-error-limit 0' to see all errors)";
-  errorHandler().errorOS = &Error;
   errorHandler().exitEarly = CanExitEarly;
-  enableColors(Error.has_colors());
+  enableColors(StderrOS.has_colors());
+
+  lld::stdoutOS = &StdoutOS;
+  lld::stderrOS = &StderrOS;
 
   MachOLinkingContext ctx;
   if (!parse(args, ctx))
     return false;
   if (ctx.doNothing())
     return true;
   if (ctx.getNodes().empty())
     return false;
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.
-    *errorHandler().errorOS << "Failed to run passes on file '"
-                            << ctx.outputPath() << "': ";
-    logAllUnhandledErrors(std::move(ec), *errorHandler().errorOS,
-                          std::string());
+    lld::errs() << "Failed to run passes on file '" << ctx.outputPath()
+                << "': ";
+    logAllUnhandledErrors(std::move(ec), lld::errs(), 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.
-    *errorHandler().errorOS << "Failed to write file '" << ctx.outputPath()
-                            << "': ";
-    logAllUnhandledErrors(std::move(ec), *errorHandler().errorOS,
-                          std::string());
+    lld::errs() << "Failed to write file '" << ctx.outputPath() << "': ";
+    logAllUnhandledErrors(std::move(ec), lld::errs(), 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

lld/lib/ReaderWriter/FileArchive.cpp

std::error_code instantiateMember(Archive::Child member,
     Expected<llvm::MemoryBufferRef> mbOrErr = member.getMemoryBufferRef();
     if (!mbOrErr)
       return errorToErrorCode(mbOrErr.takeError());
     llvm::MemoryBufferRef mb = mbOrErr.get();
     std::string memberPath = (_archive->getFileName() + "("
                            + mb.getBufferIdentifier() + ")").str();
 
     if (_logLoading)
-      llvm::errs() << memberPath << "\n";
+      lld::errs() << memberPath << "\n";
 
     std::unique_ptr<MemoryBuffer> memberMB(MemoryBuffer::getMemBuffer(
         mb.getBuffer(), mb.getBufferIdentifier(), false));
 
     ErrorOr<std::unique_ptr<File>> fileOrErr =
         _registry.loadFile(std::move(memberMB));
     if (std::error_code ec = fileOrErr.getError())
       return ec;

lld/lib/ReaderWriter/MachO/LayoutPass.cpp

static bool compareAtomsSub(const LayoutPass::SortKey &lc,
   uint64_t rightOrdinal = rightRoot->ordinal();
 
   if (leftOrdinal != rightOrdinal) {
     LLVM_DEBUG(reason = formatReason("ordinal", (int)leftRoot->ordinal(),
                                      (int)rightRoot->ordinal()));
     return leftOrdinal < rightOrdinal;
   }
 
-  llvm::errs() << "Unordered: <" << left->name() << "> <"
-               << right->name() << ">\n";
+  lld::errs() << "Unordered: <" << left->name() << "> <" << right->name()
+              << ">\n";
   llvm_unreachable("Atoms with Same Ordinal!");
 }
 
 static bool compareAtoms(const LayoutPass::SortKey &lc,
                          const LayoutPass::SortKey &rc,
                          LayoutPass::SortOverride customSorter) {
   std::string reason;
   bool result = compareAtomsSub(lc, rc, customSorter, reason);

lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

for (const SectionAlign &entry : _sectAligns) {
     }
   }
   return false;
 }
 
 void MachOLinkingContext::addExportSymbol(StringRef sym) {
   // Support old crufty export lists with bogus entries.
   if (sym.endswith(".eh") || sym.startswith(".objc_category_name_")) {
-    llvm::errs() << "warning: ignoring " << sym << " in export list\n";
+    lld::errs() << "warning: ignoring " << sym << " in export list\n";
     return;
   }
   // Only i386 MacOSX uses old ABI, so don't change those.
   if ((_os != OS::macOSX) || (_arch != arch_x86)) {
     // ObjC has two differnent ABIs.  Be nice and allow one export list work for
     // both ABIs by renaming symbols.
     if (sym.startswith(".objc_class_name_")) {
       std::string abi2className("_OBJC_CLASS_$_");

lld/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

std::sort(symbols.begin(), symbols.end(),
               bool rPrivate = (rhs->name.front() == 'l');
               if (lPrivate != rPrivate)
                 return lPrivate;
               // If same address and scope, sort by name.
               return lhs->name < rhs->name;
             });
 
   // Debug logging of symbols.
-  //for (const Symbol *sym : symbols)
-  //  llvm::errs() << "  sym: "
+  // for (const Symbol *sym : symbols)
+  //  lld::errs() << "  sym: "
   //    << llvm::format("0x%08llx ", (uint64_t)sym->value)
   //    << ", " << sym->name << "\n";
 
   // If section has no symbols and no content, there are no atoms.
   if (symbols.empty() && section.content.empty())
     return llvm::Error::success();
 
   if (symbols.empty()) {

lld/tools/lld/lld.cpp

enum Flavor {
   Invalid,
   Gnu,     // -flavor gnu
   WinLink, // -flavor link
   Darwin,  // -flavor darwin
   Wasm,    // -flavor wasm
 };
 
 LLVM_ATTRIBUTE_NORETURN static void die(const Twine &s) {
-  errs() << s << "\n";
+  llvm::errs() << s << "\n";
   exit(1);
 }
 
 static Flavor getFlavor(StringRef s) {
   return StringSwitch<Flavor>(s)
       .CasesLower("ld", "ld.lld", "gnu", Gnu)
       .CasesLower("wasm", "ld-wasm", Wasm)
       .CaseLower("link", WinLink)

 /// windows linker based on the argv[0] or -flavor option.
 int main(int argc, const char **argv) {
   InitLLVM x(argc, argv);
 
   std::vector<const char *> args(argv, argv + argc);
   switch (parseFlavor(args)) {
   case Gnu:
     if (isPETarget(args))
-      return !mingw::link(args);
-    return !elf::link(args, canExitEarly());
+      return !mingw::link(args, canExitEarly(), llvm::outs(), llvm::errs());
+    return !elf::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   case WinLink:
-    return !coff::link(args, canExitEarly());
+    return !coff::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   case Darwin:
-    return !mach_o::link(args, canExitEarly());
+    return !mach_o::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   case Wasm:
-    return !wasm::link(args, canExitEarly());
+    return !wasm::link(args, canExitEarly(), llvm::outs(), llvm::errs());
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld"
         " (WebAssembly) instead");
   }
 }

lld/unittests/MachOTests/MachONormalizedFileBinaryWriterTests.cpp

TEST(BinaryWriterTest, obj_relocs_x86) {
   EXPECT_EQ(pic2.value, 5U);
   const Relocation& tlv = text.relocations[4];
   EXPECT_EQ(tlv.offset, Hex32(0x12));
   EXPECT_EQ(tlv.type, GENERIC_RELOC_TLV);
   EXPECT_EQ(tlv.length, 2);
   EXPECT_EQ(tlv.isExtern, true);
   EXPECT_EQ(tlv.symbol, 1U);
 
-  //llvm::errs() << "temp = " << tmpFl << "\n";
+  // lld::errs() << "temp = " << tmpFl << "\n";
   bufferOwner.reset(nullptr);
   std::error_code ec = llvm::sys::fs::remove(Twine(tmpFl));
   EXPECT_FALSE(ec);
 }
 
 
 
 TEST(BinaryWriterTest, obj_relocs_armv7) {
TEST(BinaryWriterTest, obj_relocs_armv7) {
   EXPECT_EQ(movt2.value, Hex32(0xC));
  const Relocation& absPointer = text.relocations[5];
   EXPECT_EQ(absPointer.offset, Hex32(0xC));
   EXPECT_EQ(absPointer.type, ARM_RELOC_VANILLA);
   EXPECT_EQ(absPointer.length, 2);
   EXPECT_EQ(absPointer.isExtern, true);
   EXPECT_EQ(absPointer.symbol, 2U);
 
-  //llvm::errs() << "temp = " << tmpFl << "\n";
+  // lld::errs() << "temp = " << tmpFl << "\n";
   bufferOwner.reset(nullptr);
   std::error_code ec = llvm::sys::fs::remove(Twine(tmpFl));
   EXPECT_FALSE(ec);
 }
 
 
 
 TEST(BinaryWriterTest, obj_relocs_ppc) {

lld/wasm/Driver.cpp

private:
 
   // True if we are in --whole-archive and --no-whole-archive.
   bool inWholeArchive = false;
 
   std::vector<InputFile *> files;
 };
 } // anonymous namespace
 
-bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &error) {
+bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
+          raw_ostream &stderrOS) {
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
-  errorHandler().errorOS = &error;
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
-  enableColors(error.has_colors());
+  enableColors(stderrOS.has_colors());
+
+  lld::stdoutOS = &stdoutOS;
+  lld::stderrOS = &stderrOS;
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
 
   initLLVM();
   LinkerDriver().link(args);
 
   // Exit immediately if we don't need to return to the caller.

 }
 
 void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   WasmOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
   // Handle --help
   if (args.hasArg(OPT_help)) {
-    parser.PrintHelp(outs(),
+    parser.PrintHelp(lld::outs(),
                      (std::string(argsArr[0]) + " [options] file...").c_str(),
                      "LLVM Linker", false);
     return;
   }
 
   // Handle --version
   if (args.hasArg(OPT_version) || args.hasArg(OPT_v)) {
-    outs() << getLLDVersion() << "\n";
+    lld::outs() << getLLDVersion() << "\n";
     return;
   }
 
   // Handle --reproduce
   if (auto *arg = args.getLastArg(OPT_reproduce)) {
     StringRef path = arg->getValue();
     Expected<std::unique_ptr<TarWriter>> errOrWriter =
         TarWriter::create(path, path::stem(path));