Support -color-diagnostics={auto,always,never}.

[ruiu]

Summary

-color-diagnostics=auto is default because that's the same as
Clang's default. When color is enabled, error or warning messages
are colored like this.

error:
<bold>ld.lld</bold> <red>error:</red> foo.o: no such file

warning:
<bold>ld.lld</bold> <magenta>warning:</magenta> foo.o: no such file

[grimar]

Looks like a cool feature for me.

test/ELF/color-diagnostics.test

1

support

[grimar]

test/ELF/color-diagnostics.test

1

sequences

ELF/Config.h

enum ELFKind {
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
 // For --build-id.
 enum class BuildIdKind { None, Fast, Md5, Sha1, Hexstring, Uuid };
 
+// For --color-diagnostics.
+enum class ColorPolicy { Auto, Always, Never };
+
 // For --discard-{all,locals,none}.
 enum class DiscardPolicy { Default, All, Locals, None };
 
 // For --strip-{all,debug}.
 enum class StripPolicy { None, All, Debug };
 
 // For --unresolved-symbols.
 enum class UnresolvedPolicy { NoUndef, ReportError, Warn, Ignore };
struct Configuration {
   bool ZCombreloc;
   bool ZExecstack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   bool ExitEarly;
   bool ZWxneeded;
+  ColorPolicy ColorDiagnostics = ColorPolicy::Auto;
   DiscardPolicy Discard;
   SortSectionPolicy SortSection;
   StripPolicy Strip = StripPolicy::None;
   UnresolvedPolicy UnresolvedSymbols;
   Target2Policy Target2 = Target2Policy::GotRel;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;

ELF/Driver.cpp

 
 static bool getArg(opt::InputArgList &Args, unsigned K1, unsigned K2,
                    bool Default) {
   if (auto *Arg = Args.getLastArg(K1, K2))
     return Arg->getOption().getID() == K1;
   return Default;
 }
 
+// Parse -color-diagnostics={auto,always,never} or -no-color-diagnostics.
+static ColorPolicy getColorDiagnostics(opt::InputArgList &Args) {
+  auto *Arg = Args.getLastArg(OPT_color_diagnostics, OPT_no_color_diagnostics);
+  if (!Arg)
+    return ColorPolicy::Auto;
+  if (Arg->getOption().getID() == OPT_no_color_diagnostics)
+    return ColorPolicy::Never;
+
+  StringRef S = Arg->getValue();
+  if (S == "auto")
+    return ColorPolicy::Auto;
+  if (S == "always")
+    return ColorPolicy::Always;
+  if (S != "never")
+    error("unknown -color-diagnostics value: " + S);
+  return ColorPolicy::Never;
+}
+
 static DiscardPolicy getDiscardOption(opt::InputArgList &Args) {
   auto *Arg =
       Args.getLastArg(OPT_discard_all, OPT_discard_locals, OPT_discard_none);
   if (!Arg)
     return DiscardPolicy::Default;
   if (Arg->getOption().getID() == OPT_discard_all)
     return DiscardPolicy::All;
   if (Arg->getOption().getID() == OPT_discard_locals)
std::tie(Config->EKind, Config->EMachine, Config->OSABI) =
         parseEmulation(S);
     Config->MipsN32Abi = (S == "elf32btsmipn32" || S == "elf32ltsmipn32");
     Config->Emulation = S;
   }
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
+  Config->ColorDiagnostics = getColorDiagnostics(Args);
   Config->Demangle = getArg(Args, OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Discard = getDiscardOption(Args);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ErrorLimit = getInteger(Args, OPT_error_limit, 20);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->FatalWarnings = Args.hasArg(OPT_fatal_warnings);

ELF/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 lld::elf;
 using namespace llvm;
 
 namespace lld {
 
 uint64_t elf::ErrorCount;
 raw_ostream *elf::ErrorOS;
 StringRef elf::Argv0;
 
 // 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;
 
+static bool useColor() {
+  if (Config->ColorDiagnostics == ColorPolicy::Always)
+    return true;
+  if (Config->ColorDiagnostics == ColorPolicy::Never)
+    return false;
+  return ErrorOS == &errs() && sys::Process::StandardErrHasColors();
+}
+
+static void print(StringRef S, raw_ostream::Colors C) {
+  if (useColor()) {
+    ErrorOS->changeColor(raw_ostream::WHITE, /*Bold=*/true);
+    *ErrorOS << Argv0 + ": ";
+    ErrorOS->changeColor(C, true);
+    *ErrorOS << S;
+    ErrorOS->resetColor();
+  } else {
+    *ErrorOS << Argv0 + ": " << S;
+  }
+}
+
 void elf::log(const Twine &Msg) {
   std::lock_guard<std::mutex> Lock(Mu);
   if (Config->Verbose)
     outs() << Argv0 << ": " << Msg << "\n";
 }
 
 void elf::warn(const Twine &Msg) {
   if (Config->FatalWarnings) {
     error(Msg);
     return;
   }
   std::lock_guard<std::mutex> Lock(Mu);
-  *ErrorOS << Argv0 << ": warning: " << Msg << "\n";
+  print("warning: ", raw_ostream::MAGENTA);
+  *ErrorOS << Msg << "\n";
 }
 
 void elf::error(const Twine &Msg) {
   std::lock_guard<std::mutex> Lock(Mu);
 
   if (Config->ErrorLimit == 0 || ErrorCount < Config->ErrorLimit) {
-    *ErrorOS << Argv0 << ": error: " << Msg << "\n";
+    print("error: ", raw_ostream::RED);
+    *ErrorOS << Msg << "\n";
   } else if (ErrorCount == Config->ErrorLimit) {
-    *ErrorOS << Argv0 << ": error: too many errors emitted, stopping now"
+    print("error: ", raw_ostream::RED);
+    *ErrorOS << "too many errors emitted, stopping now"
              << " (use -error-limit=0 to see all errors)\n";
     if (Config->ExitEarly)
       exitLld(1);
   }
 
   ++ErrorCount;
 }
 

ELF/Options.td

 def Ttext: S<"Ttext">, HelpText<"Same as --section-start with .text as the sectionname">;
 
 def allow_multiple_definition: F<"allow-multiple-definition">,
   HelpText<"Allow multiple definitions">;
 
 def as_needed: F<"as-needed">,
   HelpText<"Only set DT_NEEDED for shared libraries if used">;
 
+def color_diagnostics: S<"color-diagnostics">,
+  HelpText<"Use colors in diagnostics">;
+
 def disable_new_dtags: F<"disable-new-dtags">,
   HelpText<"Disable new dynamic tags">;
 
 def discard_all: F<"discard-all">, HelpText<"Delete all local symbols">;
 
 def discard_locals: F<"discard-locals">,
   HelpText<"Delete temporary local symbols">;
 

 def m: JoinedOrSeparate<["-"], "m">, HelpText<"Set target emulation">;
 
 def nostdlib: F<"nostdlib">,
   HelpText<"Only search directories specified on the command line">;
 
 def no_as_needed: F<"no-as-needed">,
   HelpText<"Always DT_NEEDED for shared libraries">;
 
+def no_color_diagnostics: F<"no-color-diagnostics">,
+  HelpText<"Do not use colors in diagnostics">;
+
 def no_demangle: F<"no-demangle">,
   HelpText<"Do not demangle symbol names">;
 
 def no_gc_sections: F<"no-gc-sections">,
   HelpText<"Disable garbage collection of unused sections">;
 
 def no_gnu_unique: F<"no-gnu-unique">,
   HelpText<"Disable STB_GNU_UNIQUE symbol binding">;

 // Aliases
 def alias_auxiliary: Separate<["-"], "f">, Alias<auxiliary>;
 def alias_Bdynamic_call_shared: F<"call_shared">, Alias<Bdynamic>;
 def alias_Bdynamic_dy: F<"dy">, Alias<Bdynamic>;
 def alias_Bstatic_dn: F<"dn">, Alias<Bstatic>;
 def alias_Bstatic_non_shared: F<"non_shared">, Alias<Bstatic>;
 def alias_Bstatic_static: F<"static">, Alias<Bstatic>;
 def alias_L__library_path: J<"library-path=">, Alias<L>;
+def alias_color_diagnostics: J<"color-diagnostics=">, Alias<color_diagnostics>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
 def alias_dynamic_list: J<"dynamic-list=">, Alias<dynamic_list>;
 def alias_entry_e: JoinedOrSeparate<["-"], "e">, Alias<entry>;
 def alias_entry_entry: J<"entry=">, Alias<entry>;
 def alias_error_limit: J<"error-limit=">, Alias<error_limit>;
 def alias_export_dynamic_E: Flag<["-"], "E">, Alias<export_dynamic>;
 def alias_export_dynamic_symbol: J<"export-dynamic-symbol=">,

test/ELF/color-diagnostics.test

+# Windows command prompt doesn't suport ANSI escape sequnces.
+# REQUIRES: shell
+
+# RUN: not ld.lld -color-diagnostics=always /nosuchfile 2>&1 \
+# RUN:   | FileCheck -check-prefix=COLOR %s
+
+# COLOR: {{^.\[0;1;37m.*/ld.lld: .\[0;1;31merror: .\[0mcannot open /nosuchfile}}
+
+# RUN: not ld.lld -color-diagnostics=always -no-color-diagnostics /nosuchfile 2>&1 \
+# RUN:   | FileCheck -check-prefix=NOCOLOR %s
+
+# NOCOLOR: ld.lld: error: cannot open /nosuchfile