COFF: Friendlier undefined symbol errors.

[pcc]

Summary

This change does three things:

• Try to find the file and line number information of an undefined symbol reference by reading codeview debug info.
• Try to find the name of the function or global variable with the undefined symbol reference by searching the object file's symbol table.
• Prints the information in the same style as the ELF linker.

[pcc]

The error messages look a little odd on non-Windows platforms:

ra/bin/lld-link: error: undefined symbol: ?foo@@YAHXZ
>>> referenced by \path\to\foo.cpp:4
>>>               foo.obj:(main)

(i.e. backslashes rather than slashes in the file path)

@zturner Would there be any downside to using slashes in our codeview output on non-Windows?

[zturner]

In D45467#1062509, @pcc wrote:

The error messages look a little odd on non-Windows platforms:

ra/bin/lld-link: error: undefined symbol: ?foo@@YAHXZ
>>> referenced by \path\to\foo.cpp:4
>>>               foo.obj:(main)

(i.e. backslashes rather than slashes in the file path)

@zturner Would there be any downside to using slashes in our codeview output on non-Windows?

We should probably use the native host slash for all paths. Reason being that MS tools need to be able to link our object files, and we don't have any control over how they handle slashes. Windows' tools handling of forward slashes in tools is pretty inconsistent, but in most cases doesn't work very well, so I would expect things to break if we have slashes (e.g. even if the linker doesn't break and dutifully copies a path with forward slashes into a PDB, the debugger could break).

[zturner]

I just noticed you said on non-Windows. Yea, I think the path should be whatever is native to the host you're building on.

[pcc]

• Remove getDebugChunks() check
• Update and add tests

[smeenai]

In D45467#1062522, @zturner wrote:

I just noticed you said on non-Windows. Yea, I think the path should be whatever is native to the host you're building on.

We cross-compile for Windows on Linux. If there's a change here, it would be awesome if I was CC'd, so I could test it with our setup and make sure VS and WinDbg are still happy.

[pcc]

In D45467#1062612, @smeenai wrote:

In D45467#1062522, @zturner wrote:

I just noticed you said on non-Windows. Yea, I think the path should be whatever is native to the host you're building on.

We cross-compile for Windows on Linux. If there's a change here, it would be awesome if I was CC'd, so I could test it with our setup and make sure VS and WinDbg are still happy.

The change is D45473 and I've cc'd you.

[zturner]

In D45467#1062612, @smeenai wrote:

In D45467#1062522, @zturner wrote:

I just noticed you said on non-Windows. Yea, I think the path should be whatever is native to the host you're building on.

We cross-compile for Windows on Linux. If there's a change here, it would be awesome if I was CC'd, so I could test it with our setup and make sure VS and WinDbg are still happy.

Cross compiling is a weird situation here, because the paths aren't going to make sense anyway (obviously you can't run your debugger on the same machine that the program was built on in that setup, therefore any paths in the PDB are necessarily going to be useless). So I think this should be a property of the machine you're building on (since that's the machine the source resides on, which is what the paths refer to), and have nothing to do with the target.

[pcc]

Ping.

[zturner]

I was out the second half of last week, so can you catch me up on what happened with the other patch and what you're waiting on here? Is the path issue all settled and now you just want feedback on the error message printing?

[ruiu]

lld/COFF/Chunks.h

195–197 ↗

(On Diff #141776)

If we can always do this, should we store Relocs as an ArrayRef instead of iterator_range in the first place?

lld/COFF/PDB.cpp

1161 ↗

(On Diff #141776)

Please add a function comment.

1170–1186 ↗

(On Diff #141776)

Can you factor this code out as a separate function?

1188 ↗

(On Diff #141776)

Maybe you can factor out this loop as a new function that returns a line table for a given address?

lld/COFF/SymbolTable.cpp

68 ↗

(On Diff #141776)

Add a function comment.

77–79 ↗

(On Diff #141776)

Instead of storing two separate values, you might be able to just save the symbol.

108 ↗

(On Diff #141776)

Use error().

[pcc]

In D45467#1069257, @zturner wrote:

I was out the second half of last week, so can you catch me up on what happened with the other patch and what you're waiting on here? Is the path issue all settled and now you just want feedback on the error message printing?

Yes, that patch landed and we now emit Unix-style paths on Unix hosts. I'm just waiting on review of the error message printing here.

[zturner]

lld/COFF/Chunks.h

195–197 ↗

(On Diff #141776)

Alternatively, why not just return an iterator_range?

lld/COFF/PDB.cpp

1193 ↗

(On Diff #141776)

Can we use a DenseMap here?

1210 ↗

(On Diff #141776)

Don't we already iterate the subsection list for other reasons in this file? Would it be worth piggybacking off of that to save the relevant info from the various subsections into each SectionChunk so that we can just do something like DbgC->Lines

lld/COFF/PDB.h

33–34 ↗

(On Diff #141776)

Can you take this argument by const& instead of by non-const pointer?

[pcc]

• Address review comments

lld/COFF/Chunks.h

195–197 ↗

(On Diff #141776)

Switching to ArrayRef made the code a little simpler and was done in D45714.

lld/COFF/PDB.cpp

1210 ↗

(On Diff #141776)

I don't think that would work. We read CV subsections elsewhere to create a PDB, but that needs to happen after we issue undefined symbol errors because it requires section contents to be relocated, which requires all sections to be laid out and all symbols to be defined. But if we're issuing an undefined symbol error then obviously not all symbols will be defined.

lld/COFF/PDB.h

33–34 ↗

(On Diff #141776)

Const seems fine but we usually pass pointers around in this part of the code for things like chunks.

[zturner]

Is there a particular reason to use a pointer? Inside the function it isn’t
null checked so we’re already assuming non null.

[pcc]

In D45467#1069517, @zturner wrote:

Is there a particular reason to use a pointer? Inside the function it isn’t
null checked so we’re already assuming non null.

It's just the local convention, but I can change this one if you feel strongly.

[ruiu]

lld/COFF/Chunks.h

195 ↗

(On Diff #142731)

Now we probably should just export Relocs instead of defining an accessor for it.

lld/COFF/PDB.cpp

1218 ↗

(On Diff #142731)

auto -> coff_relocation

1300–1301 ↗

(On Diff #142731)

Can you use real types instead of auto?

lld/COFF/SymbolTable.cpp

199–201 ↗

(On Diff #142731)

Something like this is I think more straightforward

errorOrWarn("undefined symbol: " + Sym->getName() + getSymbolLocations(File, SymIndex));

[zturner]

In D45467#1069519, @pcc wrote:

In D45467#1069517, @zturner wrote:

Is there a particular reason to use a pointer? Inside the function it isn’t
null checked so we’re already assuming non null.

It's just the local convention, but I can change this one if you feel strongly.

Eh, stick with the convention. Maybe in a follow up if I feel strongly enough I can throw up a patch to change the convention :)

[pcc]

• Address review comments

[ruiu]

LGTM

lld/COFF/SymbolTable.cpp

115 ↗

(On Diff #142736)

auto -> Location

COFF/Chunks.h

public:
   const coff_section *Header;
 
   // The file that this chunk was created from.
   ObjFile *File;
 
   // The COMDAT leader symbol if this is a COMDAT chunk.
   DefinedRegular *Sym = nullptr;
 
+  ArrayRef<coff_relocation> Relocs;
+
 private:
   StringRef SectionName;
   std::vector<SectionChunk *> AssocChildren;
-  ArrayRef<coff_relocation> Relocs;
 
   // Used by the garbage collector.
   bool Live;
 
   // Used for ICF (Identical COMDAT Folding)
   void replace(SectionChunk *Other);
   uint32_t Class[2] = {0, 0};
 };

COFF/InputFiles.cpp

SectionChunk *ObjFile::readSection(uint32_t SectionNumber,
   //
   // DWARF sections don't need any special handling from the perspective
   // of the linker; they are just a data section containing relocations.
   // We can just link them to complete debug info.
   //
   // CodeView needs a linker support. We need to interpret and debug
   // info, and then write it to a separate .pdb file.
 
-  // Ignore debug info unless /debug is given.
-  if (!Config->Debug && Name.startswith(".debug"))
+  // Ignore DWARF debug info unless /debug is given.
+  if (!Config->Debug && Name.startswith(".debug_"))
     return nullptr;
 
   if (Sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
     return nullptr;
   auto *C = make<SectionChunk>(this, Sec);
   if (Def)
     C->Checksum = Def->CheckSum;
 

COFF/PDB.h

 namespace codeview {
 union DebugInfo;
 }
 }
 
 namespace lld {
 namespace coff {
 class OutputSection;
+class SectionChunk;
 class SymbolTable;
 
 void createPDB(SymbolTable *Symtab,
                llvm::ArrayRef<OutputSection *> OutputSections,
                llvm::ArrayRef<uint8_t> SectionTable,
                const llvm::codeview::DebugInfo &BuildId);
+
+std::pair<llvm::StringRef, uint32_t> getFileLine(const SectionChunk *C,
+                                                 uint32_t Addr);
 }
 }
 
 #endif

COFF/PDB.cpp

void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
   ExitOnErr(
       DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
 }
 
 void PDBLinker::commit() {
   // Write to a file.
   ExitOnErr(Builder.commit(Config->PDBPath));
 }
+
+static Expected<StringRef>
+getFileName(const DebugStringTableSubsectionRef &Strings,
+            const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID) {
+  auto Iter = Checksums.getArray().at(FileID);
+  if (Iter == Checksums.getArray().end())
+    return make_error<CodeViewError>(cv_error_code::no_records);
+  uint32_t Offset = Iter->FileNameOffset;
+  return Strings.getString(Offset);
+}
+
+static uint32_t getSecrelReloc() {
+  switch (Config->Machine) {
+  case AMD64:
+    return COFF::IMAGE_REL_AMD64_SECREL;
+  case I386:
+    return COFF::IMAGE_REL_I386_SECREL;
+  case ARMNT:
+    return COFF::IMAGE_REL_ARM_SECREL;
+  case ARM64:
+    return COFF::IMAGE_REL_ARM64_SECREL;
+  default:
+    llvm_unreachable("unknown machine type");
+  }
+}
+
+// Try to find a line table for the given offset Addr into the given chunk C.
+// If a line table was found, the line table, the string and checksum tables
+// that are used to interpret the line table, and the offset of Addr in the line
+// table are stored in the output arguments. Returns whether a line table was
+// found.
+static bool findLineTable(const SectionChunk *C, uint32_t Addr,
+                          DebugStringTableSubsectionRef &CVStrTab,
+                          DebugChecksumsSubsectionRef &Checksums,
+                          DebugLinesSubsectionRef &Lines,
+                          uint32_t &OffsetInLinetable) {
+  ExitOnError ExitOnErr;
+  uint32_t SecrelReloc = getSecrelReloc();
+
+  for (SectionChunk *DbgC : C->File->getDebugChunks()) {
+    if (DbgC->getSectionName() != ".debug$S")
+      continue;
+
+    // Build a mapping of SECREL relocations in DbgC that refer to C.
+    DenseMap<uint32_t, uint32_t> Secrels;
+    for (const coff_relocation &R : DbgC->Relocs) {
+      if (R.Type != SecrelReloc)
+        continue;
+
+      if (auto *S = dyn_cast_or_null<DefinedRegular>(
+              C->File->getSymbols()[R.SymbolTableIndex]))
+        if (S->getChunk() == C)
+          Secrels[R.VirtualAddress] = S->getValue();
+    }
+
+    ArrayRef<uint8_t> Contents =
+        consumeDebugMagic(DbgC->getContents(), ".debug$S");
+    DebugSubsectionArray Subsections;
+    BinaryStreamReader Reader(Contents, support::little);
+    ExitOnErr(Reader.readArray(Subsections, Contents.size()));
+
+    for (const DebugSubsectionRecord &SS : Subsections) {
+      switch (SS.kind()) {
+      case DebugSubsectionKind::StringTable: {
+        assert(!CVStrTab.valid() &&
+               "Encountered multiple string table subsections!");
+        ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
+        break;
+      }
+      case DebugSubsectionKind::FileChecksums:
+        assert(!Checksums.valid() &&
+               "Encountered multiple checksum subsections!");
+        ExitOnErr(Checksums.initialize(SS.getRecordData()));
+        break;
+      case DebugSubsectionKind::Lines: {
+        ArrayRef<uint8_t> Bytes;
+        auto Ref = SS.getRecordData();
+        ExitOnErr(Ref.readLongestContiguousChunk(0, Bytes));
+        size_t OffsetInDbgC = Bytes.data() - DbgC->getContents().data();
+
+        // Check whether this line table refers to C.
+        auto I = Secrels.find(OffsetInDbgC);
+        if (I == Secrels.end())
+          break;
+
+        // Check whether this line table covers Addr in C.
+        DebugLinesSubsectionRef LinesTmp;
+        ExitOnErr(LinesTmp.initialize(BinaryStreamReader(Ref)));
+        uint32_t OffsetInC = I->second + LinesTmp.header()->RelocOffset;
+        if (Addr < OffsetInC || Addr >= OffsetInC + LinesTmp.header()->CodeSize)
+          break;
+
+        assert(!Lines.header() &&
+               "Encountered multiple line tables for function!");
+        ExitOnErr(Lines.initialize(BinaryStreamReader(Ref)));
+        OffsetInLinetable = Addr - OffsetInC;
+        break;
+      }
+      default:
+        break;
+      }
+
+      if (CVStrTab.valid() && Checksums.valid() && Lines.header())
+        return true;
+    }
+  }
+
+  return false;
+}
+
+// Use CodeView line tables to resolve a file and line number for the given
+// offset into the given chunk and return them, or {"", 0} if a line table was
+// not found.
+std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *C,
+                                                 uint32_t Addr) {
+  ExitOnError ExitOnErr;
+
+  DebugStringTableSubsectionRef CVStrTab;
+  DebugChecksumsSubsectionRef Checksums;
+  DebugLinesSubsectionRef Lines;
+  uint32_t OffsetInLinetable;
+
+  if (!findLineTable(C, Addr, CVStrTab, Checksums, Lines, OffsetInLinetable))
+    return {"", 0};
+
+  uint32_t NameIndex;
+  uint32_t LineNumber;
+  for (LineColumnEntry &Entry : Lines) {
+    for (const LineNumberEntry &LN : Entry.LineNumbers) {
+      if (LN.Offset > OffsetInLinetable) {
+        StringRef Filename =
+            ExitOnErr(getFileName(CVStrTab, Checksums, NameIndex));
+        return {Filename, LineNumber};
+      }
+      LineInfo LI(LN.Flags);
+      NameIndex = Entry.NameIndex;
+      LineNumber = LI.getStartLine();
+    }
+  }
+  StringRef Filename = ExitOnErr(getFileName(CVStrTab, Checksums, NameIndex));
+  return {Filename, LineNumber};
+}

COFF/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "Driver.h"
 #include "LTO.h"
+#include "PDB.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Timer.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>

 
 static void errorOrWarn(const Twine &S) {
   if (Config->Force)
     warn(S);
   else
     error(S);
 }
 
+// Returns the name of the symbol in SC whose value is <= Addr that is closest
+// to Addr. This is generally the name of the global variable or function whose
+// definition contains Addr.
+static StringRef getSymbolName(SectionChunk *SC, uint32_t Addr) {
+  DefinedRegular *Candidate = nullptr;
+
+  for (Symbol *S : SC->File->getSymbols()) {
+    auto *D = dyn_cast_or_null<DefinedRegular>(S);
+    if (!D || D->getChunk() != SC || D->getValue() > Addr ||
+        (Candidate && D->getValue() < Candidate->getValue()))
+      continue;
+
+    Candidate = D;
+  }
+
+  if (!Candidate)
+    return "";
+  return Candidate->getName();
+}
+
+static std::string getSymbolLocations(ObjFile *File, uint32_t SymIndex) {
+  struct Location {
+    StringRef SymName;
+    std::pair<StringRef, uint32_t> FileLine;
+  };
+  std::vector<Location> Locations;
+
+  for (Chunk *C : File->getChunks()) {
+    auto *SC = dyn_cast<SectionChunk>(C);
+    if (!SC)
+      continue;
+    for (const coff_relocation &R : SC->Relocs) {
+      if (R.SymbolTableIndex != SymIndex)
+        continue;
+      std::pair<StringRef, uint32_t> FileLine =
+          getFileLine(SC, R.VirtualAddress);
+      StringRef SymName = getSymbolName(SC, R.VirtualAddress);
+      if (!FileLine.first.empty() || !SymName.empty())
+        Locations.push_back({SymName, FileLine});
+    }
+  }
+
+  if (Locations.empty())
+    return "\n>>> referenced by " + toString(File) + "\n";
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  for (Location Loc : Locations) {
+    OS << "\n>>> referenced by ";
+    if (!Loc.FileLine.first.empty())
+      OS << Loc.FileLine.first << ":" << Loc.FileLine.second
+         << "\n>>>               ";
+    OS << toString(File);
+    if (!Loc.SymName.empty())
+      OS << ":(" << Loc.SymName << ')';
+  }
+  OS << '\n';
+  return OS.str();
+}
+
 void SymbolTable::reportRemainingUndefines() {
   SmallPtrSet<Symbol *, 8> Undefs;
   DenseMap<Symbol *, Symbol *> LocalImports;
 
   for (auto &I : SymMap) {
     Symbol *Sym = I.second;
     auto *Undef = dyn_cast<Undefined>(Sym);
     if (!Undef)
if (Undefs.count(B))
       errorOrWarn("<root>: undefined symbol: " + B->getName());
     if (Config->WarnLocallyDefinedImported)
       if (Symbol *Imp = LocalImports.lookup(B))
         warn("<root>: locally defined symbol imported: " + Imp->getName() +
              " (defined in " + toString(Imp->getFile()) + ") [LNK4217]");
   }
 
   for (ObjFile *File : ObjFile::Instances) {
+    size_t SymIndex = -1ull;
     for (Symbol *Sym : File->getSymbols()) {
+      ++SymIndex;
       if (!Sym)
         continue;
       if (Undefs.count(Sym))
-        errorOrWarn(toString(File) + ": undefined symbol: " + Sym->getName());
+        errorOrWarn("undefined symbol: " + Sym->getName() +
+                    getSymbolLocations(File, SymIndex));
       if (Config->WarnLocallyDefinedImported)
         if (Symbol *Imp = LocalImports.lookup(Sym))
           warn(toString(File) + ": locally defined symbol imported: " +
                Imp->getName() + " (defined in " + toString(Imp->getFile()) +
                ") [LNK4217]");
     }
   }
 }

test/COFF/filename-casing.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc -o %T/MixedCase.obj %s
 # RUN: not lld-link /entry:main %T/MixedCase.obj 2>&1 | FileCheck -check-prefix=OBJECT %s
 
 # RUN: llvm-lib /out:%T/MixedCase.lib %T/MixedCase.obj
 # RUN: not lld-link /machine:x64 /entry:main %T/MixedCase.lib 2>&1 | FileCheck -check-prefix=ARCHIVE %s
 
-# OBJECT: MixedCase.obj: undefined symbol: f
-# ARCHIVE: MixedCase.lib(MixedCase.obj): undefined symbol: f
+# OBJECT: undefined symbol: f
+# OBJECT-NEXT: >>> referenced by {{.*}}MixedCase.obj:(main)
+# ARCHIVE: undefined symbol: f
+# ARCHIVE-NEXT: >>> referenced by {{.*}}MixedCase.lib(MixedCase.obj):(main)
 
 .globl main
 main:
   callq f

test/COFF/force.test

 # RUN: yaml2obj < %s > %t.obj
 # RUN: not lld-link /out:%t.exe /entry:main %t.obj >& %t.log
 # RUN: FileCheck -check-prefix=ERROR %s < %t.log
 # RUN: lld-link /out:%t.exe /entry:main %t.obj /force >& %t.log
 # RUN: FileCheck -check-prefix=WARN %s < %t.log
 
-# ERROR: error: {{.*}}.obj: undefined symbol: foo
-# WARN: warning: {{.*}}.obj: undefined symbol: foo
+# ERROR: error: undefined symbol: foo
+# ERROR-NEXT: >>> referenced by {{.*}}.obj
+# WARN: warning: undefined symbol: foo
+# WARN-NEXT: >>> referenced by {{.*}}.obj
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]

test/COFF/nodefaultlib.test

 
 # RUN: lld-link /libpath:%T /out:%t.exe /entry:main \
 # RUN:   /subsystem:console hello64.obj /defaultlib:std64 \
 # RUN:   /nodefaultlib:std64.lib >& %t.log || true
 # RUN: FileCheck -check-prefix=CHECK3 %s < %t.log
 
 CHECK1: error: could not open hello64.obj: {{[Nn]}}o such file or directory
 CHECK2: error: could not open hello64: {{[Nn]}}o such file or directory
-CHECK3: error: {{.*}}hello64.obj: undefined symbol: MessageBoxA
+CHECK3: error: undefined symbol: MessageBoxA
+CHECK3-NEXT: >>> referenced by {{.*}}hello64.obj:(main)
 
 # RUN: lld-link /libpath:%T /out:%t.exe /entry:main \
 # RUN:   /subsystem:console hello64.obj /defaultlib:std64.lib
 
 # RUN: env LIB=%T lld-link /out:%t.exe /entry:main \
 # RUN:   /subsystem:console hello64.obj /defaultlib:std64.lib

test/COFF/undefined-symbol-cv.s

+# RUN: llvm-mc -triple=x86_64-windows-msvc -filetype=obj -o %t.obj %s
+# RUN: not lld-link /out:%t.exe %t.obj 2>&1 | FileCheck %s
+
+# CHECK: error: undefined symbol: ?foo@@YAHXZ
+# CHECK-NEXT: >>> referenced by file1.cpp:1
+# CHECK-NEXT: >>>               {{.*}}.obj:(main)
+# CHECK-NEXT: >>> referenced by file1.cpp:2
+# CHECK-NEXT: >>>               {{.*}}.obj:(main)
+
+# CHECK: error: undefined symbol: ?bar@@YAHXZ
+# CHECK-NEXT: >>> referenced by file2.cpp:3
+# CHECK-NEXT: >>>               {{.*}}.obj:(main)
+# CHECK-NEXT: >>> referenced by file1.cpp:4
+# CHECK-NEXT: >>>               {{.*}}.obj:(f1)
+
+# CHECK: error: undefined symbol: ?baz@@YAHXZ
+# CHECK-NEXT: >>> referenced by file1.cpp:5
+# CHECK-NEXT: >>>               {{.*}}.obj:(f2)
+
+  .cv_file  1 "file1.cpp" "EDA15C78BB573E49E685D8549286F33C" 1
+  .cv_file  2 "file2.cpp" "EDA15C78BB573E49E685D8549286F33D" 1
+
+        .section        .text,"xr",one_only,main
+.globl main
+main:
+  .cv_func_id 0
+  .cv_loc 0 1 1 0 is_stmt 0
+  call  "?foo@@YAHXZ"
+  .cv_loc 0 1 2 0
+  call  "?foo@@YAHXZ"
+  .cv_loc 0 2 3 0
+  call  "?bar@@YAHXZ"
+.Lfunc_end0:
+
+f1:
+  .cv_func_id 1
+  .cv_loc 1 1 4 0 is_stmt 0
+  call  "?bar@@YAHXZ"
+.Lfunc_end1:
+
+        .section        .text,"xr",one_only,f2
+.globl f2
+f2:
+  .cv_func_id 2
+  .cv_loc 2 1 5 0 is_stmt 0
+  call  "?baz@@YAHXZ"
+.Lfunc_end2:
+
+  .section  .debug$S,"dr",associative,main
+  .long 4
+  .cv_linetable 0, main, .Lfunc_end0
+  .cv_linetable 1, f1, .Lfunc_end1
+
+  .section  .debug$S,"dr",associative,f2
+  .long 4
+  .cv_linetable 2, f2, .Lfunc_end2
+
+  .section  .debug$S,"dr"
+  .long 4
+  .cv_filechecksums
+  .cv_stringtable

test/COFF/undefined-symbol.s

+# RUN: llvm-mc -triple=x86_64-windows-msvc -filetype=obj -o %t.obj %s
+# RUN: not lld-link /out:%t.exe %t.obj 2>&1 | FileCheck %s
+
+# CHECK: error: undefined symbol: ?foo@@YAHXZ
+# CHECK-NEXT: >>> referenced by {{.*}}.obj:(main)
+# CHECK-NEXT: >>> referenced by {{.*}}.obj:(main)
+
+# CHECK: error: undefined symbol: ?bar@@YAHXZ
+# CHECK-NEXT: >>> referenced by {{.*}}.obj:(main)
+# CHECK-NEXT: >>> referenced by {{.*}}.obj:(f1)
+
+# CHECK: error: undefined symbol: ?baz@@YAHXZ
+# CHECK-NEXT: >>> referenced by {{.*}}.obj:(f2)
+
+        .section        .text,"xr",one_only,main
+.globl main
+main:
+  call  "?foo@@YAHXZ"
+  call  "?foo@@YAHXZ"
+  call  "?bar@@YAHXZ"
+
+f1:
+  call  "?bar@@YAHXZ"
+.Lfunc_end1:
+
+        .section        .text,"xr",one_only,f2
+.globl f2
+f2:
+  call  "?baz@@YAHXZ"