[ELF] Show error location for 'undefined symbol' errors

[evgeny777]

Summary

The 'undefined symbol' is likely most common linker error, so linker typically show some location information
to make identifying problem source easier. With this patch lld will show following information about error source:

• Source file name in case STT_FILE symbol is present in object file
• Function name, if it can be retrieved.
• section name + offset

In addition to this ld/gold can show line number if debug info is present. This is the next thing I plan to do.

[evgeny777]

Fixed memory corruption

[grimar]

ELF/InputFiles.cpp

411 ↗

(On Diff #75298)

May be

if (!D || D->Section != S)

ELF/Relocations.cpp

543 ↗

(On Diff #75298)

Looks you do not need .str() here.

[evgeny777]

ELF/Relocations.cpp

543 ↗

(On Diff #75298)

Yes, I do. The type of expression is llvm::Twine because of S.Name and Twine::utohexstr(Offset)

[ruiu]

Thank you for doing this. This would be very useful.

ELF/Error.cpp

42 ↗

(On Diff #75298)

I think I'm inclined to showing ARGV[0] even for undefined symbol errors to keep them consistent with other linker-issued errors. I do not see a reason to not do except for making error lines a bit shorter.

ELF/InputFiles.cpp

405 ↗

(On Diff #75298)

A brief comment would be appreciated. Please note that this is not an optimized function but it is okay because this is for creating an error message.

407 ↗

(On Diff #75298)

This function can be implemented as a non-member function, no? Non-member functions are preferred over member functions if they access only public members.

409–411 ↗

(On Diff #75298)

for (...)
   if (auto *D = ...)
     if (D->Value <= ...)
        return D;
return nullptr;

ELF/InputFiles.h

178–179 ↗

(On Diff #75298)

I'd make SourceFile a public member variable and remove the accessor, as the accessor doesn't contain a logic.

182 ↗

(On Diff #75298)

Probably a personal taste, but how about getSymbolAt?

[evgeny777]

ELF/Error.cpp

42 ↗

(On Diff #75298)

No problem, but you'll get both path to linker and path to file in a single error message. Isn't this confusing? BTW ld and gold don't show argv0 for this error type.

[ruiu]

ELF/Error.cpp

42 ↗

(On Diff #75298)

Clang doesn't seem to print out a full path but instead of the last path component (so it prints out "clang-4.0" instead of "/foo/bar/clang-4.0"). We might want to do the same. But for now I think we want to handle all errors in the same way. We can tweak later if we want it.

[evgeny777]

ELF/InputFiles.cpp

407 ↗

(On Diff #75298)

No, it can't. It iterates SymbolBodies, which is member variable.

[evgeny777]

Addressed review comments

[evgeny777]

Added debugging information parser. See undef.s and undef-debug.s for test case.
Let me know if separate review required for this.

[grimar]

ELF/InputFiles.cpp

61 ↗

(On Diff #75427)

I wonder if this class can be not templated.
You probably can pass uint64_t Addr and DILineInfo &LineInfo only.

[evgeny777]

ELF/InputFiles.cpp

61 ↗

(On Diff #75427)

I was thinking about this also, but I need ObjectFile<ELFT> to construct object::ObjectFile. Also I need to know endianess and pointer size.

[evgeny777]

Code cleanups

[ruiu]

ELF/InputFiles.cpp

407 ↗

(On Diff #75298)

But you can use ObjectFile::getSymbols() instead, no?

[evgeny777]

ELF/InputFiles.cpp

407 ↗

(On Diff #75298)

Makes sense. May be also move it to Relocations.cpp?

[ruiu]

ELF/InputFiles.cpp

407 ↗

(On Diff #75298)

Yeah, I'd do that and make this a static function.

[ruiu]

ELF/InputFiles.h

51 ↗

(On Diff #75437)

I think this is too smart, at least as the initial implementation. This function is run only when an error occurs, and for error cases, we don't pursue performance. Instead I'd like to keep it simple as possible. So, could you please remove this class and define a non-member function? I think it is okay to parse debug info for each error message.

ELF/Relocations.cpp

569–571 ↗

(On Diff #75437)

Now that you can just concatenate strings before passing to the functions.

warn(Location + ": " + Msg);
error(Location + ": " + Msg);

So I think you don't need to add new overloaded functions to error.cpp.

[evgeny777]

ELF/Relocations.cpp

569–571 ↗

(On Diff #75437)

Actually location and message are separated by message type, i.e:

<Location> : warning : <Msg>

[ruiu]

ELF/Relocations.cpp

569–571 ↗

(On Diff #75437)

Did you have a reason to break consistency that way here?

[evgeny777]

ELF/InputFiles.h

51 ↗

(On Diff #75437)

could you please remove this class

I really really wouldn't like to do this. The main reason is that LLVM DWARF parser is very slow (main reason why lldb is so slow). If you want the numbers, here they are:

command (reports about 3K errors):

ld.lld LoopConvertCheck.cpp.o -o a.out

time w/o caching: 3m31.165s
time with caching: 0m1.659s

This is release build of lld on i7-2600K / SSD
Debug build had worked over 15 minutes, before I terminated it with Ctrl-C

May be it's better to simplify DIHelper somehow?

[evgeny777]

Addressed review comments

[• rafael]

This is awesome.

Fine by me with a nit, but please wait for Rui to LGTM too.

ELF/InputFiles.cpp

65 ↗

(On Diff #75682)

Can you move the call to getLineTable to the constructor and cache LineTbl?

[evgeny777]

ELF/InputFiles.cpp

65 ↗

(On Diff #75682)

Yes, it's possible to make LineTbl a member variable (together with DwarfLine), but getLineTable(Offset) is actually very fast. It's a single lookup in std::map with one element.

[ruiu]

LGTM with nits.

ELF/InputFiles.cpp

47 ↗

(On Diff #75682)

lineData -> LineData

56 ↗

(On Diff #75682)

Use unique_ptr to remove this dtor.

59–60 ↗

(On Diff #75682)

nit: move them after if (!DrawfLine) return "" so that we won't instantiate them if we return early.

ELF/Relocations.cpp

574–575 ↗

(On Diff #75682)

std::string Msg = getLocation(...) + ": undefined symbol: '" + ...

[evgeny777]

ELF/InputFiles.cpp

56 ↗

(On Diff #75682)

It's not possible unless you include DWARFContext.h to InputFiles.h or override unique_ptr deleter (second template parameter). Is this better?

lld/trunk/ELF/InputFiles.h

 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Support/StringSaver.h"
 
 #include <map>
 
 namespace llvm {
+class DWARFDebugLine;
 namespace lto {
 class InputFile;
 }
 }
 
 namespace lld {
 namespace elf {
 
 using llvm::object::Archive;
 
 class InputFile;
 class Lazy;
 class SymbolBody;
 
+// Debugging information helper class. The main purpose is to
+// retrieve source file and line for error reporting. Linker may
+// find reasonable number of errors in a single object file, so
+// we cache debugging information in order to parse it only once
+// for each object file we link.
+template <class ELFT> class DIHelper {
+public:
+  typedef typename ELFT::uint uintX_t;
+
+  DIHelper(InputFile *F);
+  std::string getLineInfo(uintX_t Offset);
+private:
+  std::unique_ptr<llvm::DWARFDebugLine> DwarfLine;
+};
+
 // The root class of input files.
 class InputFile {
 public:
   virtual ~InputFile() = default;
 
   enum Kind {
     ObjectKind,
     SharedKind,
public:
   template <typename RelT>
   SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
 
+  // DI helper allows manipilating debugging information for this
+  // object file. Used for error reporting.
+  DIHelper<ELFT> *getDIHelper();
+
   // Get 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 getMipsGp0() const;
 
   // The number is the offset in the string table. It will be used as the
   // st_name of the symbol.
   std::vector<std::pair<const DefinedRegular<ELFT> *, unsigned>> KeptLocalSyms;
 
   // SymbolBodies and Thunks for sections in this file are allocated
   // using this buffer.
   llvm::BumpPtrAllocator Alloc;
 
+  // Name of source file obtained from STT_FILE symbol value,
+  // or empty string if there is no such symbol in object file
+  // symbol table.
+  StringRef SourceFile;
+
 private:
   void
   initializeSections(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
   void initializeSymbols();
   void initializeReverseDependencies();
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec);
 
private:
   // MIPS .MIPS.options section defined by this file.
   std::unique_ptr<MipsOptionsInputSection<ELFT>> MipsOptions;
   // MIPS .MIPS.abiflags section defined by this file.
   std::unique_ptr<MipsAbiFlagsInputSection<ELFT>> MipsAbiFlags;
 
   llvm::SpecificBumpPtrAllocator<InputSection<ELFT>> IAlloc;
   llvm::SpecificBumpPtrAllocator<MergeInputSection<ELFT>> MAlloc;
   llvm::SpecificBumpPtrAllocator<EhInputSection<ELFT>> EHAlloc;
+  std::unique_ptr<DIHelper<ELFT>> DIH;
 };
 
 // LazyObjectFile is analogous to ArchiveFile in the sense that
 // the file contains lazy symbols. The difference is that
 // LazyObjectFile wraps a single file instead of multiple files.
 //
 // This class is used for --start-lib and --end-lib options which
 // instruct the linker to link object files between them with the

lld/trunk/ELF/InputFiles.cpp

 #include "Error.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/CodeGen/Analysis.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys::fs;
 
 using namespace lld;
 using namespace lld::elf;
 
 std::vector<InputFile *> InputFile::Pool;
 
+template <class ELFT> DIHelper<ELFT>::DIHelper(elf::InputFile *F) {
+  Expected<std::unique_ptr<object::ObjectFile>> Obj =
+      object::ObjectFile::createObjectFile(F->MB);
+  if (!Obj)
+    return;
+
+  DWARFContextInMemory Dwarf(*Obj.get());
+  DwarfLine.reset(new DWARFDebugLine(&Dwarf.getLineSection().Relocs));
+  DataExtractor LineData(Dwarf.getLineSection().Data,
+                         ELFT::TargetEndianness == support::little,
+                         ELFT::Is64Bits ? 8 : 4);
+  // The second parameter is offset in .debug_line section
+  // for compilation unit (CU) of interest. We have only one
+  // CU (object file), so offset is always 0.
+  DwarfLine->getOrParseLineTable(LineData, 0);
+}
+
+template <class ELFT> std::string DIHelper<ELFT>::getLineInfo(uintX_t Offset) {
+  if (!DwarfLine)
+    return "";
+
+  DILineInfo LineInfo;
+  DILineInfoSpecifier Spec;
+  // The offset to CU is 0 (see DIHelper constructor).
+  const DWARFDebugLine::LineTable *LineTbl = DwarfLine->getLineTable(0);
+  if (!LineTbl)
+    return "";
+  LineTbl->getFileLineInfoForAddress(Offset, nullptr, Spec.FLIKind, LineInfo);
+  return LineInfo.Line != 0
+             ? LineInfo.FileName + " (" + std::to_string(LineInfo.Line) + ")"
+             : "";
+}
+
 // Deletes all InputFile instances created so far.
 void InputFile::freePool() {
   // Files are freed in reverse order so that files created
   // from other files (e.g. object files extracted from archives)
   // are freed in the proper order.
   for (int I = Pool.size() - 1; I >= 0; --I)
     delete Pool[I];
 }

 
 template <class ELFT>
 ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getSymbols() {
   if (!this->Symtab)
     return this->SymbolBodies;
   return makeArrayRef(this->SymbolBodies).slice(1);
 }
 
+template <class ELFT> DIHelper<ELFT> *elf::ObjectFile<ELFT>::getDIHelper() {
+  if (!DIH)
+    DIH.reset(new DIHelper<ELFT>(this));
+
+  return DIH.get();
+}
+
 template <class ELFT> uint32_t elf::ObjectFile<ELFT>::getMipsGp0() const {
   if (ELFT::Is64Bits && MipsOptions && MipsOptions->Reginfo)
     return MipsOptions->Reginfo->ri_gp_value;
   if (!ELFT::Is64Bits && MipsReginfo && MipsReginfo->Reginfo)
     return MipsReginfo->Reginfo->ri_gp_value;
   return 0;
 }
 
elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   return S->Repl;
 }
 
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   int Binding = Sym->getBinding();
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
   if (Binding == STB_LOCAL) {
+    if (Sym->getType() == STT_FILE)
+      SourceFile = check(Sym->getName(this->StringTable));
     if (Sym->st_shndx == SHN_UNDEF)
       return new (this->Alloc)
           Undefined(Sym->st_name, Sym->st_other, Sym->getType(), this);
     return new (this->Alloc) DefinedRegular<ELFT>(*Sym, Sec);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable));
 

 template class elf::SharedFile<ELF32BE>;
 template class elf::SharedFile<ELF64LE>;
 template class elf::SharedFile<ELF64BE>;
 
 template InputFile *BinaryFile::createELF<ELF32LE>();
 template InputFile *BinaryFile::createELF<ELF32BE>();
 template InputFile *BinaryFile::createELF<ELF64LE>();
 template InputFile *BinaryFile::createELF<ELF64BE>();
+
+template class elf::DIHelper<ELF32LE>;
+template class elf::DIHelper<ELF32BE>;
+template class elf::DIHelper<ELF64LE>;
+template class elf::DIHelper<ELF64BE>;

lld/trunk/ELF/Relocations.cpp

if (Expr == R_GOTREL) {
         Addend += File.getMipsGp0();
     }
   }
   if (Config->Pic && Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
     Addend += getPPC64TocBase();
   return Addend;
 }
 
-static void reportUndefined(SymbolBody &Sym) {
+// Find symbol that encloses given offset. Used for error reporting.
+template <class ELFT>
+static DefinedRegular<ELFT> *getSymbolAt(InputSectionBase<ELFT> *S,
+                                         typename ELFT::uint Offset) {
+  for (SymbolBody *B : S->getFile()->getSymbols())
+    if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
+      if (D->Value <= Offset && D->Value + D->Size > Offset && D->Section == S)
+        return D;
+
+  return nullptr;
+}
+
+template <class ELFT>
+static std::string getLocation(SymbolBody &Sym, InputSectionBase<ELFT> &S,
+                               typename ELFT::uint Offset) {
+  ObjectFile<ELFT> *File = S.getFile();
+
+  // First check if we can get desired values from debugging information.
+  std::string LineInfo = File->getDIHelper()->getLineInfo(Offset);
+  if (!LineInfo.empty())
+    return LineInfo;
+
+  // If don't have STT_FILE typed symbol in object file then
+  // use object file name.
+  std::string SrcFile = File->SourceFile;
+  if (SrcFile.empty())
+    SrcFile = Sym.File ? getFilename(Sym.File) : getFilename(File);
+
+  DefinedRegular<ELFT> *Encl = getSymbolAt(&S, Offset);
+  if (Encl && Encl->Type == STT_FUNC) {
+    StringRef Func = getSymbolName(*File, *Encl);
+    return SrcFile + " (function " +
+           (Config->Demangle ? demangle(Func) : Func.str()) + ")";
+  }
+
+  return (SrcFile + " (" + S.Name + "+0x" + Twine::utohexstr(Offset) + ")")
+      .str();
+}
+
+template <class ELFT>
+static void reportUndefined(SymbolBody &Sym, InputSectionBase<ELFT> &S,
+                            typename ELFT::uint Offset) {
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
     return;
 
   if (Config->Shared && Sym.symbol()->Visibility == STV_DEFAULT &&
       Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
     return;
 
-  std::string Msg = "undefined symbol: ";
-  Msg += Config->Demangle ? demangle(Sym.getName()) : Sym.getName().str();
+  std::string Msg =
+      getLocation(Sym, S, Offset) + ": undefined symbol '" +
+      (Config->Demangle ? demangle(Sym.getName()) : Sym.getName().str()) + "'";
 
-  if (Sym.File)
-    Msg += " in " + getFilename(Sym.File);
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
     warn(Msg);
   else
     error(Msg);
 }
 
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
   for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
     const RelTy &RI = *I;
     SymbolBody &Body = File.getRelocTargetSym(RI);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
     // We only report undefined symbols if they are referenced somewhere in the
     // code.
     if (!Body.isLocal() && Body.isUndefined() && !Body.symbol()->isWeak())
-      reportUndefined(Body);
+      reportUndefined(Body, C, RI.r_offset);
 
     RelExpr Expr = Target->getRelExpr(Type, Body);
     bool Preemptible = isPreemptible(Body, Type);
     Expr = adjustExpr(File, Body, IsWrite, Expr, Type, Buf + RI.r_offset);
     if (HasError)
       continue;
 
     // Skip a relocation that points to a dead piece

lld/trunk/test/ELF/Inputs/undef-debug.s

+.file 1 "undef-debug.s"
+.loc 1 3
+        .quad zed3

lld/trunk/test/ELF/libsearch.s

 // RUN:   | FileCheck --check-prefix=NOLIBRARY %s
 // NOLIBRARY: missing arg value for "-l", expected 1 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: undefined symbol: _bar
+// UNDEFINED: error: {{.*}} (.bar+0x0): undefined symbol '_bar'
 
 // 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: undefined symbol: _edata
-# CHECK: undefined symbol: _etext
-# CHECK: undefined symbol: _end
+# CHECK: error: {{.*}} (.text+0x0): undefined symbol '_edata'
+# CHECK: error: {{.*}} (.text+0x8): undefined symbol '_etext'
+# CHECK: error: {{.*}} (.text+0x10): undefined symbol '_end'
 
 .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: undefined symbol: __ehdr_start
+# CHECK: error: {{.*}} (.text+0x0): undefined symbol '__ehdr_start'
 
 .text
 .global _start, __ehdr_start
 _start:
   .quad __ehdr_start

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: undefined symbol: foo in {{.*}}combined-lto-object-name.ll.tmp.o
+; CHECK: error: ld-temp.o (function _start): undefined symbol 'foo'

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: undefined symbol: _bar
+// UNDEFINED: error: {{.*}} (.text+0x1): undefined symbol '_bar'
 
 // 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: undefined symbol: __tls_get_addr
+// CHECK: error: {{.*}} (.text+0x1): undefined symbol '__tls_get_addr'

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: undefined symbol: hidden in {{.*}}
+# CHECK: error: {{.*}} (.data+0x0): undefined symbol 'hidden'
 .global hidden
 .hidden hidden
 
-# CHECK: undefined symbol: internal in {{.*}}
+# CHECK: error: {{.*}} (.data+0x8): undefined symbol 'internal'
 .global internal
 .internal internal
 
-# CHECK: undefined symbol: protected in {{.*}}
+# CHECK: error: {{.*}} (.data+0x10): undefined symbol 'protected'
 .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 -o %t.exe 2>&1 | FileCheck %s
-# RUN: not ld.lld -pie %t.o %t2.a -o %t.exe 2>&1 | FileCheck %s
-# CHECK: undefined symbol: foo in
-# CHECK: undefined symbol: bar in
-# CHECK: undefined symbol: foo(int) in
-# CHECK: undefined symbol: zed2 in {{.*}}2.a({{.*}}.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: undef-debug.s (3): undefined symbol 'zed3'
 
 # RUN: not ld.lld %t.o %t2.a -o %t.exe -no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO-DEMANGLE %s
-# NO-DEMANGLE: undefined symbol: _Z3fooi in
+# NO-DEMANGLE: error: undef.s (.text+0x10): 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: undefined symbol: undef in {{.*}}2.o
+# UNDCHECK: error: {{.*}}2.o (.text+0x1): undefined symbol 'undef'
 
 ## 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: undefined symbol: undef
+# ERRUND: error: {{.*}} (.text+0x1): undefined symbol 'undef'
 ## 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.

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: undefined symbol: f3 in
+# CHECK: error: {{.*}} (.text+0x1): undefined symbol 'f3'
 .globl _start
 _start:
 call f3

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: undefined symbol: foo
+# ERR: error: {{.*}} (.text+0x1): undefined symbol 'foo'
 
 callq foo@PLT