Index: Common/ErrorHandler.cpp
===================================================================
--- Common/ErrorHandler.cpp
+++ Common/ErrorHandler.cpp
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #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"
@@ -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,190 @@
   ++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));
+}
Index: ELF/Config.h
===================================================================
--- ELF/Config.h
+++ ELF/Config.h
@@ -303,6 +303,13 @@
   else
     warn(Msg);
 }
+
+static inline void errorOrWarn(const Diagnostic &diagnostic) {
+  if (!Config->NoinhibitExec)
+    error(diagnostic);
+  else
+    warn(diagnostic);
+}
 } // namespace elf
 } // namespace lld
 
Index: ELF/Driver.cpp
===================================================================
--- ELF/Driver.cpp
+++ ELF/Driver.cpp
@@ -751,6 +751,7 @@
   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,
Index: ELF/InputFiles.h
===================================================================
--- ELF/InputFiles.h
+++ ELF/InputFiles.h
@@ -43,6 +43,8 @@
 
 namespace elf {
 
+ObjLocation toObjLoc(const elf::InputFile *F);
+
 using llvm::object::Archive;
 
 class Symbol;
@@ -108,8 +110,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
@@ -78,47 +78,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);
   }
 }
 
@@ -230,6 +226,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
@@ -175,8 +175,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
@@ -312,16 +312,6 @@
   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:
@@ -349,6 +339,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,
Index: ELF/Options.td
===================================================================
--- ELF/Options.td
+++ ELF/Options.td
@@ -390,6 +390,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,34 +65,6 @@
 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.
 //
@@ -387,6 +359,14 @@
                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
@@ -445,8 +425,19 @@
   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;
 }
 
@@ -676,13 +667,8 @@
   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 "
@@ -690,11 +676,11 @@
 
   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;
 }
 
@@ -703,7 +689,8 @@
 // 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;
 
@@ -898,20 +885,24 @@
   }
 
   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)) +
-        " in readonly segment; recompile object files with -fPIC "
-        "or pass '-Wl,-z,notext' to allow text relocations in the output" +
-        getLocation(Sec, Sym, Offset));
+            (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",
+        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;
   }
 
@@ -920,8 +911,9 @@
     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;
   }
 
@@ -929,10 +921,12 @@
     // 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));
+        error(
+            Diagnostic("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});
@@ -968,9 +962,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));
+      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())
@@ -980,8 +975,9 @@
     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 {
@@ -1036,13 +1032,15 @@
     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 "
+        "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.",
+        definedAt(toObjLoc(Sym.File)),
+        referencedBy(Sec.getSymLoc(Sym, Offset))));
   }
 
   // Relax relocations.
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -443,27 +443,10 @@
     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,
Index: include/lld/Common/ErrorHandler.h
===================================================================
--- include/lld/Common/ErrorHandler.h
+++ include/lld/Common/ErrorHandler.h
@@ -25,9 +25,10 @@
 //    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:
 //
@@ -80,6 +81,95 @@
 
 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;
@@ -91,29 +181,49 @@
   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().log(Msg); }
+
+inline void log(const Twine &Msg) {
+  ErrorHandler &EH = errorHandler();
+  EH.log(EH.LogName, 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