[lld] Enable Visual Studio compatible output

[chrisjackson]

Summary

This builds a little on @ikudrin's diff D50560 which was a much improved version of D47540. I have attempted to take into account the comments on those diffs.

Adds diagnostic output functions to enable Visual Studio
compatibility with the flag --vs-diagnostics. Clang has a
flag which enables similar support, see
"-fdiagnostics-format=clang/msvc/vi" described
in https://clang.llvm.org/docs/UsersManual.html.
The existing diagnostics output format for warning and error messages is
not fully compatible with Visual Studio (VS) and can even cause VS to become
unresponsive.

The format accepted by VS
(https://msdn.microsoft.com/en-us/library/yxkt8b26.aspx):

{filename (line# [, column#]) | toolname} : [any text] {error | warning}
code####:localizable string [ any text ]

or more simply:

Origin : {warning|error} code#### : Message

The current default lld format uses the lld executable path for Origin.
Clicking the message inside VS will lead to a hang or long delay as VS
attempts to access the executable as a source code origin. Additionally, the
line and column information accepted by VS differs from the lld format.

[aganea]

Common/ErrorHandler.cpp

143

Could you please use clang-format on the whole patch? (only changed lines)

[ruiu]

I think we need to be very careful how to implement the feature. Currently it is very easy to understand what lld prints out as an error message and how to construct an error message. Basically, what you see in the source code is what you get at runtime. This patch added an abstraction layer between the current code and stderr, and now it is not easy to figure out what is the actual output and how to construct a desired error message.

If we have no choice other than implementing two different error format styles, the cost of abstraction can be justified. Everybody would understand why we would have to abstract an error message so that they are outputted in an appropriate format. However, frankly speaking, MSVC-compatible error output is a nice-to-have for lld/ELF but for most lld/ELF users that's not something they care about too much. It wouldn't be wrong to expect that the current error message format remains as "primary" and the MSVC-style output remains as a distant number two.So I'm not personally happy to add an abstraction layer to support both. I'd like to search for a way to implement the MSVC-style error message in such a way that that doesn't complicate the normal execution pass.

I remember we had a similar discussion when we were talking about how to add MinGW support to lld. One way of doing it was to directly add MinGW support to lld/coff, so that lld-link works both as a MSVC link.exe and a MinGW linker. That way, both the existing lld/coff and lld/mingw pays the cost of supporting the abstraction cost of supporting lld/mingw, but that didn't look like a good design choice given that the need for lld/mingw is not as large as lld/coff. We ended up having a good compromise, which is, implementing lld/mingw as a wrapper to lld/coff by translating GNU-ish command line options to Windows-ish ones and then call the entry point function of lld/coff. That was less intrusive than directly adding a mingw support.

So I think we should do something similar for supporting MSVC-style error message, instead of fully abstracting the error message so that they can be output in any format.

I'd propose detecting error message patterns in error() and textually replacing it, so that the actual output becomes the MSVC style. I believe that would work for most cases. If there's an error message that doesn't work well with the textual conversion approach, we could change the original error message so that it is easy to handle by a text matcher. It may not look very "clean" approach, and it may even look a dumb approach, but I'd like to choose the dumb one if it works for the sake of code readability.

[chrisjackson]

Used clang-format-diff against the patch is requested by @aganea.

[aganea]

I like @ruiu 's suggestion in D58484, it is simple and elegant. We don't need performance there, so a regex is fine.
In both cases, yours and @ruiu 's, it would be good to demonstrate usage in the COFF driver as well.
There will be less changes to the LLD codebase with the regex approach. More code changes/additions means more maintenance in the long term.
What do you think on building on @ruiu 's proposal, Chris?

Common/ErrorHandler.cpp

148

There are a lot of new functions here, and it is not immediately clear which ones should be used. I fail to see at first sight which APIs to use when I want to report errors. Before, they were local to a TU, and maybe more specific for certain use-cases. Probably adding some comments and/or usage examples here would help. However - please see my other comment before doing that.

[chrisjackson]

In D58300#1408954, @aganea wrote:

I like @ruiu 's suggestion in D58484, it is simple and elegant. We don't need performance there, so a regex is fine.
In both cases, yours and @ruiu 's, it would be good to demonstrate usage in the COFF driver as well.
There will be less changes to the LLD codebase with the regex approach. More code changes/additions means more maintenance in the long term.
What do you think on building on @ruiu 's proposal, Chris?

I intend to extend Rui's example to pass a couple of the existing tests and see how it works out. I'll comment more on this at D58484.

[chrisjackson]

The diagnostics were implemented in D58484.

Common/ErrorHandler.cpp

 //===- ErrorHandler.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/ErrorHandler.h"
-
 #include "lld/Common/Threads.h"
+#include "llvm/Support/Path.h"
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <mutex>
 
void lld::diagnosticHandler(const DiagnosticInfo &DI) {
   }
 }
 
 void lld::checkError(Error E) {
   handleAllErrors(std::move(E),
                   [&](ErrorInfoBase &EIB) { error(EIB.message()); });
 }
 
-void ErrorHandler::print(StringRef S, raw_ostream::Colors C) {
-  *ErrorOS << LogName << ": ";
+void ErrorHandler::print(const Twine &Orig, StringRef S, raw_ostream::Colors C,
+                         const Twine &Msg) {
+  newline(ErrorOS, Msg);
+  *ErrorOS << Orig << ": ";
   if (ColorDiagnostics) {
     ErrorOS->changeColor(C, true);
     *ErrorOS << S;
     ErrorOS->resetColor();
   } else {
     *ErrorOS << S;
   }
+  *ErrorOS << Msg << "\n";
 }
 
-void ErrorHandler::log(const Twine &Msg) {
+void ErrorHandler::log(const Twine &Orig, const Twine &Msg) {
   if (Verbose) {
     std::lock_guard<std::mutex> Lock(Mu);
-    *ErrorOS << LogName << ": " << Msg << "\n";
+    *ErrorOS << Orig << ": " << Msg << "\n";
   }
 }
 
 void ErrorHandler::message(const Twine &Msg) {
   std::lock_guard<std::mutex> Lock(Mu);
   outs() << Msg << "\n";
   outs().flush();
 }
 
-void ErrorHandler::warn(const Twine &Msg) {
+void ErrorHandler::warn(const Twine &Orig, const Twine &Msg) {
   if (FatalWarnings) {
-    error(Msg);
+    error(Orig, Msg);
     return;
   }
-
   std::lock_guard<std::mutex> Lock(Mu);
-  newline(ErrorOS, Msg);
-  print("warning: ", raw_ostream::MAGENTA);
-  *ErrorOS << Msg << "\n";
+  print(Orig, "warning: ", raw_ostream::MAGENTA, Msg);
 }
 
-void ErrorHandler::error(const Twine &Msg) {
+void ErrorHandler::error(const Twine &Orig, const Twine &Msg) {
   std::lock_guard<std::mutex> Lock(Mu);
-  newline(ErrorOS, Msg);
 
-  if (ErrorLimit == 0 || ErrorCount < ErrorLimit) {
-    print("error: ", raw_ostream::RED);
-    *ErrorOS << Msg << "\n";
-  } else if (ErrorCount == ErrorLimit) {
-    print("error: ", raw_ostream::RED);
-    *ErrorOS << ErrorLimitExceededMsg << "\n";
+  if (ErrorLimit == 0 || ErrorCount < ErrorLimit)
+    print(Orig, "error: ", raw_ostream::RED, Msg);
+  else if (ErrorCount == ErrorLimit) {
+    print(LogName, "error: ", raw_ostream::RED, ErrorLimitExceededMsg);
     if (ExitEarly)
       exitLld(1);
   }
 
   ++ErrorCount;
 }
 
-void ErrorHandler::fatal(const Twine &Msg) {
-  error(Msg);
+void ErrorHandler::fatal(const Twine &Orig, const Twine &Msg) {
+  error(Orig, Msg);
   exitLld(1);
 }
+
+ObjLocation lld::makeScriptObjLocation(StringRef Script) {
+  ObjLocation Result;
+  Result.File = Script;
+  return Result;
+}
+
+ObjLocation lld::makeSymbolObjLocation(StringRef Archive, StringRef File,
+                                       StringRef Sym) {
+  ObjLocation Result;
+  Result.Archive = Archive;
+  Result.File = File;
+  Result.Sym = Sym;
+  return Result;
+}
+
+ObjLocation lld::makeSectionObjLocation(StringRef Archive, StringRef File,
+                                        StringRef Sec, uint64_t Off) {
+  ObjLocation Result;
+  Result.Archive = Archive;
+  Result.File = File;
+  Result.Sec = Sec;
+  Result.Off = Off;
+  return Result;
+}
+
+SrcLocation lld::makeSrcLocation(StringRef File, unsigned Line) {
+  SrcLocation Result;
+  Result.Path = File.str();
+  Result.Line = Line;
+  return Result;
+}
+
+SrcLocation lld::makeSrcLocationOnlyFile(StringRef File) {
+  SrcLocation Result;
+  Result.Path = File.str();
+  return Result;
+}
+
+static bool hasLineNumber(const ObjLocation &ObjLoc) {
+  return !ObjLoc.Sym.empty() || !ObjLoc.Sec.empty();
+}
+
+static bool hasLineNumber(const SrcLocation &SrcLoc) {
+  return SrcLoc.Line.hasValue();
+}
+
+// Based on createFileLineMsg (InputFiles.cpp)
+static std::string getNativeSrcLocTxt(const SrcLocation &SrcLoc) {
+  if (!hasLineNumber(SrcLoc))
+    return SrcLoc.Path;
+  std::string Filename = llvm::sys::path::filename(SrcLoc.Path);
+  std::string Lineno = ":" + std::to_string(SrcLoc.Line.getValue());
+  if (Filename == SrcLoc.Path)
+    return Filename + Lineno;
+  return Filename + Lineno + " (" + SrcLoc.Path + Lineno + ")";
+}
+
+static std::string getVSSrcLocTxt(const SrcLocation &SrcLoc) {
+  if (!hasLineNumber(SrcLoc))
+    return SrcLoc.Path;
+  return SrcLoc.Path + "(" + std::to_string(SrcLoc.Line.getValue()) + ")";
+}
+
+// Based on InputSectionBase::getObjMsg()
+static std::string getObjLocTxt(const ObjLocation &ObjLoc) {
+  std::string Details;
+  if (!ObjLoc.Sym.empty())
+    Details = ":(" + ObjLoc.Sym + ")";
+  else if (!ObjLoc.Sec.empty())
+    Details =
+        (":(" + ObjLoc.Sec + "+0x" + llvm::utohexstr(ObjLoc.Off) + ")").str();
+
+  if (ObjLoc.Archive.empty())
+    return (ObjLoc.File + Details).str();
+
+  if (Details.empty())
+    return (ObjLoc.Archive + "(" + ObjLoc.File + ")").str();
+
+  return (ObjLoc.File + Details + " in archive " + ObjLoc.Archive).str();
+}
+
+static std::string getNativeDefinedTxt(const SymbolLocation *SymLoc) {
+  std::string Result;
+  if (!SymLoc)
+    return Result;
+
+  if ((SymLoc->SrcLoc && hasLineNumber(SymLoc->SrcLoc.getValue())) ||
+      (!SymLoc->SrcLoc && hasLineNumber(SymLoc->ObjLoc)))
+    Result = "\n>>> defined at ";
+  else
+    Result = "\n>>> defined in ";
+
+  if (SymLoc->SrcLoc)
+    Result +=
+        getNativeSrcLocTxt(SymLoc->SrcLoc.getValue()) + "\n>>>            ";
+
+  Result += getObjLocTxt(SymLoc->ObjLoc);
+  return Result;
+}
+
+static std::string getVSDefinedTxt(const SymbolLocation *SymLoc) {
+  std::string Result;
+  if (!SymLoc)
+    return Result;
+
+  // if the source location with a line number exists, it is already printed
+  // in the front of the message.
+  if (SymLoc->SrcLoc && !hasLineNumber(SymLoc->SrcLoc.getValue()))
+    Result += "\n>>> defined in " + getVSSrcLocTxt(SymLoc->SrcLoc.getValue()) +
+              "\n>>>            ";
+  else if (hasLineNumber(SymLoc->ObjLoc))
+    Result = "\n>>> defined at ";
+  else
+    Result = "\n>>> defined in ";
+
+  Result += getObjLocTxt(SymLoc->ObjLoc);
+  return Result;
+}
+
+static std::string getNativeReferencedTxt(const SymbolLocation *SymLoc) {
+  std::string Result;
+  if (!SymLoc)
+    return Result;
+
+  Result = "\n>>> referenced by ";
+  if (SymLoc->SrcLoc)
+    Result +=
+        getNativeSrcLocTxt(SymLoc->SrcLoc.getValue()) + "\n>>>               ";
+  Result += getObjLocTxt(SymLoc->ObjLoc);
+  return Result;
+}
+
+static std::string getVSReferencedTxt(const SymbolLocation *SymLoc) {
+  std::string Result;
+  if (!SymLoc)
+    return Result;
+
+  Result = "\n>>> referenced by ";
+  // if the source location with a line number exists, it is already printed
+  // in the front of the message.
+  if (SymLoc->SrcLoc && !hasLineNumber(SymLoc->SrcLoc.getValue()))
+    Result +=
+        getVSSrcLocTxt(SymLoc->SrcLoc.getValue()) + "\n>>>               ";
+  Result += getObjLocTxt(SymLoc->ObjLoc);
+  return Result;
+}
+
+static std::string getMsg(const Diagnostic &C, unsigned index) {
+  if (!errorHandler().VSDiagnostics)
+    return (C.Msg + getNativeDefinedTxt(C.Defined[0]) +
+            getNativeDefinedTxt(C.Defined[1]) +
+            getNativeReferencedTxt(C.Referenced))
+        .str();
+  return (C.Msg + getVSDefinedTxt(C.Defined[index]) +
+          getVSReferencedTxt(C.Referenced))
+      .str();
+}
+
+static std::string getOrig(const Diagnostic &C, unsigned index) {
+  if (!errorHandler().VSDiagnostics)
+    return errorHandler().LogName;
+  const SymbolLocation *Loc = C.Referenced ? C.Referenced : C.Defined[index];
+  if (!Loc || !Loc->SrcLoc || !hasLineNumber(Loc->SrcLoc.getValue()))
+    return errorHandler().LogName;
+  return getVSSrcLocTxt(Loc->SrcLoc.getValue());
+}
+
+static unsigned reportCount(const Diagnostic &diagnostic) {
+  if (errorHandler().VSDiagnostics && diagnostic.Defined[1])
+    return 2;
+  return 1;
+}
+
+void lld::warn(Diagnostic const &C) {
+  for (unsigned I = 0; I < reportCount(C); ++I)
+    errorHandler().warn(getOrig(C, I), getMsg(C, I));
+}
+
+void lld::error(Diagnostic const &C) {
+  for (unsigned I = 0; I < reportCount(C); ++I)
+    errorHandler().error(getOrig(C, I), getMsg(C, I));
+}

ELF/Config.h

 extern Configuration *Config;
 
 static inline void errorOrWarn(const Twine &Msg) {
   if (!Config->NoinhibitExec)
     error(Msg);
   else
     warn(Msg);
 }
+
+static inline void errorOrWarn(const Diagnostic &diagnostic) {
+  if (!Config->NoinhibitExec)
+    error(diagnostic);
+  else
+    warn(diagnostic);
+}
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.cpp

 }
 
 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   errorHandler().Verbose = Args.hasArg(OPT_verbose);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
+  errorHandler().VSDiagnostics = Args.hasArg(OPT_visual_studio_diagnostics_format);
 
   Config->AllowMultipleDefinition =
       Args.hasFlag(OPT_allow_multiple_definition,
                    OPT_no_allow_multiple_definition, false) ||
       hasZOption(Args, "muldefs");
   Config->AllowShlibUndefined =
       Args.hasFlag(OPT_allow_shlib_undefined, OPT_no_allow_shlib_undefined,
                    Args.hasArg(OPT_shared));

ELF/InputFiles.h

 class InputSectionBase;
 }
 
 // Returns "<internal>", "foo.a(bar.o)" or "baz.o".
 std::string toString(const elf::InputFile *F);
 
 namespace elf {
 
+ObjLocation toObjLoc(const elf::InputFile *F);
+
 using llvm::object::Archive;
 
 class Symbol;
 
 // If -reproduce option is given, all input files are written
 // to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> Tar;
 
public:
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint8_t OSABI = 0;
   uint8_t ABIVersion = 0;
 
   // Cache for toString(). Only toString() should use this member.
   mutable std::string ToStringCache;
 
-  std::string getSrcMsg(const Symbol &Sym, InputSectionBase &Sec,
-                        uint64_t Offset);
+  llvm::Optional<SrcLocation> getSrcLoc(const Symbol &Sym,
+                                        InputSectionBase &Sec, uint64_t Offset);
 
   // True if this is an argument for --just-symbols. Usually false.
   bool JustSymbols = false;
 
   // On PPC64 we need to keep track of which files contain small code model
   // relocations that access the .toc section. To minimize the chance of a
   // relocation overflow, files that do contain said relocations should have
   // their .toc sections sorted closer to the .got section than files that do

ELF/InputFiles.cpp

Optional<MemoryBufferRef> elf::readFile(StringRef Path) {
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   if (Tar)
     Tar->append(relativeToRoot(Path), MBRef.getBuffer());
   return MBRef;
 }
 
-// Concatenates arguments to construct a string representing an error location.
-static std::string createFileLineMsg(StringRef Path, unsigned Line) {
-  std::string Filename = path::filename(Path);
-  std::string Lineno = ":" + std::to_string(Line);
-  if (Filename == Path)
-    return Filename + Lineno;
-  return Filename + Lineno + " (" + Path.str() + Lineno + ")";
-}
-
 template <class ELFT>
-static std::string getSrcMsgAux(ObjFile<ELFT> &File, const Symbol &Sym,
-                                InputSectionBase &Sec, uint64_t Offset) {
+static Optional<SrcLocation>
+getSrcLocAux(ObjFile<ELFT> &File, const Symbol &Sym, InputSectionBase &Sec,
+             uint64_t Offset) {
   // In DWARF, functions and variables are stored to different places.
   // First, lookup a function for a given offset.
   if (Optional<DILineInfo> Info = File.getDILineInfo(&Sec, Offset))
-    return createFileLineMsg(Info->FileName, Info->Line);
+    return makeSrcLocation(Info->FileName, Info->Line);
 
   // If it failed, lookup again as a variable.
   if (Optional<std::pair<std::string, unsigned>> FileLine =
           File.getVariableLoc(Sym.getName()))
-    return createFileLineMsg(FileLine->first, FileLine->second);
+    return makeSrcLocation(FileLine->first, FileLine->second);
 
   // File.SourceFile contains STT_FILE symbol, and that is a last resort.
-  return File.SourceFile;
+  if (!File.SourceFile.empty())
+    return makeSrcLocationOnlyFile(File.SourceFile);
+
+  return None;
 }
 
-std::string InputFile::getSrcMsg(const Symbol &Sym, InputSectionBase &Sec,
+llvm::Optional<SrcLocation> InputFile::getSrcLoc(const Symbol &Sym,
+                                                 InputSectionBase &Sec,
                                                  uint64_t Offset) {
   if (kind() != ObjKind)
-    return "";
+    return None;
   switch (Config->EKind) {
   default:
     llvm_unreachable("Invalid kind");
   case ELF32LEKind:
-    return getSrcMsgAux(cast<ObjFile<ELF32LE>>(*this), Sym, Sec, Offset);
+    return getSrcLocAux(cast<ObjFile<ELF32LE>>(*this), Sym, Sec, Offset);
   case ELF32BEKind:
-    return getSrcMsgAux(cast<ObjFile<ELF32BE>>(*this), Sym, Sec, Offset);
+    return getSrcLocAux(cast<ObjFile<ELF32BE>>(*this), Sym, Sec, Offset);
   case ELF64LEKind:
-    return getSrcMsgAux(cast<ObjFile<ELF64LE>>(*this), Sym, Sec, Offset);
+    return getSrcLocAux(cast<ObjFile<ELF64LE>>(*this), Sym, Sec, Offset);
   case ELF64BEKind:
-    return getSrcMsgAux(cast<ObjFile<ELF64BE>>(*this), Sym, Sec, Offset);
+    return getSrcLocAux(cast<ObjFile<ELF64BE>>(*this), Sym, Sec, Offset);
   }
 }
 
 template <class ELFT> void ObjFile<ELFT>::initializeDwarf() {
   Dwarf = llvm::make_unique<DWARFContext>(make_unique<LLDDwarfObj<ELFT>>(this));
   for (std::unique_ptr<DWARFUnit> &CU : Dwarf->compile_units()) {
     auto Report = [](Error Err) {
       handleAllErrors(std::move(Err),
if (F->ToStringCache.empty()) {
     if (F->ArchiveName.empty())
       F->ToStringCache = F->getName();
     else
       F->ToStringCache = (F->ArchiveName + "(" + F->getName() + ")").str();
   }
   return F->ToStringCache;
 }
 
+ObjLocation elf::toObjLoc(const elf::InputFile *F) {
+  ObjLocation Result;
+  if (F) {
+    Result.File = F->getName();
+    Result.Archive = F->ArchiveName;
+  } else
+    Result.File = "<internal>";
+  return Result;
+}
+
 template <class ELFT>
 ELFFileBase<ELFT>::ELFFileBase(Kind K, MemoryBufferRef MB) : InputFile(K, MB) {
   if (ELFT::TargetEndianness == support::little)
     EKind = ELFT::Is64Bits ? ELF64LEKind : ELF32LEKind;
   else
     EKind = ELFT::Is64Bits ? ELF64BEKind : ELF32BEKind;
 
   EMachine = getObj().getHeader()->e_machine;

ELF/InputSection.h

public:
 
   // Get the function symbol that encloses this offset from within the
   // section.
   template <class ELFT>
   Defined *getEnclosingFunction(uint64_t Offset);
 
   // Returns a source location string. Used to construct an error message.
   template <class ELFT> std::string getLocation(uint64_t Offset);
-  std::string getSrcMsg(const Symbol &Sym, uint64_t Offset);
   std::string getObjMsg(uint64_t Offset);
+  SymbolLocation getSymLoc(const Symbol &Sym, uint64_t Offset);
+  ObjLocation getObjLoc(uint64_t Offset);
 
   // Each section knows how to relocate itself. These functions apply
   // relocations, assuming that Buf points to this section's copy in
   // the mmap'ed output buffer.
   template <class ELFT> void relocate(uint8_t *Buf, uint8_t *BufEnd);
   void relocateAlloc(uint8_t *Buf, uint8_t *BufEnd);
 
   // The native ELF reloc data type is not very convenient to handle.

ELF/InputSection.cpp

std::string InputSectionBase::getLocation(uint64_t Offset) {
 
   if (Defined *D = getEnclosingFunction<ELFT>(Offset))
     return SrcFile + ":(function " + toString(*D) + ": " + SecAndOffset + ")";
 
   // If there's no symbol, print out the offset in the section.
   return (SrcFile + ":(" + SecAndOffset + ")");
 }
 
-// This function is intended to be used for constructing an error message.
-// The returned message looks like this:
-//
-//   foo.c:42 (/home/alice/possibly/very/long/path/foo.c:42)
-//
-//  Returns an empty string if there's no way to get line info.
-std::string InputSectionBase::getSrcMsg(const Symbol &Sym, uint64_t Offset) {
-  return File->getSrcMsg(Sym, *this, Offset);
-}
-
 // Returns a filename string along with an optional section name. This
 // function is intended to be used for constructing an error
 // message. The returned message looks like this:
 //
 //   path/to/foo.o:(function bar)
 //
 // or
 //
if (auto *D = dyn_cast<Defined>(B))
       if (D->Section == this && D->Value <= Off && Off < D->Value + D->Size)
         return Filename + ":(" + toString(*D) + ")" + Archive;
 
   // If there's no symbol, print out the offset in the section.
   return (Filename + ":(" + Name + "+0x" + utohexstr(Off) + ")" + Archive)
       .str();
 }
 
+ObjLocation InputSectionBase::getObjLoc(uint64_t Off) {
+  // Find a symbol that encloses a given location.
+  for (Symbol *B : File->getSymbols())
+    if (auto *D = dyn_cast<Defined>(B))
+      if (D->Section == this && D->Value <= Off && Off < D->Value + D->Size)
+        return makeSymbolObjLocation(File->ArchiveName, File->getName(),
+                                     toString(*D));
+
+  return makeSectionObjLocation(File->ArchiveName, File->getName(), Name, Off);
+}
+
+SymbolLocation InputSectionBase::getSymLoc(const Symbol &Sym, uint64_t Off) {
+  return SymbolLocation(getObjLoc(Off), File->getSrcLoc(Sym, *this, Off));
+}
+
 InputSection InputSection::Discarded(nullptr, 0, 0, 0, ArrayRef<uint8_t>(), "");
 
 InputSection::InputSection(InputFile *F, uint64_t Flags, uint32_t Type,
                            uint32_t Alignment, ArrayRef<uint8_t> Data,
                            StringRef Name, Kind K)
     : InputSectionBase(F, Flags, Type,
                        /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Alignment, Data,
                        Name, K) {}

ELF/Options.td

defm whole_archive: B<"whole-archive",
     "Do not force load of all members in a static library (default)">;
 
 defm wrap: Eq<"wrap", "Use wrapper functions for symbol">,
   MetaVarName<"<symbol>=<symbol>">;
 
 def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
+def visual_studio_diagnostics_format : F<"vs-diagnostics">,
+  HelpText<"Format diagnostics for Visual Studio compatiblity">;
+
 // Aliases
 def: Separate<["-"], "f">, Alias<auxiliary>, HelpText<"Alias for --auxiliary">;
 def: F<"call_shared">, Alias<Bdynamic>, HelpText<"Alias for --Bdynamic">;
 def: F<"dy">, Alias<Bdynamic>, HelpText<"Alias for --Bdynamic">;
 def: F<"dn">, Alias<Bstatic>, HelpText<"Alias for --Bstatic">;
 def: F<"non_shared">, Alias<Bstatic>, HelpText<"Alias for --Bstatic">;
 def: F<"static">, Alias<Bstatic>, HelpText<"Alias for --Bstatic">;
 def: Flag<["-"], "d">, Alias<define_common>, HelpText<"Alias for --define-common">;

ELF/Relocations.cpp

 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
-static Optional<std::string> getLinkerScriptLocation(const Symbol &Sym) {
-  for (BaseCommand *Base : Script->SectionCommands)
-    if (auto *Cmd = dyn_cast<SymbolAssignment>(Base))
-      if (Cmd->Sym == &Sym)
-        return Cmd->Location;
-  return None;
-}
-
-// Construct a message in the following format.
-//
-// >>> defined in /home/alice/src/foo.o
-// >>> referenced by bar.c:12 (/home/alice/src/bar.c:12)
-// >>>               /home/alice/src/bar.o:(.text+0x1)
-static std::string getLocation(InputSectionBase &S, const Symbol &Sym,
-                               uint64_t Off) {
-  std::string Msg = "\n>>> defined in ";
-  if (Sym.File)
-    Msg += toString(Sym.File);
-  else if (Optional<std::string> Loc = getLinkerScriptLocation(Sym))
-    Msg += *Loc;
-
-  Msg += "\n>>> referenced by ";
-  std::string Src = S.getSrcMsg(Sym, Off);
-  if (!Src.empty())
-    Msg += Src + "\n>>>               ";
-  return Msg + S.getObjMsg(Off);
-}
-
 namespace {
 // Build a bitmask with one bit set for each RelExpr.
 //
 // Constexpr function arguments can't be used in static asserts, so we
 // use template arguments to build the mask.
 // But function template partial specializations don't exist (needed
 // for base case of the recursion), so we need a dummy struct.
 template <RelExpr... Exprs> struct RelExprMaskBuilder {

 
 // True if this expression is of the form Sym - X, where X is a position in the
 // file (PC, or GOT for example).
 static bool isRelExpr(RelExpr Expr) {
   return oneof<R_PC, R_GOTREL, R_GOTREL_FROM_END, R_MIPS_GOTREL, R_PPC_CALL,
                R_PPC_CALL_PLT, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC>(Expr);
 }
 
+static llvm::Optional<std::string> getLinkerScriptLocation(const Symbol &Sym) {
+  for (BaseCommand *Base : Script->SectionCommands)
+    if (auto *Cmd = dyn_cast<SymbolAssignment>(Base))
+      if (Cmd->Sym == &Sym)
+        return Cmd->Location;
+  return llvm::None;
+}
+
 // Returns true if a given relocation can be computed at link-time.
 //
 // For instance, we know the offset from a relocation to its target at
 // link-time if the relocation is PC-relative and refers a
 // non-interposable function in the same executable. This function
 // will return true for such relocation.
 //
 // If this function returns false, that means we need to emit a
static bool isStaticLinkTimeConstant(RelExpr E, RelType Type, const Symbol &Sym,
   // with a comparison, which will load a zero from the GOT.
   // Another special case is MIPS _gp_disp symbol which represents offset
   // between start of a function and '_gp' value and defined as absolute just
   // to simplify the code.
   assert(AbsVal && RelE);
   if (Sym.isUndefWeak())
     return true;
 
-  error("relocation " + toString(Type) + " cannot refer to absolute symbol: " +
-        toString(Sym) + getLocation(S, Sym, RelOff));
+  lld::ObjLocation loc;
+  std::string script;
+  if (Sym.File) {
+    loc = toObjLoc(Sym.File);
+  } else {
+    script = getLinkerScriptLocation(Sym).getValue();
+    loc = makeScriptObjLocation(script);
+  }
+
+  error(Diagnostic("relocation " + toString(Type) +
+                       " cannot refer to absolute symbol: " + toString(Sym),
+                   definedAt(loc), referencedBy(S.getSymLoc(Sym, RelOff))));
+
   return true;
 }
 
 static RelExpr toPlt(RelExpr Expr) {
   switch (Expr) {
   case R_PPC_CALL:
     return R_PPC_CALL_PLT;
   case R_PC:
static bool maybeReportUndefined(Symbol &Sym, InputSectionBase &Sec,
   if (Sym.isLocal() || !Sym.isUndefined() || Sym.isWeak())
     return false;
 
   bool CanBeExternal =
       Sym.computeBinding() != STB_LOCAL && Sym.Visibility == STV_DEFAULT;
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore && CanBeExternal)
     return false;
 
-  std::string Msg =
-      "undefined symbol: " + toString(Sym) + "\n>>> referenced by ";
-
-  std::string Src = Sec.getSrcMsg(Sym, Offset);
-  if (!Src.empty())
-    Msg += Src + "\n>>>               ";
-  Msg += Sec.getObjMsg(Offset);
+  const SymbolLocation &SymLoc = Sec.getSymLoc(Sym, Offset);
+  std::string Msg = "undefined symbol: " + toString(Sym);
 
   if (Sym.getName().startswith("_ZTV"))
     Msg += "\nthe vtable symbol may be undefined because the class is missing "
            "its key function (see https://lld.llvm.org/missingkeyfunction)";
 
   if ((Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal) ||
       Config->NoinhibitExec) {
-    warn(Msg);
+    warn(Diagnostic(Msg, referencedBy(SymLoc)));
     return false;
   }
 
-  error(Msg);
+  error(Diagnostic(Msg, referencedBy(SymLoc)));
   return true;
 }
 
 // MIPS N32 ABI treats series of successive relocations with the same offset
 // as a single relocation. The similar approach used by N64 ABI, but this ABI
 // packs all relocations into the single relocation record. Here we emulate
 // this for the N32 ABI. Iterate over relocation with the same offset and put
 // theirs types into the single bit-set.
-template <class RelTy> static RelType getMipsN32RelType(RelTy *&Rel, RelTy *End) {
+template <class RelTy>
+static RelType getMipsN32RelType(RelTy *&Rel, RelTy *End) {
   RelType Type = 0;
   uint64_t Offset = Rel->r_offset;
 
   int N = 0;
   while (Rel != End && Rel->r_offset == Offset)
     Type |= (Rel++)->getType(Config->IsMips64EL) << (8 * N++);
   return Type;
 }
static void processRelocAux(InputSectionBase &Sec, RelExpr Expr, RelType Type,
   // If the relocation is to a weak undef, and we are producing
   // executable, give up on it and produce a non preemptible 0.
   if (!Config->Shared && Sym.isUndefWeak()) {
     Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return;
   }
 
   if (!CanWrite && (Config->Pic && !isRelExpr(Expr))) {
-    error(
+    error(Diagnostic(
         "can't create dynamic relocation " + toString(Type) + " against " +
-        (Sym.getName().empty() ? "local symbol" : "symbol: " + toString(Sym)) +
+            (Sym.getName().empty() ? "local symbol"
+                                   : "symbol: " + toString(Sym)) +
             " in readonly segment; recompile object files with -fPIC "
-        "or pass '-Wl,-z,notext' to allow text relocations in the output" +
-        getLocation(Sec, Sym, Offset));
+            "or pass '-Wl,-z,notext' to allow text relocations in the output",
+        definedAt(toObjLoc(Sym.File)),
+        referencedBy(Sec.getSymLoc(Sym, Offset))));
     return;
   }
 
   // Copy relocations are only possible if we are creating an executable.
   if (Config->Shared) {
-    errorOrWarn("relocation " + toString(Type) +
-                " cannot be used against symbol " + toString(Sym) +
-                "; recompile with -fPIC" + getLocation(Sec, Sym, Offset));
+    errorOrWarn(Diagnostic("relocation " + toString(Type) +
+                               " cannot be used against symbol " +
+                               toString(Sym) + "; recompile with -fPIC",
+                           definedAt(toObjLoc(Sym.File)),
+                           referencedBy(Sec.getSymLoc(Sym, Offset))));
     return;
   }
 
   // If the symbol is undefined we already reported any relevant errors.
   if (Sym.isUndefined())
     return;
 
   if (!canDefineSymbolInExecutable(Sym)) {
-    error("cannot preempt symbol: " + toString(Sym) +
-          getLocation(Sec, Sym, Offset));
+    error(Diagnostic("cannot preempt symbol: " + toString(Sym),
+                     definedAt(toObjLoc(Sym.File)),
+                     referencedBy(Sec.getSymLoc(Sym, Offset))));
     return;
   }
 
   if (Sym.isObject()) {
     // Produce a copy relocation.
     if (auto *SS = dyn_cast<SharedSymbol>(&Sym)) {
       if (!Config->ZCopyreloc)
-        error("unresolvable relocation " + toString(Type) +
+        error(
+            Diagnostic("unresolvable relocation " + toString(Type) +
                            " against symbol '" + toString(*SS) +
-              "'; recompile with -fPIC or remove '-z nocopyreloc'" +
-              getLocation(Sec, Sym, Offset));
+                           "'; recompile with -fPIC or remove '-z nocopyreloc'",
+                       definedAt(toObjLoc(Sym.File)),
+                       referencedBy(Sec.getSymLoc(Sym, Offset))));
       addCopyRelSymbol<ELFT>(*SS);
     }
     Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return;
   }
 
   if (Sym.isFunc()) {
     // This handles a non PIC program call to function in a shared library. In
if (Sym.isFunc()) {
 
     // For position independent executable on i386, the plt entry requires ebx
     // to be set. This causes two problems:
     // * If some code has a direct reference to a function, it was probably
     //   compiled without -fPIE/-fPIC and doesn't maintain ebx.
     // * If a library definition gets preempted to the executable, it will have
     //   the wrong ebx value.
     if (Config->Pie && Config->EMachine == EM_386)
-      errorOrWarn("symbol '" + toString(Sym) +
-                  "' cannot be preempted; recompile with -fPIE" +
-                  getLocation(Sec, Sym, Offset));
+      errorOrWarn(Diagnostic("symbol '" + toString(Sym) +
+                                 "' cannot be preempted; recompile with -fPIE",
+                             definedAt(toObjLoc(Sym.File)),
+                             referencedBy(Sec.getSymLoc(Sym, Offset))));
     if (!Sym.isInPlt())
       addPltEntry<ELFT>(In.Plt, In.GotPlt, In.RelaPlt, Target->PltRel, Sym);
     if (!Sym.isDefined())
       replaceWithDefined(Sym, In.Plt, getPltEntryOffset(Sym.PltIndex), 0);
     Sym.NeedsPltAddr = true;
     Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return;
   }
 
-  errorOrWarn("symbol '" + toString(Sym) + "' has no type" +
-              getLocation(Sec, Sym, Offset));
+  errorOrWarn(Diagnostic("symbol '" + toString(Sym) + "' has no type",
+                         definedAt(toObjLoc(Sym.File)),
+                         referencedBy(Sec.getSymLoc(Sym, Offset))));
 }
 
 struct IRelativeReloc {
   RelType Type;
   InputSectionBase *Sec;
   uint64_t Offset;
   Symbol *Sym;
 };
static void scanReloc(InputSectionBase &Sec, OffsetGetter &GetOffset, RelTy *&I,
   // the got entries in any way, we don't have to track which objects have
   // got-based small code model relocs. The .toc sections get placed after the
   // end of the linker allocated .got section and we do sort those so sections
   // addressed with small code model relocations come first.
   if (Config->EMachine == EM_PPC64 && isPPC64SmallCodeModelTocReloc(Type))
     Sec.File->PPC64SmallCodeModelTocRelocs = true;
 
   if (Sym.isGnuIFunc() && !Config->ZText && Config->WarnIfuncTextrel) {
-    warn("using ifunc symbols when text relocations are allowed may produce "
-         "a binary that will segfault, if the object file is linked with "
-         "old version of glibc (glibc 2.28 and earlier). If this applies to "
-         "you, consider recompiling the object files without -fPIC and "
-         "without -Wl,-z,notext option. Use -no-warn-ifunc-textrel to "
-         "turn off this warning." +
-         getLocation(Sec, Sym, Offset));
+    warn(Diagnostic(
+        "using ifunc symbols when text relocations are allowed may produce "
+        "turn off this warning.",
+        definedAt(toObjLoc(Sym.File)),
+        referencedBy(Sec.getSymLoc(Sym, Offset))));
   }
 
   // Relax relocations.
   //
   // If we know that a PLT entry will be resolved within the same ELF module, we
   // can skip PLT access and directly jump to the destination function. For
   // example, if we are linking a main exectuable, all dynamic symbols that can
   // be resolved within the executable will actually be resolved that way at

ELF/SymbolTable.cpp

static void reportDuplicate(Symbol *Sym, InputFile *NewFile,
 
   Defined *D = cast<Defined>(Sym);
   if (!D->Section || !ErrSec) {
     error("duplicate symbol: " + toString(*Sym) + "\n>>> defined in " +
           toString(Sym->File) + "\n>>> defined in " + toString(NewFile));
     return;
   }
 
-  // Construct and print an error message in the form of:
-  //
-  //   ld.lld: error: duplicate symbol: foo
-  //   >>> defined at bar.c:30
-  //   >>>            bar.o (/home/alice/src/bar.o)
-  //   >>> defined at baz.c:563
-  //   >>>            baz.o in archive libbaz.a
   auto *Sec1 = cast<InputSectionBase>(D->Section);
-  std::string Src1 = Sec1->getSrcMsg(*Sym, D->Value);
-  std::string Obj1 = Sec1->getObjMsg(D->Value);
-  std::string Src2 = ErrSec->getSrcMsg(*Sym, ErrOffset);
-  std::string Obj2 = ErrSec->getObjMsg(ErrOffset);
-
-  std::string Msg = "duplicate symbol: " + toString(*Sym) + "\n>>> defined at ";
-  if (!Src1.empty())
-    Msg += Src1 + "\n>>>            ";
-  Msg += Obj1 + "\n>>> defined at ";
-  if (!Src2.empty())
-    Msg += Src2 + "\n>>>            ";
-  Msg += Obj2;
-  error(Msg);
+  lld::SymbolLocation Loc1 = Sec1->getSymLoc(*Sym, D->Value);
+  lld::SymbolLocation Loc2 = ErrSec->getSymLoc(*Sym, ErrOffset);
+  error(Diagnostic("duplicate symbol: " + toString(*Sym), definedAt(Loc1, Loc2)));
 }
 
 Defined *SymbolTable::addDefined(StringRef Name, uint8_t StOther, uint8_t Type,
                                  uint64_t Value, uint64_t Size, uint8_t Binding,
                                  SectionBase *Section, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, getVisibility(StOther),

include/lld/Common/ErrorHandler.h

 //    F have to be wrapped with ErrorOr. That seemed too much.
 //
 //  - Finding only one error at a time is not sufficient. We want to find as
 //    many errors as possible with one execution of the linker. That means the
 //    linker needs to keep running after a first error and give up at some
 //    checkpoint (beyond which it would find cascading, false errors caused by
 //    the previous errors).
 //
-//  - We want a simple interface to report errors. Unlike Clang, the data we
-//    handle is compiled binary, so we don't need an error reporting mechanism
-//    that's as sophisticated as the one that Clang has.
+//  - We want a simple interface to report errors. However, we require
+//    compatibility with Visual Studio's diagnostic output format. For this we
+//    provide the Diagnsotic class that allows the definition and reference of
+//    the erroneous symbols to be reported in a structured fashion.
 //
 // The current lld's error handling mechanism is simple:
 //
 //  - When you find an error, report it using error() and continue as far as
 //    you can. An internal error counter is incremented by one every time you
 //    call error().
 //
 //    A common idiom to handle an error is calling error() and then returning

 #include "llvm/Support/FileOutputBuffer.h"
 
 namespace llvm {
 class DiagnosticInfo;
 }
 
 namespace lld {
 
+    struct ObjLocation {
+      StringRef Archive;
+      StringRef File;
+      StringRef Sec;
+      uint64_t Off = 0;
+      std::string Sym;
+    };
+
+    struct SrcLocation {
+      std::string Path;
+      llvm::Optional<unsigned> Line;
+    };
+
+    struct SymbolLocation {
+      SymbolLocation(const ObjLocation &ObjLoc) : ObjLoc(ObjLoc) {}
+      SymbolLocation(const ObjLocation &ObjLoc,
+                     const llvm::Optional<SrcLocation> &SrcLoc)
+          : ObjLoc(ObjLoc), SrcLoc(SrcLoc) {}
+      ObjLocation ObjLoc;
+      llvm::Optional<SrcLocation> SrcLoc;
+    };
+
+    struct ReferencingSymbolLocation {
+      explicit ReferencingSymbolLocation(const SymbolLocation &SymLoc)
+          : SymLoc(SymLoc) {}
+      ReferencingSymbolLocation &
+      operator=(const ReferencingSymbolLocation &) = delete;
+      const SymbolLocation &SymLoc;
+    };
+
+    struct DefinedSymbolLocation {
+      explicit DefinedSymbolLocation(const SymbolLocation &SymLoc) {
+        definition[0] = &SymLoc;
+      }
+
+      explicit DefinedSymbolLocation(const SymbolLocation &SymLoc0,
+                                     const SymbolLocation &SymLoc1) {
+        definition[0] = &SymLoc0;
+        definition[1] = &SymLoc1;
+      }
+
+      DefinedSymbolLocation &operator=(const DefinedSymbolLocation &) = delete;
+      const SymbolLocation *definition[2] = {0, 0};
+    };
+
+    ObjLocation makeScriptObjLocation(StringRef Script);
+    ObjLocation makeSymbolObjLocation(StringRef Archive, StringRef File,
+                                      StringRef Sym);
+    ObjLocation makeSectionObjLocation(StringRef Archive, StringRef File,
+                                       StringRef Sec, uint64_t Off);
+
+    SrcLocation makeSrcLocation(StringRef File, unsigned Line);
+    SrcLocation makeSrcLocationOnlyFile(StringRef File);
+
+    inline ReferencingSymbolLocation
+    referencedBy(const SymbolLocation &SymLoc) {
+      return ReferencingSymbolLocation(SymLoc);
+    }
+
+    inline DefinedSymbolLocation definedAt(const SymbolLocation &SymLoc) {
+      return DefinedSymbolLocation(SymLoc);
+    }
+
+    inline DefinedSymbolLocation definedAt(const SymbolLocation &SymLoc1,
+                                           const SymbolLocation &SymLoc2) {
+      return DefinedSymbolLocation(SymLoc1, SymLoc2);
+    }
+
+    struct Diagnostic {
+      Diagnostic(const Twine &Msg, const DefinedSymbolLocation &defLoc,
+                 const ReferencingSymbolLocation &refLoc)
+          : Msg(Msg), Referenced(&refLoc.SymLoc) {
+        Defined[0] = defLoc.definition[0];
+        Defined[1] = defLoc.definition[1];
+      }
+      Diagnostic(const Twine &Msg, const ReferencingSymbolLocation &refLoc)
+          : Msg(Msg), Referenced(&refLoc.SymLoc) {}
+      Diagnostic(const Twine &Msg, const DefinedSymbolLocation &defLoc)
+          : Msg(Msg) {
+        Defined[0] = defLoc.definition[0];
+        Defined[1] = defLoc.definition[1];
+      }
+      Diagnostic &operator=(const Diagnostic &) = delete;
+
+      const Twine &Msg;
+      const SymbolLocation *Referenced = 0;
+      const SymbolLocation *Defined[2] = {0, 0};
+    };
+
 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 ColorDiagnostics = llvm::errs().has_colors();
   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);
+  void error(const Twine &Orig, const Twine &Msg);
+  LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Orig, const Twine &Msg);
+  void log(const Twine &Orig, const Twine &Msg);
   void message(const Twine &Msg);
-  void warn(const Twine &Msg);
+  void warn(const Twine &Orig, const Twine &Msg);
 
   std::unique_ptr<llvm::FileOutputBuffer> OutputBuffer;
 
 private:
-  void print(StringRef S, raw_ostream::Colors C);
+  void print(const Twine &Orig, StringRef S, raw_ostream::Colors C,
+             const Twine &Msg);
 };
 
 /// Returns the default error handler.
 ErrorHandler &errorHandler();
 
-inline void error(const Twine &Msg) { errorHandler().error(Msg); }
+inline void error(const Twine &Msg) {
+  ErrorHandler &EH = errorHandler();
+  EH.error(EH.LogName, Msg);
+}
+
+void warn(Diagnostic const &C);
+void error(Diagnostic const &C);
+
 inline LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg) {
-  errorHandler().fatal(Msg);
+  ErrorHandler &EH = errorHandler();
+  EH.fatal(EH.LogName, Msg);
+}
+
+inline void log(const Twine &Msg) {
+  ErrorHandler &EH = errorHandler();
+  EH.log(EH.LogName, Msg);
 }
-inline void log(const Twine &Msg) { errorHandler().log(Msg); }
+
 inline void message(const Twine &Msg) { errorHandler().message(Msg); }
-inline void warn(const Twine &Msg) { errorHandler().warn(Msg); }
+
+inline void warn(const Twine &Msg) {
+  ErrorHandler &EH = errorHandler();
+  EH.warn(EH.LogName, Msg);
+}
+
 inline uint64_t errorCount() { return errorHandler().ErrorCount; }
 
 LLVM_ATTRIBUTE_NORETURN void exitLld(int Val);
 
 void diagnosticHandler(const llvm::DiagnosticInfo &DI);
 void checkError(Error E);
 
 // check functions are convenient functions to strip errors

test/ELF/Inputs/vs-diag-duplicate2.s

+.global foo, bar
+
+.text
+foo:
+  nop
+
+.file 1 "duplicate2.s"
+.loc 1 20
+bar:
+  nop
+
+.section .debug_abbrev,"",@progbits
+  .byte  1                      # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte  0                      # DW_CHILDREN_no
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte  0                      # EOM(1)
+  .byte  0                      # EOM(2)
+  .byte  0                      # EOM(3)
+
+.section .debug_info,"",@progbits
+  .long .Lend0 - .Lbegin0       # Length of Unit
+.Lbegin0:
+  .short 4                      # DWARF version number
+  .long  .debug_abbrev          # Offset Into Abbrev. Section
+  .byte  8                      # Address Size (in bytes)
+  .byte  1                      # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .long  .debug_line            # DW_AT_stmt_list
+.Lend0:
+  .section .debug_line,"",@progbits

test/ELF/Inputs/vs-diag-duplicate3.s

+.file "duplicate3.s"
+
+.global baz
+.text
+baz:
+  nop

test/ELF/vs-diag-duplicate.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/vs-diag-duplicate2.s -o %t2.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/vs-diag-duplicate3.s -o %t3.o
+// RUN: not ld.lld --vs-diagnostics %t1.o %t2.o %t3.o -o %tout 2>&1 | FileCheck %s
+
+// Case 1. Both symbols have full source location.
+// CHECK:      duplicate.s(15): error: duplicate symbol: bar
+// CHECK-NEXT: >>> defined at {{.*}}1.o:(.text+0x{{.+}})
+// CHECK:      duplicate2.s(20): error: duplicate symbol: bar
+// CHECK-NEXT: >>> defined at {{.*}}2.o:(.text+0x{{.+}})
+
+// Case 2. The source locations are unknown for both symbols.
+// CHECK:      {{.*}}ld.lld{{.*}}: error: duplicate symbol: foo
+// CHECK-NEXT: >>> defined at {{.*}}1.o:(.text+0x{{.+}})
+// CHECK:      {{.*}}ld.lld{{.*}}: error: duplicate symbol: foo
+// CHECK-NEXT: >>> defined at {{.*}}2.o:(.text+0x{{.+}})
+
+// Case 3. For the second definition of `baz` we know only the source file found in a STT_FILE symbol.
+// CHECK:      duplicate.s(30): error: duplicate symbol: baz
+// CHECK-NEXT: >>> {{.*}}1.o:(.text+0x{{.+}})
+// CHECK:      {{.*}}ld.lld{{.*}}: error: duplicate symbol: baz
+// CHECK-NEXT: >>> defined in duplicate3.s
+// CHECK-NEXT: >>>            {{.*}}3.o:(.text+0x{{.+}})
+
+.global _start, foo, bar, baz
+.text
+_start:
+  nop
+
+foo:
+  nop
+
+.file 1 "duplicate.s"
+.loc 1 15
+
+bar:
+  nop
+
+.loc 1 30
+baz:
+  nop
+
+.section .debug_abbrev,"",@progbits
+  .byte  1                      # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte  0                      # DW_CHILDREN_no
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte  0                      # EOM(1)
+  .byte  0                      # EOM(2)
+  .byte  0                      # EOM(3)
+
+.section .debug_info,"",@progbits
+  .long .Lend0 - .Lbegin0       # Length of Unit
+.Lbegin0:
+  .short 4                      # DWARF version number
+  .long  .debug_abbrev          # Offset Into Abbrev. Section
+  .byte  8                      # Address Size (in bytes)
+  .byte  1                      # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .long  .debug_line            # DW_AT_stmt_list
+.Lend0:
+  .section .debug_line,"",@progbits

test/ELF/vs-diag-dyn.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: not ld.lld -shared --vs-diagnostics %t.o -o /dev/null 2>&1 | FileCheck %s
+
+// CHECK: dyn.s(15): error: can't create dynamic relocation R_X86_64_64 against local symbol in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output
+// CHECK-NEXT: >>> defined in {{.*}}.o
+// CHECK-NEXT: >>> referenced by {{.*}}.o:(.text+0x{{.+}})
+
+.file 1 "dyn.s"
+.loc 1 15
+
+foo:
+.quad foo
+
+.section .debug_abbrev,"",@progbits
+  .byte  1                      # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte  0                      # DW_CHILDREN_no
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte  0                      # EOM(1)
+  .byte  0                      # EOM(2)
+  .byte  0                      # EOM(3)
+
+.section .debug_info,"",@progbits
+  .long .Lend0 - .Lbegin0       # Length of Unit
+.Lbegin0:
+  .short 4                      # DWARF version number
+  .long  .debug_abbrev          # Offset Into Abbrev. Section
+  .byte  8                      # Address Size (in bytes)
+  .byte  1                      # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .long  .debug_line            # DW_AT_stmt_list
+.Lend0:
+  .section .debug_line,"",@progbits

test/ELF/vs-diag-undef1.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
+// RUN: not ld.lld --vs-diagnostics %t1.o -o %tout 2>&1 \
+// RUN:   | FileCheck -check-prefix=ERR -check-prefix=CHECK %s
+// RUN: ld.lld --vs-diagnostics --warn-unresolved-symbols %t1.o -o %tout 2>&1 \
+// RUN:   | FileCheck -check-prefix=WARN -check-prefix=CHECK %s
+
+// ERR:        {{.*}}ld.lld{{.*}}: error: undefined symbol: foo
+// WARN:       {{.*}}ld.lld{{.*}}: warning: undefined symbol: foo
+// CHECK-NEXT: >>> referenced by {{.*}}1.o:(.text+0x{{.+}})
+
+.global _start, foo
+.text
+_start:
+  jmp foo

test/ELF/vs-diag-undef2.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
+// RUN: not ld.lld --vs-diagnostics %t1.o -o %tout 2>&1 \
+// RUN:   | FileCheck -check-prefix=ERR -check-prefix=CHECK %s
+// RUN: ld.lld --vs-diagnostics --warn-unresolved-symbols %t1.o -o %tout 2>&1 \
+// RUN:   | FileCheck -check-prefix=WARN -check-prefix=CHECK %s
+
+// ERR:        {{.*}}ld.lld{{.*}}: error: undefined symbol: foo
+// WARN:       {{.*}}ld.lld{{.*}}: warning: undefined symbol: foo
+// CHECK-NEXT: >>> referenced by undef2.s
+// CHECK-NEXT: >>>               {{.*}}1.o:(.text+0x{{.+}})
+
+.file "undef2.s"
+
+.global _start, foo
+.text
+_start:
+  jmp foo

test/ELF/vs-diag-undef3.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
+// RUN: not ld.lld --vs-diagnostics %t1.o -o %tout 2>&1 \
+// RUN:   | FileCheck -check-prefix=ERR -check-prefix=CHECK %s
+// RUN: ld.lld --vs-diagnostics --warn-unresolved-symbols %t1.o -o %tout 2>&1 \
+// RUN:   | FileCheck -check-prefix=WARN -check-prefix=CHECK %s
+
+// ERR:        undef3.s(15): error: undefined symbol: foo
+// WARN:       undef3.s(15): warning: undefined symbol: foo
+// CHECK-NEXT: >>> referenced by {{.*}}1.o:(.text+0x{{.+}})
+
+.file 1 "undef3.s"
+
+.global _start, foo
+.text
+_start:
+.loc 1 15
+  jmp foo
+
+.section .debug_abbrev,"",@progbits
+  .byte  1                      # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte  0                      # DW_CHILDREN_no
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte  0                      # EOM(1)
+  .byte  0                      # EOM(2)
+  .byte  0                      # EOM(3)
+
+.section .debug_info,"",@progbits
+  .long .Lend0 - .Lbegin0       # Length of Unit
+.Lbegin0:
+  .short 4                      # DWARF version number
+  .long  .debug_abbrev          # Offset Into Abbrev. Section
+  .byte  8                      # Address Size (in bytes)
+  .byte  1                      # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .long  .debug_line            # DW_AT_stmt_list
+.Lend0:
+  .section .debug_line,"",@progbits