COFF: add error() and warn() to Error.{cpp,h}

[inglorion]

Summary

This copies over some functionality we have in ELF/Error.{cpp,h} and makes it available in COFF/Error.{cpp,h}

[inglorion]

I'm refactoring the COFF linker's LTO support to use the new LTO API. To keep the code as similar as possible to what we do in the ELF linker, I'll be re-using some code that uses the functions being added here.

[ruiu]

COFF/Config.h

83

You don't seem to set a value to ColorDiagnostics. Does this mean it error messages are always printed in black/white? Doesn't Process::StandardErrHasColors work for Windows?

COFF/Error.h

26

This was removed from ELF, so you don't want to add it to COFF. You can always do error("somthing failed: " + EC.message()) instead of error(EC, "something failed").

[inglorion]

Thanks for taking a look, @ruiu. I'll remove the functions that no longer exist in ELF. As for colors, I didn't need that for what I was doing, so I didn't make it do anything. Want me to include that in this patch or in a follow-up?

[ruiu]

If you are not going to set a value to Config->ColorDiagnostics, if (Config->ColorDiagnostics) part is dead code, but I don't think we want to check in dead code. How about adding this one line to the driver?

Config->Diagnostics = (ErrorOS == llvm::errs() && Process::StandardErrHasColors());

[inglorion]

Changes requested by @ruiu:

• Only add error(const Twine &Msg), not the variant that has since been removed.
• Initialize Config->ColorDiagnostics based on color support in error stream.
• Also updated existing code to use Config->ColorDiagnostics, instead of using its own detection.
• Updated the title of the change to reflect that we're only adding error() and warn().

[ruiu]

COFF/Config.h

83

nit: remove = false as the default value will always be overwrote.

87

Since this is always true, please remove the variable.

COFF/Error.cpp

15

Are you actually using this header?

68–69

It is OK to call exitLld unconditionally in COFF.

98–101

I think you want to remove this code and Config::FatalWarnings. (This is using an uninitialized value.)

[inglorion]

COFF/Error.cpp

15

llvm_shutdown() (used in exitLld) comes from that header.

[inglorion]

Changes requested by @ruiu:

• Removed Config->ExitEarly and Config->FatalWarnings and the code that checks their values.

[inglorion]

Removed no-longer-needed initialization of Config->ColorDiagnostics in Config.h.

[ruiu]

LGTM with this fix.

COFF/Error.cpp

98–99

Debug code or something?

[inglorion]

COFF/Error.cpp

98–99

Nope...that's a bug I just introduced. Fixing...

[inglorion]

Use exitLld instead of _exit in fatal(), make warn() not fatal, and mark exitLld() noreturn.

[pcc]

lld/trunk/COFF/Error.cpp

67 ↗

(On Diff #84708)

It looks like this isn't actually configurable in the COFF linker.

COFF/Config.h

struct Configuration {
   bool is64() { return Machine == AMD64; }
 
   llvm::COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
   bool Verbose = false;
   WindowsSubsystem Subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
   SymbolBody *Entry = nullptr;
   bool NoEntry = false;
   std::string OutputFile;
+  bool ColorDiagnostics = false;
   bool DoGC = true;
   bool DoICF = true;
+  uint64_t ErrorLimit = 20;
   bool Relocatable = true;
   bool Force = false;
   bool Debug = false;
   bool WriteSymtab = true;
   unsigned DebugTypes = static_cast<unsigned>(DebugType::None);
   StringRef PDBPath;
 
   // Symbols in this set are considered as live by the garbage collector.
   std::set<SymbolBody *> GCRoot;

COFF/Driver.cpp

 
 Configuration *Config;
 LinkerDriver *Driver;
 
 BumpPtrAllocator BAlloc;
 StringSaver Saver{BAlloc};
 std::vector<SpecificAllocBase *> SpecificAllocBase::Instances;
 
-bool link(ArrayRef<const char *> Args) {
+bool link(ArrayRef<const char *> Args, raw_ostream &Diag) {
+  ErrorCount = 0;
+  ErrorOS = &Diag;
+  Argv0 = Args[0];
   Config = make<Configuration>();
+  Config->ColorDiagnostics =
+      (ErrorOS == &llvm::errs() && Process::StandardErrHasColors());
   Driver = make<LinkerDriver>();
   Driver->link(Args);
   return true;
 }
 
 // Drop directory components and replace extension with ".exe" or ".dll".
 static std::string getOutputPath(StringRef Path) {
   auto P = Path.find_last_of("\\/");

COFF/Error.h

 #define LLD_COFF_ERROR_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/Support/Error.h"
 
 namespace lld {
 namespace coff {
 
+extern uint64_t ErrorCount;
+extern llvm::raw_ostream *ErrorOS;
+extern llvm::StringRef Argv0;
+
+void warn(const Twine &Msg);
+void error(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void fatal(std::error_code EC, const Twine &Prefix);
 LLVM_ATTRIBUTE_NORETURN void fatal(llvm::Error &Err, const Twine &Prefix);
 
 template <class T> T check(ErrorOr<T> &&V, const Twine &Prefix) {
   if (auto EC = V.getError())
     fatal(EC, Prefix);
   return std::move(*V);
 }
 

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 "Config.h"
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
+#include <mutex>
 
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #endif
 
 using namespace llvm;
 
 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.
+static std::mutex Mu;
+
 namespace coff {
+StringRef Argv0;
+uint64_t ErrorCount;
+raw_ostream *ErrorOS;
+
+static void exitLld(int Val) {
+  // 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();
+  _exit(Val);
+}
+
+static void print(StringRef S, raw_ostream::Colors C) {
+  *ErrorOS << Argv0 + ": ";
+  if (Config->ColorDiagnostics) {
+    ErrorOS->changeColor(C, true);
+    *ErrorOS << S;
+    ErrorOS->resetColor();
+  } else {
+    *ErrorOS << S;
+  }
+}
+
+void error(const Twine &Msg) {
+  std::lock_guard<std::mutex> Lock(Mu);
+
+  if (Config->ErrorLimit == 0 || ErrorCount < Config->ErrorLimit) {
+    print("error: ", raw_ostream::RED);
+    *ErrorOS << Msg << "\n";
+  } else if (ErrorCount == Config->ErrorLimit) {
+    print("error: ", raw_ostream::RED);
+    *ErrorOS << "too many errors emitted, stopping now"
+             << " (use -error-limit=0 to see all errors)\n";
+    exitLld(1);
+  }
+
+  ++ErrorCount;
+}
 
 void fatal(const Twine &Msg) {
-  if (sys::Process::StandardErrHasColors()) {
+  if (Config->ColorDiagnostics) {
     errs().changeColor(raw_ostream::RED, /*bold=*/true);
     errs() << "error: ";
     errs().resetColor();
   } else {
     errs() << "error: ";
   }
   errs() << Msg << "\n";
 
   outs().flush();
   errs().flush();
   _exit(1);
 }
 
 void fatal(std::error_code EC, const Twine &Msg) {
   fatal(Msg + ": " + EC.message());
 }
 
 void fatal(llvm::Error &Err, const Twine &Msg) {
   fatal(errorToErrorCode(std::move(Err)), Msg);
 }
 
+void warn(const Twine &Msg) {
+  error(Msg);
+  return;
+  std::lock_guard<std::mutex> Lock(Mu);
+  print("warning: ", raw_ostream::MAGENTA);
+  *ErrorOS << Msg << "\n";
+}
+
 } // namespace coff
 } // namespace lld

include/lld/Driver/Driver.h

 #ifndef LLD_DRIVER_DRIVER_H
 #define LLD_DRIVER_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 link(llvm::ArrayRef<const char *> Args,
+          llvm::raw_ostream &Diag = llvm::errs());
 }
 
 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,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 }
 
 #endif