[LLD] Enable Visual Studio compatible diagnostics.

[ikudrin]

Summary

This is an alternative implementation for D47540.

In this patch, I moved the code which produces the location part of a diagnostic message into a distinct place. I hope that this makes the overall code clearer because it simplifies other parts of the codebase.

The patch is primarily intended to demonstrate the approach and collect the feedback, which way we are going to go. The code is far from being perfect and has to be polished if this approach will be chosen.

[chrisjackson]

@ikudrin

I have experimented with this implementation and I agree that separating the diagnostic location functions into a distinct library is a good structured approach. I think this would be a reasonable and more explicit support for Visual Studio Diagnostics than D47540 which really just shoehorned in support.

[arichardson]

ELF/Relocations.cpp

636

This would have been useful for me too when I added new error messages to our fork of LLD. I just ended up copy-pasting the string constants from other files in lld.
I like this since it will ensure consistent warning message formats everywhere.

[chrisjackson]

@ruiu
Hello Rui, do you have any thoughts on this implementation compared to D47540 ?

[ruiu]

I haven't read Diagnostics.cpp to focus on the ABI itself, but it looks like this approach is better than https://reviews.llvm.org/D47540, though this patch seems a bit too abstracted and too object-oriented to my taste. Can you add comment to the code? Also, please avoid operator overriding and eliminate Diag class (you can do that because all you need is a boolean flag indicating whether VS output is wanted or not.)

[ikudrin]

@chrisjackson @arichardson @ruiu, thank you for the feedback! I am going to continue working on the patch somewhere in October. I would really appreciate any additional comments meanwhile.

@ruiu, if not overloading operators, what style of combining messages would you prefer?

[ruiu]

Operator overriding can always be rewritten as function calls, so instead of operator+(X), you can always define something like add(X)?

[ikudrin]

With overloaded operators we can write something like

error("relocation " + toString(Type) +
        " cannot refer to absolute symbol: " + toString(Sym) +
        definedAt(toObjLoc(Sym.File)) +
        referencedBy(S.getSymLoc(Sym, RelOff)));

How would you prefer it to look like?
I don't insist on the current style, but I believe it is important to be discussed prior to rewriting the code because the decision will influence the design directly.

[aganea]

Ping! Any progress planned on this?

[chrisjackson]

I will provide a patch for this as I'm very keen to add support for Visual Studio diagnostics, but I'm not currently working on it.

Common/ErrorHandler.cpp

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);
 }

ELF/CMakeLists.txt

add_lld_library(lldELF
   Arch/MipsArchTree.cpp
   Arch/PPC.cpp
   Arch/PPC64.cpp
   Arch/RISCV.cpp
   Arch/SPARCV9.cpp
   Arch/X86.cpp
   Arch/X86_64.cpp
   CallGraphSort.cpp
+  Diagnostics.cpp
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
   Filesystem.cpp
   GdbIndex.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp

ELF/Diagnostics.h

+//===- Diagnostics.h --------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_ELF_DIAGNOSTICS_H
+#define LLD_ELF_DIAGNOSTICS_H
+
+#include "Config.h"
+#include "lld/Common/LLVM.h"
+#include "llvm/ADT/Optional.h"
+
+namespace lld {
+namespace elf {
+
+class Symbol;
+
+struct ObjLocation {
+  StringRef Archive;
+  StringRef File;
+  StringRef Sec;
+  uint64_t Off = 0;
+  std::string Sym;
+};
+
+ObjLocation makeSymbolObjLocation(StringRef Archive, StringRef File,
+                                  StringRef Sym);
+ObjLocation makeSectionObjLocation(StringRef Archive, StringRef File,
+                                   StringRef Sec, uint64_t Off);
+
+struct SrcLocation {
+  std::string Path; // see createFileLineMsg for using of path::filename(Path);
+  llvm::Optional<unsigned> Line;
+};
+
+SrcLocation makeSrcLocation(StringRef File, unsigned Line);
+SrcLocation makeSrcLocationOnlyFile(StringRef File);
+
+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)
+      : SymLoc(SymLoc) {}
+  DefinedSymbolLocation &operator=(const DefinedSymbolLocation &) = delete;
+  const SymbolLocation &SymLoc;
+};
+
+inline ReferencingSymbolLocation referencedBy(const SymbolLocation &SymLoc) {
+  return ReferencingSymbolLocation(SymLoc);
+}
+
+inline DefinedSymbolLocation definedAt(const SymbolLocation &SymLoc) {
+  return DefinedSymbolLocation(SymLoc);
+}
+
+class DiagnosticCollector {
+public:
+  DiagnosticCollector(const Twine &Msg, const ReferencingSymbolLocation &Loc)
+      : Msg(Msg), Referenced(&(Loc.SymLoc)) {}
+  DiagnosticCollector(const Twine &Msg, const DefinedSymbolLocation &Loc)
+      : Msg(Msg) {
+    Defined[0] = &(Loc.SymLoc);
+  }
+  DiagnosticCollector &operator=(const DiagnosticCollector &) = delete;
+
+  DiagnosticCollector &operator+(const ReferencingSymbolLocation &Loc);
+  DiagnosticCollector &operator+(const DefinedSymbolLocation &Loc);
+
+  const Twine &Msg;
+  const SymbolLocation *Referenced = 0;
+  const SymbolLocation *Defined[2] = {0, 0};
+};
+
+inline DiagnosticCollector operator+(const Twine &Msg,
+                                     const ReferencingSymbolLocation &Loc) {
+  return DiagnosticCollector(Msg, Loc);
+}
+
+inline DiagnosticCollector operator+(const Twine &Msg,
+                                     const DefinedSymbolLocation &Loc) {
+  return DiagnosticCollector(Msg, Loc);
+}
+
+class Diagnostics {
+public:
+  bool VSDiagnostics = false;
+
+  void warn(const DiagnosticCollector &Msg);
+  void error(const DiagnosticCollector &Msg);
+  void errorOrWarn(const DiagnosticCollector &Msg) {
+    if (!Config->NoinhibitExec)
+      error(Msg);
+    else
+      warn(Msg);
+  }
+};
+
+extern Diagnostics *Diag;
+
+} // namespace elf
+} // namespace lld
+
+#endif

ELF/Diagnostics.cpp

+//===- Diagnostics.cpp ----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// TBD
+//
+//===----------------------------------------------------------------------===//
+
+#include "Diagnostics.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/Support/Path.h"
+
+using namespace lld;
+using namespace lld::elf;
+
+Diagnostics *elf::Diag;
+
+ObjLocation elf::makeSymbolObjLocation(StringRef Archive, StringRef File,
+                                       StringRef Sym) {
+  ObjLocation Result;
+  Result.Archive = Archive;
+  Result.File = File;
+  Result.Sym = Sym;
+  return Result;
+}
+
+ObjLocation elf::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 elf::makeSrcLocation(StringRef File, unsigned Line) {
+  SrcLocation Result;
+  Result.Path = File.str();
+  Result.Line = Line;
+  return Result;
+}
+
+SrcLocation elf::makeSrcLocationOnlyFile(StringRef File) {
+  SrcLocation Result;
+  Result.Path = File.str();
+  return Result;
+}
+
+DiagnosticCollector &DiagnosticCollector::
+operator+(const ReferencingSymbolLocation &Loc) {
+  assert(!Referenced &&
+         "We do not expect to see a referencing location more than once.");
+  Referenced = &(Loc.SymLoc);
+  return *this;
+}
+
+DiagnosticCollector &DiagnosticCollector::
+operator+(const DefinedSymbolLocation &Loc) {
+  assert(
+      !Defined[1] &&
+      "We are not ready to see a symbol definition location more than twice.");
+  if (Defined[0])
+    Defined[1] = &(Loc.SymLoc);
+  else
+    Defined[0] = &(Loc.SymLoc);
+  return *this;
+}
+
+static unsigned reportCount(const DiagnosticCollector &C) {
+  if (Diag->VSDiagnostics && C.Defined[1])
+    return 2;
+  return 1;
+}
+
+static bool hasDetails(const ObjLocation &ObjLoc) {
+  return !ObjLoc.Sym.empty() || !ObjLoc.Sec.empty();
+}
+
+static bool hasDetails(const SrcLocation &SrcLoc) {
+  return SrcLoc.Line.hasValue();
+}
+
+// Based on createFileLineMsg (InputFiles.cpp)
+static std::string getNativeSrcLocTxt(const SrcLocation &SrcLoc) {
+  if (!hasDetails(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 (!hasDetails(SrcLoc))
+    return SrcLoc.Path;
+  return SrcLoc.Path + "(" + std::to_string(SrcLoc.Line.getValue()) + ")";
+}
+
+static std::string getOrig(const DiagnosticCollector &C, unsigned index) {
+  if (!Diag->VSDiagnostics)
+    return errorHandler().LogName;
+  const SymbolLocation *Loc = C.Referenced ? C.Referenced : C.Defined[index];
+  if (!Loc || !Loc->SrcLoc || !hasDetails(Loc->SrcLoc.getValue()))
+    return errorHandler().LogName;
+  return getVSSrcLocTxt(Loc->SrcLoc.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 && hasDetails(SymLoc->SrcLoc.getValue())) ||
+      (!SymLoc->SrcLoc && hasDetails(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 && !hasDetails(SymLoc->SrcLoc.getValue()))
+    Result += "\n>>> defined in " + getVSSrcLocTxt(SymLoc->SrcLoc.getValue()) +
+              "\n>>>            ";
+  else if (hasDetails(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 && !hasDetails(SymLoc->SrcLoc.getValue()))
+    Result +=
+        getVSSrcLocTxt(SymLoc->SrcLoc.getValue()) + "\n>>>               ";
+  Result += getObjLocTxt(SymLoc->ObjLoc);
+  return Result;
+}
+
+static std::string getMsg(const DiagnosticCollector &C, unsigned index) {
+  if (!Diag->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();
+}
+
+void Diagnostics::warn(const DiagnosticCollector &C) {
+  for (unsigned I = 0; I < reportCount(C); ++I)
+    errorHandler().warn(getOrig(C, I), getMsg(C, I));
+}
+
+void Diagnostics::error(const DiagnosticCollector &C) {
+  for (unsigned I = 0; I < reportCount(C); ++I)
+    errorHandler().error(getOrig(C, I), getMsg(C, I));
+}

ELF/Driver.cpp

 // be harmful when you are doing cross-linking. Therefore, in LLD, we
 // simply trust the compiler driver to pass all required options and
 // don't try to make effort on our side.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
+#include "Diagnostics.h"
 #include "Filesystem.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "MarkLive.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
   OutputSections.clear();
   Tar = nullptr;
   BinaryFiles.clear();
   BitcodeFiles.clear();
   ObjectFiles.clear();
   SharedFiles.clear();
 
   Config = make<Configuration>();
+  Diag = make<Diagnostics>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
   Symtab = make<SymbolTable>();
   Config->ProgName = Args[0];
 
   Driver->main(Args);
 
   // Exit immediately if we don't need to return to the caller.

 }
 
 // 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);
+  Diag->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->AuxiliaryList = args::getStrings(Args, OPT_auxiliary);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);

ELF/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_INPUT_FILES_H
 #define LLD_ELF_INPUT_FILES_H
 
 #include "Config.h"
+#include "Diagnostics.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/IR/Comdat.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 llvm::TarWriter *Tar;
 
public:
   // have ELF type (i.e. ELF{32,64}{LE,BE}) and target machine type.
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint8_t OSABI = 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;
 
   // GroupId is used for --warn-backrefs which is an optional error
   // checking feature. All files within the same --{start,end}-group or
   // --{start,end}-lib get the same group ID. Otherwise, each file gets a new
   // group ID. For more info, see checkDependency() in SymbolTable.cpp.

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));
   const DWARFObject &Obj = Dwarf->getDWARFObj();
   DWARFDataExtractor LineData(Obj, Obj.getLineSection(), Config->IsLE,
                               Config->Wordsize);
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

 //===- InputSection.h -------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_INPUT_SECTION_H
 #define LLD_ELF_INPUT_SECTION_H
 
 #include "Config.h"
+#include "Diagnostics.h"
 #include "Relocations.h"
 #include "Thunks.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Object/ELF.h"
 
public:
 
   // Compilers emit zlib-compressed debug sections if the -gz option
   // is given. This function checks if this section is compressed, and
   // if so, decompress in memory.
   void maybeDecompress();
 
   // 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) + ")";
 
   // If there's no symbol, print out the offset in the section.
   return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
 }
 
-// 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) {}
case R_TLSGD_GOT:
     return InX::Got->getGlobalDynOffset(Sym) + A;
   case R_TLSGD_GOT_FROM_END:
     return InX::Got->getGlobalDynOffset(Sym) + A - InX::Got->getSize();
   case R_TLSGD_PC:
     return InX::Got->getGlobalDynAddr(Sym) + A - P;
   case R_TLSLD_GOT_FROM_END:
     return InX::Got->getTlsIndexOff() + A - InX::Got->getSize();
   case R_TLSLD_GOT:
       return InX::Got->getTlsIndexOff() + A;
   case R_TLSLD_PC:
     return InX::Got->getTlsIndexVA() + A - P;
   default:
     llvm_unreachable("invalid expression");
   }
 }
 
 // This function applies relocations to sections without SHF_ALLOC bit.
if (Defined *F = getEnclosingFunction<ELFT>(Rel.Offset)) {
       Prologues.insert(F);
       if (Target->adjustPrologueForCrossSplitStack(Buf + getOffset(F->Value),
                                                    End))
         continue;
       if (!getFile<ELFT>()->SomeNoSplitStack)
         error(lld::toString(this) + ": " + F->getName() +
               " (with -fsplit-stack) calls " + D->getName() +
               " (without -fsplit-stack), but couldn't adjust its prologue");
       }
     }
   switchMorestackCallsToMorestackNonSplit(Prologues, MorestackCalls);
 }
 
 template <class ELFT> void InputSection::writeTo(uint8_t *Buf) {
   if (Type == SHT_NOBITS)
     return;
 
   if (auto *S = dyn_cast<SyntheticSection>(this)) {

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;
 
-// 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 " + toString(Sym.File) + "\n>>> referenced by ";
-  std::string Src = S.getSrcMsg(Sym, Off);
-  if (!Src.empty())
-    Msg += Src + "\n>>>               ";
-  return Msg + S.getObjMsg(Off);
-}
-
 // This function is similar to the `handleTlsRelocation`. MIPS does not
 // support any relaxations for TLS relocations so by factoring out MIPS
 // handling in to the separate function we can simplify the code and do not
 // pollute other `handleTlsRelocation` by MIPS `ifs` statements.
 // Mips has a custom MipsGotSection that handles the writing of GOT entries
 // without dynamic relocations.
 static unsigned handleMipsTlsRelocation(RelType Type, Symbol &Sym,
                                         InputSectionBase &C, uint64_t Offset,
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));
+  Diag->error("relocation " + toString(Type) +
+              " cannot refer to absolute symbol: " + toString(Sym) +
+              definedAt(toObjLoc(Sym.File)) +
+              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);
-
+  SymbolLocation SymLoc = Sec.getSymLoc(Sym, Offset);
+  std::string Msg = "undefined symbol: " + toString(Sym);
   if ((Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal) ||
       Config->NoinhibitExec) {
-    warn(Msg);
+    Diag->warn(Msg + referencedBy(SymLoc));
     return false;
   }
 
-  error(Msg);
+  Diag->error(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.
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(
+    Diag->error(
         "can't create dynamic relocation " + toString(Type) + " against " +
         (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));
+        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) +
+    Diag->errorOrWarn("relocation " + toString(Type) +
                       " cannot be used against symbol " + toString(Sym) +
-                "; recompile with -fPIC" + getLocation(Sec, Sym, Offset));
+                      "; 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));
+    Diag->error("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) +
+        Diag->error("unresolvable relocation " + toString(Type) +
                     " against symbol '" + toString(*SS) +
                     "'; recompile with -fPIC or remove '-z nocopyreloc'" +
-              getLocation(Sec, Sym, Offset));
+                    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) +
+      Diag->errorOrWarn("symbol '" + toString(Sym) +
                         "' cannot be preempted; recompile with -fPIE" +
-                  getLocation(Sec, Sym, Offset));
+                        definedAt(toObjLoc(Sym.File)) +
+                        referencedBy(Sec.getSymLoc(Sym, Offset)));
     if (!Sym.isInPlt())
       addPltEntry<ELFT>(InX::Plt, InX::GotPlt, InX::RelaPlt, Target->PltRel,
                         Sym);
     if (!Sym.isDefined())
       replaceWithDefined(Sym, InX::Plt, Sym.getPltOffset(), 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));
+  Diag->errorOrWarn("symbol '" + toString(Sym) + "' has no type" +
+                    definedAt(toObjLoc(Sym.File)) +
+                    referencedBy(Sec.getSymLoc(Sym, Offset)));
 }
 
 template <class ELFT, class RelTy>
 static void scanReloc(InputSectionBase &Sec, OffsetGetter &GetOffset, RelTy *&I,
                       RelTy *End) {
   const RelTy &Rel = *I;
   Symbol &Sym = Sec.getFile<ELFT>()->getRelocTargetSym(Rel);
   RelType Type;

ELF/SymbolTable.cpp

if (Size > Bss->Size) {
     D->File = Bss->File = &File;
     D->Size = Bss->Size = Size;
   }
   return S;
 }
 
 static void reportDuplicate(Symbol *Sym, InputFile *NewFile) {
   if (!Config->AllowMultipleDefinition)
-    error("duplicate symbol: " + toString(*Sym) + "\n>>> defined in " +
-          toString(Sym->File) + "\n>>> defined in " + toString(NewFile));
+    Diag->error("duplicate symbol: " + toString(*Sym) +
+                definedAt(toObjLoc(Sym->File)) + definedAt(toObjLoc(NewFile)));
 }
 
 static void reportDuplicate(Symbol *Sym, InputFile *NewFile,
                             InputSectionBase *ErrSec, uint64_t ErrOffset) {
   if (Config->AllowMultipleDefinition)
     return;
 
   Defined *D = cast<Defined>(Sym);
   if (!D->Section || !ErrSec) {
     reportDuplicate(Sym, 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);
+  SymbolLocation Loc1 = Sec1->getSymLoc(*Sym, D->Value);
+  SymbolLocation Loc2 = ErrSec->getSymLoc(*Sym, ErrOffset);
+  Diag->error("duplicate symbol: " + toString(*Sym) + definedAt(Loc1) +
+              definedAt(Loc2));
 }
 
 Symbol *SymbolTable::addRegular(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, Type, getVisibility(StOther),

include/lld/Common/ErrorHandler.h

public:
   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;
 
-  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);
+}
+
 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