[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

423

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

47

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

417

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.

419

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.

421–423

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

ELF/InputFiles.h

178–179

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

182

Probably a personal taste, but how about getSymbolAt?

[evgeny777]

ELF/Error.cpp

47

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

47

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

419

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

60

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

[evgeny777]

ELF/InputFiles.cpp

60

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

419

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

[evgeny777]

ELF/InputFiles.cpp

419

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

[ruiu]

ELF/InputFiles.cpp

419

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

[ruiu]

ELF/InputFiles.h

50

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

563–565

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

563–565

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

<Location> : warning : <Msg>

[ruiu]

ELF/Relocations.cpp

563–565

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

[evgeny777]

ELF/InputFiles.h

50

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

64

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

[evgeny777]

ELF/InputFiles.cpp

64

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

46

lineData -> LineData

55

Use unique_ptr to remove this dtor.

58–59

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

ELF/Relocations.cpp

557–561

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

[evgeny777]

ELF/InputFiles.cpp

55

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

ELF/Error.h

 namespace elf {
 
 extern bool HasError;
 extern llvm::raw_ostream *ErrorOS;
 extern llvm::StringRef Argv0;
 
 void log(const Twine &Msg);
 void warn(const Twine &Msg);
+void warn(const Twine &Source, const Twine &Msg);
 
 void error(const Twine &Msg);
+void error(const Twine &Source, const Twine &Msg);
 void error(std::error_code EC, const Twine &Prefix);
 
 template <typename T> void error(const ErrorOr<T> &V, const Twine &Prefix) {
   error(V.getError(), Prefix);
 }
 
 LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg);
 LLVM_ATTRIBUTE_NORETURN void fatal(std::error_code EC, const Twine &Prefix);

ELF/Error.cpp

 raw_ostream *elf::ErrorOS;
 StringRef elf::Argv0;
 
 void elf::log(const Twine &Msg) {
   if (Config->Verbose)
     outs() << Argv0 << ": " << Msg << "\n";
 }
 
-void elf::warn(const Twine &Msg) {
+static void output(const Twine &Type, const Twine &Source, const Twine &Msg) {
+  *elf::ErrorOS << elf::Argv0 << ": " << Source << ": " << Type << ": " << Msg
+                << "\n";
+}
+
+void elf::warn(const Twine &Msg) { warn(Twine(), Msg); }
+
+void elf::warn(const Twine &Source, const Twine &Msg) {
   if (Config->FatalWarnings)
-    error(Msg);
+    error(Source, Msg);
   else
-    *ErrorOS << Argv0 << ": warning: " << Msg << "\n";
+    output("warning", Source, Msg);
 }
 
-void elf::error(const Twine &Msg) {
-  *ErrorOS << Argv0 << ": error: " << Msg << "\n";
+void elf::error(const Twine &Msg) { error(Twine(), Msg); }
+
+void elf::error(const Twine &Source, const Twine &Msg) {
+  output("error", Source, Msg);
   HasError = true;
 }
 
 void elf::error(std::error_code EC, const Twine &Prefix) {
   error(Prefix + ": " + EC.message());
 }
 
 void elf::fatal(const Twine &Msg) {
-  *ErrorOS << Argv0 << ": error: " << Msg << "\n";
+  output("error", Twine(), Msg);
   exit(1);
 }
 
 void elf::fatal(std::error_code EC, const Twine &Prefix) {
   fatal(Prefix + ": " + EC.message());
 }
 
 } // namespace lld

ELF/InputFiles.h

 class Lazy;
 class SymbolBody;
 
 // The root class of input files.
 class InputFile {
 public:
   virtual ~InputFile() = default;
 
   enum Kind {
     ObjectKind,
     SharedKind,
     LazyObjectKind,
     ArchiveKind,
     BitcodeKind,
     BinaryKind,
   };
 
public:
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
 
   // 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;
 
+  // Gets symbol which encloses given offset and belongs to given section
+  DefinedRegular<ELFT> *getSymbolAt(InputSectionBase<ELFT> *S, uintX_t Offset);
+
   // 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<StringRef> &ComdatGroups);
   void initializeSymbols();
   void initializeReverseDependencies();
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec);
 
   bool shouldMerge(const Elf_Shdr &Sec);

ELF/InputFiles.cpp

 // 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];
 }
 
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
 std::string elf::getFilename(const InputFile *F) {
   if (!F)
     return "(internal)";
   if (!F->ArchiveName.empty())
     return (F->ArchiveName + "(" + F->getName() + ")").str();
   return F->getName();
 }
 
 template <class ELFT> static ELFFile<ELFT> createELFObj(MemoryBufferRef MB) {
   std::error_code EC;
   ELFFile<ELFT> F(MB.getBuffer(), EC);
   if (EC)
     fatal(EC, "failed to read " + MB.getBufferIdentifier());
   return F;
 }
 
 template <class ELFT> static ELFKind getELFKind() {
   if (ELFT::TargetEndianness == support::little)
     return ELFT::Is64Bits ? ELF64LEKind : ELF32LEKind;
   return ELFT::Is64Bits ? ELF64BEKind : ELF32BEKind;
 }
 
 template <class ELFT>
 ELFFileBase<ELFT>::ELFFileBase(Kind K, MemoryBufferRef MB)
     : InputFile(K, MB), ELFObj(createELFObj<ELFT>(MB)) {
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));
 }
 
+// Find symbol that encloses given offset. Used for error reporting.
+template <class ELFT>
+DefinedRegular<ELFT> *
+elf::ObjectFile<ELFT>::getSymbolAt(InputSectionBase<ELFT> *S, uintX_t Offset) {
+  for (SymbolBody *B : SymbolBodies)
+    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>
 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));
 

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) {
+template <class ELFT>
+static std::string getLocation(SymbolBody &Sym, InputSectionBase<ELFT> &S,
+                               typename ELFT::uint Offset) {
+  ObjectFile<ELFT> *File = S.getFile();
+  std::string SrcFile = File->SourceFile;
+
+  // If don't have STT_FILE typed symbol in object file then
+  // use object file name.
+  if (SrcFile.empty())
+    SrcFile = Sym.File ? getFilename(Sym.File) : getFilename(File);
+
+  DefinedRegular<ELFT> *Encl = File->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/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: (.bar+0x0): error: 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: (.text+0x0): error: undefined symbol '_edata'
+# CHECK: (.text+0x8): error: undefined symbol '_etext'
+# CHECK: (.text+0x10): error: 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: (.text+0x0): error: 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: ld-temp.o (function _start): error: 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: (.text+0x1): error: 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: (.text+0x1): error: 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: {{.*}} (.data+0x0): error: undefined symbol 'hidden'
 .global hidden
 .hidden hidden
 
-# CHECK: undefined symbol: internal in {{.*}}
+# CHECK: {{.*}} (.data+0x8): error: undefined symbol 'internal'
 .global internal
 .internal internal
 
-# CHECK: undefined symbol: protected in {{.*}}
+# CHECK: {{.*}} (.data+0x10): error: 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-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)
+# CHECK: undef.s (.text+0x1): error: undefined symbol 'foo'
+# CHECK: undef.s (.text+0x6): error: undefined symbol 'bar'
+# CHECK: undef.s (.text+0x10): error: undefined symbol 'foo(int)'
+# CHECK: {{.*}}2.a({{.*}}.o) (.text+0x0): error: undefined symbol 'zed2'
 
 # 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: undef.s (.text+0x10): error: 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: {{.*}}2.o (.text+0x1): error: 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: (.text+0x1): error: 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: (.text+0x1): error: 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: (.text+0x1): error: undefined symbol 'foo'
 
 callq foo@PLT