Index: Common/ErrorHandler.cpp
===================================================================
--- Common/ErrorHandler.cpp
+++ Common/ErrorHandler.cpp
@@ -84,8 +84,10 @@
                   [&](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;
@@ -93,12 +95,13 @@
   } 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";
   }
 }
 
@@ -108,28 +111,22 @@
   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);
   }
@@ -137,7 +134,7 @@
   ++ErrorCount;
 }
 
-void ErrorHandler::fatal(const Twine &Msg) {
-  error(Msg);
+void ErrorHandler::fatal(const Twine &Orig, const Twine &Msg) {
+  error(Orig, Msg);
   exitLld(1);
 }
Index: ELF/CMakeLists.txt
===================================================================
--- ELF/CMakeLists.txt
+++ ELF/CMakeLists.txt
@@ -22,6 +22,7 @@
   Arch/X86.cpp
   Arch/X86_64.cpp
   CallGraphSort.cpp
+  Diagnostics.cpp
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
Index: ELF/Diagnostics.h
===================================================================
--- /dev/null
+++ ELF/Diagnostics.h
@@ -0,0 +1,122 @@
+//===- 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
Index: ELF/Diagnostics.cpp
===================================================================
--- /dev/null
+++ ELF/Diagnostics.cpp
@@ -0,0 +1,218 @@
+//===- 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));
+}
Index: ELF/Driver.cpp
===================================================================
--- ELF/Driver.cpp
+++ ELF/Driver.cpp
@@ -25,6 +25,7 @@
 
 #include "Driver.h"
 #include "Config.h"
+#include "Diagnostics.h"
 #include "Filesystem.h"
 #include "ICF.h"
 #include "InputFiles.h"
@@ -91,6 +92,7 @@
   SharedFiles.clear();
 
   Config = make<Configuration>();
+  Diag = make<Diagnostics>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
   Symtab = make<SymbolTable>();
@@ -725,6 +727,7 @@
   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,
Index: ELF/InputFiles.h
===================================================================
--- ELF/InputFiles.h
+++ ELF/InputFiles.h
@@ -11,6 +11,7 @@
 #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"
@@ -44,6 +45,8 @@
 
 namespace elf {
 
+ObjLocation toObjLoc(const elf::InputFile *F);
+
 using llvm::object::Archive;
 
 class Symbol;
@@ -106,8 +109,8 @@
   // 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;
Index: ELF/InputFiles.cpp
===================================================================
--- ELF/InputFiles.cpp
+++ ELF/InputFiles.cpp
@@ -79,47 +79,43 @@
   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,
-                                 uint64_t Offset) {
+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);
   }
 }
 
@@ -235,6 +231,16 @@
   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)
Index: ELF/InputSection.h
===================================================================
--- ELF/InputSection.h
+++ ELF/InputSection.h
@@ -11,6 +11,7 @@
 #define LLD_ELF_INPUT_SECTION_H
 
 #include "Config.h"
+#include "Diagnostics.h"
 #include "Relocations.h"
 #include "Thunks.h"
 #include "lld/Common/LLVM.h"
@@ -176,8 +177,9 @@
 
   // 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
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -252,16 +252,6 @@
   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:
@@ -289,6 +279,21 @@
       .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,
@@ -694,7 +699,7 @@
   case R_TLSLD_GOT_FROM_END:
     return InX::Got->getTlsIndexOff() + A - InX::Got->getSize();
   case R_TLSLD_GOT:
-    return InX::Got->getTlsIndexOff() + A;
+      return InX::Got->getTlsIndexOff() + A;
   case R_TLSLD_PC:
     return InX::Got->getTlsIndexVA() + A - P;
   default:
@@ -958,8 +963,8 @@
         error(lld::toString(this) + ": " + F->getName() +
               " (with -fsplit-stack) calls " + D->getName() +
               " (without -fsplit-stack), but couldn't adjust its prologue");
+      }
     }
-  }
   switchMorestackCallsToMorestackNonSplit(Prologues, MorestackCalls);
 }
 
Index: ELF/Options.td
===================================================================
--- ELF/Options.td
+++ ELF/Options.td
@@ -365,6 +365,9 @@
 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">;
Index: ELF/Relocations.cpp
===================================================================
--- ELF/Relocations.cpp
+++ ELF/Relocations.cpp
@@ -65,21 +65,6 @@
 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
@@ -403,8 +388,10 @@
   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;
 }
 
@@ -638,21 +625,15 @@
   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;
 }
 
@@ -856,20 +837,22 @@
   }
 
   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) +
-                " cannot be used against symbol " + toString(Sym) +
-                "; recompile with -fPIC" + getLocation(Sec, Sym, Offset));
+    Diag->errorOrWarn("relocation " + toString(Type) +
+                      " cannot be used against symbol " + toString(Sym) +
+                      "; recompile with -fPIC" + definedAt(toObjLoc(Sym.File)) +
+                      referencedBy(Sec.getSymLoc(Sym, Offset)));
     return;
   }
 
@@ -878,8 +861,9 @@
     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;
   }
 
@@ -887,10 +871,11 @@
     // Produce a copy relocation.
     if (auto *SS = dyn_cast<SharedSymbol>(&Sym)) {
       if (!Config->ZCopyreloc)
-        error("unresolvable relocation " + toString(Type) +
-              " against symbol '" + toString(*SS) +
-              "'; recompile with -fPIC or remove '-z nocopyreloc'" +
-              getLocation(Sec, Sym, Offset));
+        Diag->error("unresolvable relocation " + toString(Type) +
+                    " against symbol '" + toString(*SS) +
+                    "'; 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});
@@ -926,9 +911,10 @@
     // * 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));
+      Diag->errorOrWarn("symbol '" + toString(Sym) +
+                        "' cannot be preempted; recompile with -fPIE" +
+                        definedAt(toObjLoc(Sym.File)) +
+                        referencedBy(Sec.getSymLoc(Sym, Offset)));
     if (!Sym.isInPlt())
       addPltEntry<ELFT>(InX::Plt, InX::GotPlt, InX::RelaPlt, Target->PltRel,
                         Sym);
@@ -939,8 +925,9 @@
     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>
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -489,8 +489,8 @@
 
 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,
@@ -504,27 +504,11 @@
     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,
Index: include/lld/Common/ErrorHandler.h
===================================================================
--- include/lld/Common/ErrorHandler.h
+++ include/lld/Common/ErrorHandler.h
@@ -93,28 +93,44 @@
   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);
Index: test/ELF/Inputs/vs-diag-duplicate2.s
===================================================================
--- /dev/null
+++ test/ELF/Inputs/vs-diag-duplicate2.s
@@ -0,0 +1,31 @@
+.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
Index: test/ELF/Inputs/vs-diag-duplicate3.s
===================================================================
--- /dev/null
+++ test/ELF/Inputs/vs-diag-duplicate3.s
@@ -0,0 +1,6 @@
+.file "duplicate3.s"
+
+.global baz
+.text
+baz:
+  nop
Index: test/ELF/vs-diag-duplicate.s
===================================================================
--- /dev/null
+++ test/ELF/vs-diag-duplicate.s
@@ -0,0 +1,63 @@
+// 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
Index: test/ELF/vs-diag-dyn.s
===================================================================
--- /dev/null
+++ test/ELF/vs-diag-dyn.s
@@ -0,0 +1,34 @@
+// 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
Index: test/ELF/vs-diag-undef1.s
===================================================================
--- /dev/null
+++ test/ELF/vs-diag-undef1.s
@@ -0,0 +1,15 @@
+// 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
Index: test/ELF/vs-diag-undef2.s
===================================================================
--- /dev/null
+++ test/ELF/vs-diag-undef2.s
@@ -0,0 +1,18 @@
+// 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
Index: test/ELF/vs-diag-undef3.s
===================================================================
--- /dev/null
+++ test/ELF/vs-diag-undef3.s
@@ -0,0 +1,39 @@
+// 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