Change the error message format for undefined symbols.

[ruiu]

Summary

Previously, undefined symbol errors are one line like this
and wasn't easy to read.

/ssd/clang/bin/ld.lld: error: /ssd/llvm-project/lld/ELF/Writer.cpp:207: undefined symbol 'lld::elf::EhFrameSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::addSection(lld::elf::InputSectionBase*)'

This patch make it more structured like this.

bin/ld.lld: error: undefined symbol: lld::elf::EhFrameSection<llvm::object::ELFType<(llvm::support::endianness)0, true>
>>> Referenced by Writer.cpp:207 (/ssd/llvm-project/lld/ELF/Writer.cpp:207)
>>>               Writer.cpp.o in archive lib/liblldELF.a

Discussion thread is
http://lists.llvm.org/pipermail/llvm-dev/2017-March/111459.html

[• rafael]

lld/ELF/Error.cpp

83 ↗

(On Diff #93417)

Maybe factor these 3 lines into a small helper method?

lld/ELF/InputSection.cpp

264 ↗

(On Diff #93417)

Why does it have to be a function? Don't we want the same drag when, for example, a vtable has an undefined reference?

[ruiu]

• Address review comments.

[ruiu]

lld/ELF/Error.cpp

83 ↗

(On Diff #93417)

Done.

lld/ELF/InputSection.cpp

264 ↗

(On Diff #93417)

The current code does this too, but there's probably no strong reason to do this only for functions, so I made this to find any symbol that encloses a given location.

[• rafael]

LGTM with a nit.

lld/ELF/Relocations.cpp

623 ↗

(On Diff #93509)

Obj is never empty, is it?

624 ↗

(On Diff #93509)

If Obj is never empty you can factor

Msg += "\n>>> referenced by "

before the if/else if chain.

[ruiu]

lld/ELF/Relocations.cpp

623 ↗

(On Diff #93509)

If it is a synthetic section, it can be null, I think.

lld/trunk/ELF/Error.cpp

 uint64_t elf::ErrorCount;
 raw_ostream *elf::ErrorOS;
 StringRef elf::Argv0;
 
 // The functions defined in this file can be called from multiple threads,
 // but outs() or errs() are not thread-safe. We protect them using a mutex.
 static std::mutex Mu;
 
+// Prints "\n" or does nothing, depending on Msg contents of
+// the previous call of this function.
+static void newline(const Twine &Msg) {
+  // True if the previous error message contained "\n".
+  // We want to separate multi-line error messages with a newline.
+  static bool Flag;
+
+  if (Flag)
+    *ErrorOS << "\n";
+  Flag = (StringRef(Msg.str()).find('\n') != StringRef::npos);
+}
+
 static void print(StringRef S, raw_ostream::Colors C) {
   *ErrorOS << Argv0 + ": ";
   if (Config->ColorDiagnostics) {
     ErrorOS->changeColor(C, true);
     *ErrorOS << S;
     ErrorOS->resetColor();
   } else {
     *ErrorOS << S;
void elf::message(const Twine &Msg) {
   outs().flush();
 }
 
 void elf::warn(const Twine &Msg) {
   if (Config->FatalWarnings) {
     error(Msg);
     return;
   }
+
   std::lock_guard<std::mutex> Lock(Mu);
+  newline(Msg);
   print("warning: ", raw_ostream::MAGENTA);
   *ErrorOS << Msg << "\n";
 }
 
 void elf::error(const Twine &Msg) {
   std::lock_guard<std::mutex> Lock(Mu);
+  newline(Msg);
 
   if (Config->ErrorLimit == 0 || ErrorCount < Config->ErrorLimit) {
     print("error: ", raw_ostream::RED);
     *ErrorOS << Msg << "\n";
   } else if (ErrorCount == Config->ErrorLimit) {
     print("error: ", raw_ostream::RED);
     *ErrorOS << "too many errors emitted, stopping now"
              << " (use -error-limit=0 to see all errors)\n";
void elf::exitLld(int Val) {
   llvm_shutdown();
 
   outs().flush();
   errs().flush();
   _exit(Val);
 }
 
 void elf::fatal(const Twine &Msg) {
-  std::lock_guard<std::mutex> Lock(Mu);
-  print("error: ", raw_ostream::RED);
-  *ErrorOS << Msg << "\n";
+  error(Msg);
   exitLld(1);
 }

lld/trunk/ELF/InputFiles.h

 #include "llvm/Object/ELF.h"
 #include "llvm/Object/IRObjectFile.h"
 
 #include <map>
 
 namespace llvm {
 class DWARFDebugLine;
 class TarWriter;
+struct DILineInfo;
 namespace lto {
 class InputFile;
 }
 }
 
 namespace lld {
 namespace elf {
 class InputFile;
public:
   SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
     return getSymbolBody(SymIndex);
   }
 
   // Returns source line information for a given offset.
   // If no information is available, returns "".
   std::string getLineInfo(InputSectionBase *S, uint64_t Offset);
+  llvm::Optional<llvm::DILineInfo> getDILineInfo(InputSectionBase *, uint64_t);
 
   // MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
   uint32_t MipsGp0 = 0;
 
   // Name of source file obtained from STT_FILE symbol value,
   // or empty string if there is no such symbol in object file

lld/trunk/ELF/InputFiles.cpp

template <class ELFT> void elf::ObjectFile<ELFT>::initializeDwarfLine() {
   // for compilation unit (CU) of interest. We have only one
   // CU (object file), so offset is always 0.
   DwarfLine->getOrParseLineTable(LineData, 0);
 }
 
 // Returns source line information for a given offset
 // using DWARF debug info.
 template <class ELFT>
-std::string elf::ObjectFile<ELFT>::getLineInfo(InputSectionBase *S,
+Optional<DILineInfo> elf::ObjectFile<ELFT>::getDILineInfo(InputSectionBase *S,
                                                           uint64_t Offset) {
   if (!DwarfLine)
     initializeDwarfLine();
 
   // The offset to CU is 0.
   const DWARFDebugLine::LineTable *Tbl = DwarfLine->getLineTable(0);
   if (!Tbl)
-    return "";
+    return None;
 
   // Use fake address calcuated by adding section file offset and offset in
   // section. See comments for ObjectInfo class.
   DILineInfo Info;
   Tbl->getFileLineInfoForAddress(
       S->getOffsetInFile() + Offset, nullptr,
       DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, Info);
   if (Info.Line == 0)
-    return "";
-  return Info.FileName + ":" + std::to_string(Info.Line);
+    return None;
+  return Info;
+}
+
+// Returns source line information for a given offset
+// using DWARF debug info.
+template <class ELFT>
+std::string elf::ObjectFile<ELFT>::getLineInfo(InputSectionBase *S,
+                                               uint64_t Offset) {
+  if (Optional<DILineInfo> Info = getDILineInfo(S, Offset))
+    return Info->FileName + ":" + std::to_string(Info->Line);
 }
 
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
 std::string lld::toString(const InputFile *F) {
   if (!F)
     return "(internal)";
   if (!F->ArchiveName.empty())
     return (F->ArchiveName + "(" + F->getName() + ")").str();

lld/trunk/ELF/InputSection.h

public:
   }
 
   InputSectionBase *getLinkOrderDep() const;
 
   void uncompress();
 
   // Returns a source location string. Used to construct an error message.
   template <class ELFT> std::string getLocation(uint64_t Offset);
+  template <class ELFT> std::string getSrcMsg(uint64_t Offset);
+  template <class ELFT> std::string getObjMsg(uint64_t Offset);
 
   template <class ELFT> void relocate(uint8_t *Buf, uint8_t *BufEnd);
 
   std::vector<Relocation> Relocations;
 
   template <typename T> llvm::ArrayRef<T> getDataAs() const {
     size_t S = Data.size();
     assert(S % sizeof(T) == 0);

lld/trunk/ELF/InputSection.cpp

 #include "OutputSections.h"
 #include "Relocations.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Thunks.h"
 #include "llvm/Object/Decompressor.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Path.h"
 #include <mutex>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
+using namespace llvm::sys;
 
 using namespace lld;
 using namespace lld::elf;
 
 std::vector<InputSectionBase *> elf::InputSections;
 
 // Returns a string to construct an error message.
 std::string lld::toString(const InputSectionBase *Sec) {
if (auto *D = dyn_cast<DefinedRegular>(B))
       if (D->Section == this && D->Type == STT_FUNC)
         if (D->Value <= Offset && Offset < D->Value + D->Size)
           return SrcFile + ":(function " + toString(*D) + ")";
 
   // If there's no symbol, print out the offset in the section.
   return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
 }
 
+// Returns a source location string. 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.
+template <class ELFT> std::string InputSectionBase::getSrcMsg(uint64_t Offset) {
+  // Synthetic sections don't have input files.
+  elf::ObjectFile<ELFT> *File = getFile<ELFT>();
+  if (!File)
+    return "";
+
+  Optional<DILineInfo> Info = File->getDILineInfo(this, Offset);
+
+  // File->SourceFile contains STT_FILE symbol, and that is a last resort.
+  if (!Info)
+    return File->SourceFile;
+
+  std::string Path = Info->FileName;
+  std::string Filename = path::filename(Path);
+  std::string Lineno = ":" + std::to_string(Info->Line);
+  if (Filename == Path)
+    return Filename + Lineno;
+  return Filename + Lineno + " (" + Path + Lineno + ")";
+}
+
+// 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
+//
+//   path/to/foo.o:(function bar) in archive path/to/bar.a
+template <class ELFT> std::string InputSectionBase::getObjMsg(uint64_t Off) {
+  // Synthetic sections don't have input files.
+  elf::ObjectFile<ELFT> *File = getFile<ELFT>();
+  std::string Filename = File ? File->getName() : "(internal)";
+
+  std::string Archive;
+  if (!File->ArchiveName.empty())
+    Archive = (" in archive " + File->ArchiveName).str();
+
+  // Find a symbol that encloses a given location.
+  for (SymbolBody *B : getFile<ELFT>()->getSymbols())
+    if (auto *D = dyn_cast<DefinedRegular>(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();
+}
+
 InputSectionBase InputSectionBase::Discarded;
 
 InputSection::InputSection(uint64_t Flags, uint32_t Type, uint32_t Alignment,
                            ArrayRef<uint8_t> Data, StringRef Name, Kind K)
     : InputSectionBase(nullptr, Flags, Type,
                        /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Alignment, Data,
                        Name, K) {}
 

 template InputSection::InputSection(elf::ObjectFile<ELF64BE> *,
                                     const ELF64BE::Shdr *, StringRef);
 
 template std::string InputSectionBase::getLocation<ELF32LE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF32BE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t);
 
+template std::string InputSectionBase::getSrcMsg<ELF32LE>(uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF32BE>(uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF64LE>(uint64_t);
+template std::string InputSectionBase::getSrcMsg<ELF64BE>(uint64_t);
+
+template std::string InputSectionBase::getObjMsg<ELF32LE>(uint64_t);
+template std::string InputSectionBase::getObjMsg<ELF32BE>(uint64_t);
+template std::string InputSectionBase::getObjMsg<ELF64LE>(uint64_t);
+template std::string InputSectionBase::getObjMsg<ELF64BE>(uint64_t);
+
 template void InputSection::writeTo<ELF32LE>(uint8_t *);
 template void InputSection::writeTo<ELF32BE>(uint8_t *);
 template void InputSection::writeTo<ELF64LE>(uint8_t *);
 template void InputSection::writeTo<ELF64BE>(uint8_t *);
 
 template elf::ObjectFile<ELF32LE> *InputSectionBase::getFile<ELF32LE>() const;
 template elf::ObjectFile<ELF32BE> *InputSectionBase::getFile<ELF32BE>() const;
 template elf::ObjectFile<ELF64LE> *InputSectionBase::getFile<ELF64LE>() const;

lld/trunk/ELF/Relocations.cpp

static void reportUndefined(SymbolBody &Sym, InputSectionBase &S,
   if (Config->UnresolvedSymbols == UnresolvedPolicy::IgnoreAll)
     return;
 
   bool CanBeExternal = Sym.symbol()->computeBinding() != STB_LOCAL &&
                        Sym.getVisibility() == STV_DEFAULT;
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore && CanBeExternal)
     return;
 
-  std::string Msg = S.getLocation<ELFT>(Offset) + ": undefined symbol '" +
-                    toString(Sym) + "'";
+  std::string Msg =
+      "undefined symbol: " + toString(Sym) + "\n>>> referenced by ";
+
+  std::string Src = S.getSrcMsg<ELFT>(Offset);
+  if (!Src.empty())
+    Msg += Src + "\n>>>               ";
+  Msg += S.getObjMsg<ELFT>(Offset);
 
   if (Config->UnresolvedSymbols == UnresolvedPolicy::WarnAll ||
       (Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal)) {
     warn(Msg);
   } else {
     error(Msg);
+
     if (Config->ArchiveWithoutSymbolsSeen) {
       message("At least one archive listed no symbols in its index."
               " This can happen when creating archives with a version"
               " of ar that does not understand the object files in"
               " the archive. For example, if you are using LLVM"
               " bitcode objects (such as created by -flto), you may"
               " need to use llvm-ar or GNU ar with a plugin.");
       // Reset to false so that we print the message only once.

lld/trunk/test/ELF/libsearch.s

 // RUN:   | FileCheck --check-prefix=NOLIBRARY %s
 // NOLIBRARY: -l: missing argument
 
 // Should link normally, because _bar is not used
 // RUN: ld.lld -o %t3 %t.o
 // Should not link because of undefined symbol _bar
 // RUN: not ld.lld -o %t3 %t.o %tbar.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=UNDEFINED %s
-// UNDEFINED: error: {{.*}}:(.bar+0x0): undefined symbol '_bar'
+// UNDEFINED: error: undefined symbol: _bar
+// UNDEFINED: >>> referenced by {{.*}}:(.bar+0x0)
 
 // Should fail if cannot find specified library (without -L switch)
 // RUN: not ld.lld -o %t3 %t.o -lls 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIB %s
 // NOLIB: unable to find library -lls
 
 // Should use explicitly specified static library
 // Also ensure that we accept -L <arg>

lld/trunk/test/ELF/linkerscript/edata-etext.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t.script
 # RUN: not ld.lld %t.o -script %t.script -o %t 2>&1 | FileCheck %s
-# CHECK: error: {{.*}}:(.text+0x0): undefined symbol '_edata'
-# CHECK: error: {{.*}}:(.text+0x8): undefined symbol '_etext'
-# CHECK: error: {{.*}}:(.text+0x10): undefined symbol '_end'
+# CHECK: error: undefined symbol: _edata
+# CHECK: >>> referenced by {{.*}}:(.text+0x0)
+# CHECK: error: undefined symbol: _etext
+# CHECK: >>> referenced by {{.*}}:(.text+0x8)
+# CHECK: error: undefined symbol: _end
+# CHECK: >>> referenced by {{.*}}:(.text+0x10)
 
 .global _start,_end,_etext,_edata
 .text
 _start:
  .quad _edata + 0x1
  .quad _etext + 0x1
  .quad _end + 0x1
 
 .data
   .word 1
 .bss
   .align 4
   .space 6

lld/trunk/test/ELF/linkerscript/ehdr_start.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t.script
 # RUN: not ld.lld %t.o -script %t.script -o %t 2>&1 | FileCheck %s
-# CHECK: error: {{.*}}:(.text+0x0): undefined symbol '__ehdr_start'
+# CHECK: error: undefined symbol: __ehdr_start
+# CHECK: >>> referenced by {{.*}}:(.text+0x0)
 
 .text
 .global _start, __ehdr_start
 _start:
   .quad __ehdr_start

lld/trunk/test/ELF/lto/archive-no-index.ll

 ; RUN: ld.lld -emain -m elf_x86_64 %t.o -o %t %T/archive-no-index/libf.a \
 ; RUN:     %T/archive-no-index/libfs.a
 
 ; RUN: llvm-as %S/Inputs/archive-3.ll -o %T/archive-no-index/foo.o
 ; RUN: llvm-ar crs %T/archive-no-index/libfoo.a %T/archive-no-index/foo.o
 ; RUN: not ld.lld -emain -m elf_x86_64 %t.o -o %t %T/archive-no-index/libfoo.a \
 ; RUN:     2>&1 | FileCheck --check-prefix=NO-NOTE %s
 
-; NOTE: undefined symbol 'f'
+; NOTE: undefined symbol: f
 ; NOTE: archive listed no symbols
 
-; NO-NOTE: undefined symbol 'f'
+; NO-NOTE: undefined symbol: f
 ; NO-NOTE-NOT: archive listed no symbols
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @f()
 
 define i32 @main() {
   call void @f()
   ret i32 0
 }

lld/trunk/test/ELF/lto/combined-lto-object-name.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 ; RUN: not ld.lld -m elf_x86_64 %t.o -o %t2 2>&1 | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare void @foo()
 define void @_start() {
   call void @foo()
   ret void
 }
 
-; CHECK: error: ld-temp.o:(function _start): undefined symbol 'foo'
+; CHECK: error: undefined symbol: foo
+; CHECK: >>> referenced by ld-temp.o
+; CHECK:                   {{.*}}:(_start)

lld/trunk/test/ELF/sysroot.s

 // RUN: mkdir -p %t/lib
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t/m.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:     %p/Inputs/libsearch-st.s -o %t/st.o
 // RUN: rm -f %t/lib/libls.a
 // RUN: llvm-ar rcs %t/lib/libls.a %t/st.o
 // REQUIRES: x86
 
 // Should not link because of undefined symbol _bar
 // RUN: not ld.lld -o %t/r %t/m.o 2>&1 \
 // RUN:     | FileCheck --check-prefix=UNDEFINED %s
-// UNDEFINED: error: {{.*}}:(.text+0x1): undefined symbol '_bar'
+// UNDEFINED: error: undefined symbol: _bar
+// UNDEFINED: >>> referenced by {{.*}}:(.text+0x1)
 
 // We need to be sure that there is no suitable library in the /lib directory
 // RUN: not ld.lld -o %t/r %t/m.o -L/lib -l:libls.a 2>&1 \
 // RUN:     | FileCheck --check-prefix=NOLIB %s
 // NOLIB: unable to find library -l:libls.a
 
 // Should just remove the '=' symbol if --sysroot is not specified.
 // Case 1: relative path

lld/trunk/test/ELF/tls-static.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/shared.s -o %tso
 // RUN: ld.lld -static %t -o %tout
 // RUN: ld.lld %t -o %tout
 // RUN: ld.lld -shared %tso -o %tshared
 // RUN: not ld.lld -static %t %tshared -o %tout 2>&1 | FileCheck %s
 // REQUIRES: x86
 
 .global _start
 _start:
   call __tls_get_addr
 
-// CHECK: error: {{.*}}:(.text+0x1): undefined symbol '__tls_get_addr'
+// CHECK: error: undefined symbol: __tls_get_addr
+// CHECK: >>> referenced by {{.*}}:(.text+0x1)

lld/trunk/test/ELF/undef-shared.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
-# CHECK: error: {{.*}}:(.data+0x0): undefined symbol 'hidden'
+# CHECK: error: undefined symbol: hidden
+# CHECK: >>> referenced by {{.*}}:(.data+0x0)
 .global hidden
 .hidden hidden
 
-# CHECK: error: {{.*}}:(.data+0x8): undefined symbol 'internal'
+# CHECK: error: undefined symbol: internal
+# CHECK: >>> referenced by {{.*}}:(.data+0x8)
 .global internal
 .internal internal
 
-# CHECK: error: {{.*}}:(.data+0x10): undefined symbol 'protected'
+# CHECK: error: undefined symbol: protected
+# CHECK: >>> referenced by {{.*}}:(.data+0x10)
 .global protected
 .protected protected
 
 .section .data, "a"
  .quad hidden
  .quad internal
  .quad protected

lld/trunk/test/ELF/undef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef-debug.s -o %t3.o
 # RUN: llvm-ar rc %t2.a %t2.o
 # RUN: not ld.lld %t.o %t2.a %t3.o -o %t.exe 2>&1 | FileCheck %s
 # RUN: not ld.lld -pie %t.o %t2.a %t3.o -o %t.exe 2>&1 | FileCheck %s
-# CHECK: error: undef.s:(.text+0x1): undefined symbol 'foo'
-# CHECK: error: undef.s:(.text+0x6): undefined symbol 'bar'
-# CHECK: error: undef.s:(.text+0x10): undefined symbol 'foo(int)'
-# CHECK: error: {{.*}}2.a({{.*}}.o):(.text+0x0): undefined symbol 'zed2'
-# CHECK: error: dir{{/|\\}}undef-debug.s:3: undefined symbol 'zed3'
-# CHECK: error: dir{{/|\\}}undef-debug.s:7: undefined symbol 'zed4'
-# CHECK: error: dir{{/|\\}}undef-debug.s:11: undefined symbol 'zed5'
+
+# CHECK: error: undefined symbol: foo
+# CHECK: >>> referenced by undef.s
+# CHECK:                   {{.*}}:(.text+0x1)
+
+# CHECK: error: undefined symbol: bar
+# CHECK: >>> referenced by undef.s
+# CHECK: >>>               {{.*}}:(.text+0x6)
+
+# CHECK: error: undefined symbol: foo(int)
+# CHECK: >>> referenced by undef.s
+# CHECK: >>>               {{.*}}:(.text+0x10)
+
+# CHECK: error: undefined symbol: zed2
+# CHECK: >>> referenced by {{.*}}.o:(.text+0x0) in archive {{.*}}2.a
+
+# CHECK: error: undefined symbol: zed3
+# CHECK: >>> referenced by undef-debug.s:3 (dir{{/|\\}}undef-debug.s:3)
+# CHECK: >>>               {{.*}}.o:(.text+0x0)
+
+# CHECK: error: undefined symbol: zed4
+# CHECK: >>> referenced by undef-debug.s:7 (dir{{/|\\}}undef-debug.s:7)
+# CHECK: >>>               {{.*}}.o:(.text.1+0x0)
+
+# CHECK: error: undefined symbol: zed5
+# CHECK: >>> referenced by undef-debug.s:11 (dir{{/|\\}}undef-debug.s:11)
+# CHECK: >>>               {{.*}}.o:(.text.2+0x0)
 
 # RUN: not ld.lld %t.o %t2.a -o %t.exe -no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO-DEMANGLE %s
-# NO-DEMANGLE: error: undef.s:(.text+0x10): undefined symbol '_Z3fooi'
+# NO-DEMANGLE: error: undefined symbol: _Z3fooi
 
 .file "undef.s"
 
   .globl _start
 _start:
   call foo
   call bar
   call zed1
   call _Z3fooi

lld/trunk/test/ELF/unresolved-symbols.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/unresolved-symbols.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t.so
 
 ## Check that %t2.o contains undefined symbol undef.
 # RUN: not ld.lld %t1.o %t2.o -o %t 2>&1 | \
 # RUN:   FileCheck -check-prefix=UNDCHECK %s
-# UNDCHECK: error: {{.*}}2.o:(.text+0x1): undefined symbol 'undef'
+# UNDCHECK: error: undefined symbol: undef
+# UNDCHECK: >>> referenced by {{.*}}2.o:(.text+0x1)
 
 ## Error out if unknown option value was set.
 # RUN: not ld.lld %t1.o %t2.o -o %t --unresolved-symbols=xxx 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERR1 %s
 # ERR1: unknown --unresolved-symbols value: xxx
 
 ## Ignore all should not produce error for symbols from object except
 ## case when --no-undefined specified.
 # RUN: ld.lld %t2.o -o %t1_1 --unresolved-symbols=ignore-all
 # RUN: llvm-readobj %t1_1 > /dev/null 2>&1
 # RUN: not ld.lld %t2.o -o %t1_2 --unresolved-symbols=ignore-all --no-undefined 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERRUND %s
-# ERRUND: error: {{.*}}:(.text+0x1): undefined symbol 'undef'
+# ERRUND: error: undefined symbol: undef
+# ERRUND: >>> referenced by {{.*}}:(.text+0x1)
+
 ## Also ignore all should not produce error for symbols from DSOs.
 # RUN: ld.lld %t1.o %t.so -o %t1_3 --unresolved-symbols=ignore-all
 # RUN: llvm-readobj %t1_3 > /dev/null 2>&1
 
 ## Ignoring undefines in objects should not produce error for symbol from object.
 # RUN: ld.lld %t1.o %t2.o -o %t2 --unresolved-symbols=ignore-in-object-files
 # RUN: llvm-readobj %t2 > /dev/null 2>&1
 ## And still should not should produce for undefines from DSOs.

 ## undefines from DSO and do report undefines from object. With
 ## report-all specified and without.
 # RUN: ld.lld -shared %t1.o %t.so -o %t6 --unresolved-symbols=report-all
 # RUN: llvm-readobj %t6 > /dev/null 2>&1
 # RUN: ld.lld -shared %t1.o %t.so -o %t6_1
 # RUN: llvm-readobj %t6_1 > /dev/null 2>&1
 # RUN: not ld.lld %t2.o -o %t7 --unresolved-symbols=report-all 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERRUND %s
-# RUN: not ld.lld %t2.o -o %t7_1 2>&1 | \
-# RUN:   FileCheck -check-prefix=ERRUND %s
+# RUN: not ld.lld %t2.o -o %t7_1 2>&1 | FileCheck -check-prefix=ERRUND %s
 
 .globl _start
 _start:

lld/trunk/test/ELF/verneed-local.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: not ld.lld %t.o %S/Inputs/verneed1.so -o %t 2>&1 | FileCheck %s
 
-# CHECK: error: {{.*}}:(.text+0x1): undefined symbol 'f3'
+# CHECK: error: undefined symbol: f3
+# CHECK: >>> referenced by {{.*}}:(.text+0x1)
 .globl _start
 _start:
 call f3

lld/trunk/test/ELF/warn-unresolved-symbols-hidden.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: not ld.lld -shared %t.o -o %t.so -z defs --warn-unresolved-symbols 2>&1| FileCheck %s
 
-# CHECK: warning: {{.*}}: undefined symbol 'foo'
-# CHECK: error: {{.*}}: undefined symbol 'bar'
-# CHECK: error: {{.*}}: undefined symbol 'zed'
+# CHECK: warning: undefined symbol: foo
+# CHECK: error: undefined symbol: bar
+# CHECK: error: undefined symbol: zed
 
-        .data
-        .quad foo
-        .hidden bar
-        .quad bar
-        .protected zed
-        .quad zed

lld/trunk/test/ELF/warn-unresolved-symbols.s

 # RUN:  FileCheck -allow-empty -check-prefix=NOERR %s
 # RUN: ld.lld -shared %t1.o -o %t8.so --error-unresolved-symbols 2>&1 | \
 # RUN:  FileCheck -allow-empty -check-prefix=NOERR %s
 # RUN: ld.lld -r %t1.o -o %t9 -warn-unresolved-symbols 2>&1 | \
 # RUN:  FileCheck -allow-empty -check-prefix=NOWARN %s
 # RUN: ld.lld -shared %t1.o -o %t10.so --warn-unresolved-symbols 2>&1 | \
 # RUN:  FileCheck -allow-empty -check-prefix=NOWARN %s
 
-# ERRUND: error: {{.*}}:(.text+0x1): undefined symbol 'undef'
-# WARNUND: warning: {{.*}}:(.text+0x1): undefined symbol 'undef'
-# NOERR-NOT: error: {{.*}}:(.text+0x1): undefined symbol 'undef'
-# NOWARN-NOT: warning: {{.*}}:(.text+0x1): undefined symbol 'undef'
+# ERRUND: error: undefined symbol: undef
+# ERRUND: >>> referenced by {{.*}}:(.text+0x1)
+
+# WARNUND: warning: undefined symbol: undef
+# WARNUND: >>> referenced by {{.*}}:(.text+0x1)
+
+# NOERR-NOT: error: undefined symbol: undef
+# NOERR-NOT: >>> referenced by {{.*}}:(.text+0x1)
+
+# NOWARN-NOT: warning: undefined symbol: undef
+# NOWARN-NOT: >>> referenced by {{.*}}:(.text+0x1)
 
 .globl _start
 _start:
 
 .globl _shared
 _shared:
  callq undef@PLT

lld/trunk/test/ELF/zdefs.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t1.so
 
 # RUN: not ld.lld -z defs -shared %t.o -o %t1.so 2>&1 | FileCheck -check-prefix=ERR %s
-# ERR: error: {{.*}}:(.text+0x1): undefined symbol 'foo'
+# ERR: error: undefined symbol: foo
+# ERR: >>> referenced by {{.*}}:(.text+0x1)
 
 callq foo@PLT