[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

455

May be

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

ELF/Relocations.cpp

544

Looks you do not need .str() here.

[evgeny777]

ELF/Relocations.cpp

544

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

449

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.

451

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.

453–455

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

ELF/InputFiles.h

201–202

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

205

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

451

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

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

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

451

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

[evgeny777]

ELF/InputFiles.cpp

451

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

[ruiu]

ELF/InputFiles.cpp

451

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

[ruiu]

ELF/InputFiles.h

52

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

580–582

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

580–582

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

<Location> : warning : <Msg>

[ruiu]

ELF/Relocations.cpp

580–582

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

[evgeny777]

ELF/InputFiles.h

52

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

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

[evgeny777]

ELF/InputFiles.cpp

65

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

lineData -> LineData

56

Use unique_ptr to remove this dtor.

59–60

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

ELF/Relocations.cpp

574–575

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

[evgeny777]

ELF/InputFiles.cpp

56

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

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);
+  ~DIHelper();
+  std::string getLineInfo(uintX_t Offset);
+
+private:
+  llvm::DWARFDebugLine *DwarfLine = nullptr;
+};
+
 // 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

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 = 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> DIHelper<ELFT>::~DIHelper() { delete DwarfLine; }
+
+template <class ELFT> std::string DIHelper<ELFT>::getLineInfo(uintX_t Offset) {
+  DILineInfo LineInfo;
+  DILineInfoSpecifier Spec;
+  if (!DwarfLine)
+    return "";
+
+  // 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;
 }
 
template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getElfSymbols(false);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
     SymbolBodies.push_back(createSymbolBody(&Sym));
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index >= Sections.size())
     fatal(getFilename(this) + ": invalid section index: " + Twine(Index));
   InputSectionBase<ELFT> *S = Sections[Index];
 
   // We found that GNU assembler 2.17.50 [FreeBSD] 2007-07-03
   // could generate broken objects. STT_SECTION symbols can be
   // associated with SHT_REL[A]/SHT_SYMTAB/SHT_STRTAB sections.
   // In this case it is fine for section to be null here as we
   // do not allocate sections of these types.
   if (!S) {
     if (Index == 0 || Sym.getType() == STT_SECTION)
       return nullptr;
     fatal(getFilename(this) + ": invalid section index: " + Twine(Index));
   }
 
   if (S == &InputSectionBase<ELFT>::Discarded)
     return S;
   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>;

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 Location = getLocation(Sym, S, Offset);
+  std::string Msg =
+      "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);
+    warn(Location + ": " + Msg);
   else
-    error(Msg);
+    error(Location + ": " + Msg);
 }
 
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
 // * For that, we need to know how many dynamic relocs we will have.
 // It might be possible to avoid this by outputting the file with write:
 // * Write the allocated output sections, computing addresses.
 // * Apply relocations, recording which ones require a dynamic reloc.
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

test/ELF/Inputs/undef-debug.s

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

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>

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

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

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'

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

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'

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

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

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.

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

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