[lld-macho] Show source information for undefined references

[BertalanD]

Summary

The error used to look like this:

ld64.lld: error: undefined symbol: _foo
>>> referenced by /path/to/bar.o:(symbol _baz+0x4)

If DWARF line information is available, we now show where in the source
the references are coming from:

ld64.lld: error: unreferenced symbol: _foo
>>> referenced by: bar.cpp:42 (/path/to/bar.cpp:42)
>>>                /path/to/bar.o:(symbol _baz+0x4)

[thakis]

This looks excellent. Only inconsequential comments :)

lld/MachO/InputSection.cpp

111

nit: the verb has a space, "look up". ("lookup" is a noun. same for "set up" / "setup".)

116

nit: same

124

Do we have test coverage of all 3 scenarios (fun, var, file) in this function?

lld/MachO/SyntheticSections.h

438

const ref?

[BertalanD]

• Added a test for references originating from variables (couldn't produce a non-convoluted example that covers the third case
• Take emitBeginSourceStab's argument as a StringRef
• Fixed the spelling errors

[thakis]

LG!

[thakis]

Apologies, only after landing this did I realize that this makes ld64.lld crash on the repro in comment 0 of https://github.com/llvm/llvm-project/issues/56121

I'll revert this again for now, to keep HEAD green.

Lengthy stack below:

(lldb) r
Process 58952 launched: '/Users/thakis/src/llvm-project/out/gn/bin/ld64.lld' (arm64)
ld64.lld was compiled with optimization - stepping may behave oddly; variables may not be available.
Process 58952 stopped
* thread #16, stop reason = EXC_BAD_ACCESS (code=1, address=0xa00000129)
    frame #0: 0x0000000100606a80 ld64.lld`llvm::DWARFUnit::tryExtractDIEsIfNeeded(bool) [inlined] std::__1::vector<llvm::DWARFDebugInfoEntry, std::__1::allocator<llvm::DWARFDebugInfoEntry> >::empty(this=0x0000000a00000129 size=0) const at vector:524:23 [opt]
   521 	        {return static_cast<size_type>(__end_cap() - this->__begin_);}
   522 	    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
   523 	    bool empty() const _NOEXCEPT
-> 524 	        {return this->__begin_ == this->__end_;}
   525 	    size_type max_size() const _NOEXCEPT;
   526 	    void reserve(size_type __n);
   527 	    void shrink_to_fit() _NOEXCEPT;
Target 0: (ld64.lld) stopped.
(lldb) bt
* thread #16, stop reason = EXC_BAD_ACCESS (code=1, address=0xa00000129)
  * frame #0: 0x0000000100606a80 ld64.lld`llvm::DWARFUnit::tryExtractDIEsIfNeeded(bool) [inlined] std::__1::vector<llvm::DWARFDebugInfoEntry, std::__1::allocator<llvm::DWARFDebugInfoEntry> >::empty(this=0x0000000a00000129 size=0) const at vector:524:23 [opt]
    frame #1: 0x0000000100606a80 ld64.lld`llvm::DWARFUnit::tryExtractDIEsIfNeeded(this=0x0000000a00000009, CUDieOnly=true) at DWARFUnit.cpp:487:31 [opt]
    frame #2: 0x000000010060699c ld64.lld`llvm::DWARFUnit::extractDIEsIfNeeded(this=0x0000000a00000009, CUDieOnly=<unavailable>) at DWARFUnit.cpp:482:17 [opt]
    frame #3: 0x000000010060614c ld64.lld`llvm::DWARFUnit::getCompilationDir() [inlined] llvm::DWARFUnit::getUnitDIE(this=0x0000000a00000009, ExtractUnitDIEOnly=true) at DWARFUnit.h:403:5 [opt]
    frame #4: 0x0000000100606144 ld64.lld`llvm::DWARFUnit::getCompilationDir(this=0x0000000a00000009) at DWARFUnit.cpp:390:26 [opt]
    frame #5: 0x000000010025305c ld64.lld`lld::macho::ObjFile::sourceFile(this=0x00000001587fc698) const at InputFiles.cpp:1379:37 [opt]
    frame #6: 0x000000010027e280 ld64.lld`lld::macho::SymtabSection::emitStabs(this=0x000000028cdc4a00) at SyntheticSections.cpp:934:33 [opt]
    frame #7: 0x000000010027e850 ld64.lld`lld::macho::SymtabSection::finalizeContents(this=0x000000028cdc4a00) at SyntheticSections.cpp:1027:3 [opt]
    frame #8: 0x00000001002a4d74 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator()() [inlined] std::__1::__function::__value_func<void ()>::operator(this=0x0000600001809218)() const at function.h:509:16 [opt]
    frame #9: 0x00000001002a4d60 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator()() [inlined] std::__1::function<void ()>::operator(this=0x0000600001809218)() const at function.h:1186:12 [opt]
    frame #10: 0x00000001002a4d60 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator()() [inlined] llvm::ThreadPool::createTaskAndFuture(this=0x0000600001809208)>)::'lambda'()::operator()() const at ThreadPool.h:135:15 [opt]
    frame #11: 0x00000001002a4d60 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator()() [inlined] decltype(__f=0x0000600001809208)>)::'lambda'()&>(fp)()) std::__1::__invoke<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()&>(llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()&) at type_traits:2435:23 [opt]
    frame #12: 0x00000001002a4d60 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator()() [inlined] void std::__1::__invoke_void_return_wrapper<void, true>::__call<llvm::ThreadPool::createTaskAndFuture(__args=0x0000600001809208)>)::'lambda'()&>(llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()&) at invoke.h:61:9 [opt]
    frame #13: 0x00000001002a4d60 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator()() [inlined] std::__1::__function::__alloc_func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator(this=0x0000600001809208)() at function.h:182:16 [opt]
    frame #14: 0x00000001002a4d60 ld64.lld`std::__1::__function::__func<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'(), std::__1::allocator<llvm::ThreadPool::createTaskAndFuture(std::__1::function<void ()>)::'lambda'()>, void ()>::operator(this=0x0000600001809200)() at function.h:356:12 [opt]
    frame #15: 0x000000010035dd54 ld64.lld`llvm::ThreadPool::processTasks(llvm::ThreadPoolTaskGroup*) [inlined] std::__1::__function::__value_func<void ()>::operator(this=0x00000002da436f18)() const at function.h:509:16 [opt]
    frame #16: 0x000000010035dd40 ld64.lld`llvm::ThreadPool::processTasks(llvm::ThreadPoolTaskGroup*) [inlined] std::__1::function<void ()>::operator(this=0x00000002da436f18)() const at function.h:1186:12 [opt]
    frame #17: 0x000000010035dd40 ld64.lld`llvm::ThreadPool::processTasks(this=0x000000016fdfe1a0, WaitingForGroup=0x0000000000000000) at ThreadPool.cpp:99:5 [opt]
    frame #18: 0x000000010035e694 ld64.lld`void* llvm::thread::ThreadProxy<std::__1::tuple<llvm::ThreadPool::grow(int)::$_0> >(void*) [inlined] llvm::ThreadPool::grow(int)::$_0::operator()() const at ThreadPool.cpp:47:7 [opt]
    frame #19: 0x000000010035e680 ld64.lld`void* llvm::thread::ThreadProxy<std::__1::tuple<llvm::ThreadPool::grow(int)::$_0> >(void*) [inlined] void llvm::thread::Apply<llvm::ThreadPool::grow(int)::$_0>(std::__1::tuple<llvm::ThreadPool::grow(int)::$_0>&, std::__1::integer_sequence<unsigned long>) at thread.h:42:5 [opt]
    frame #20: 0x000000010035e680 ld64.lld`void* llvm::thread::ThreadProxy<std::__1::tuple<llvm::ThreadPool::grow(int)::$_0> >(void*) [inlined] void llvm::thread::GenericThreadProxy<std::__1::tuple<llvm::ThreadPool::grow(int)::$_0> >(Ptr=0x0000600000121490) at thread.h:50:5 [opt]
    frame #21: 0x000000010035e678 ld64.lld`void* llvm::thread::ThreadProxy<std::__1::tuple<llvm::ThreadPool::grow(int)::$_0> >(Ptr=0x0000600000121490) at thread.h:60:5 [opt]
    frame #22: 0x000000018c02626c libsystem_pthread.dylib`_pthread_start + 148

[BertalanD]

Looks like ObjFile::parseDebugInfo wasn't checking if there were any compilation units before assigning the iterator's value to compileUnit. I'm not sure why that didn't cause issues previously, it's maybe because we were taking slightly different code paths as we did not parse __debug_line. The following change makes lld not crash when linking the Chromium reproducer.

diff --git a/lld/MachO/InputFiles.cpp b/lld/MachO/InputFiles.cpp
index 2db8dae75d42..724e8f64d2ab 100644
--- a/lld/MachO/InputFiles.cpp
+++ b/lld/MachO/InputFiles.cpp
@@ -1015,7 +1015,10 @@ void ObjFile::parseDebugInfo() {
   // FIXME: There can be more than one compile unit per object file. See
   // PR48637.
   auto it = units.begin();
-  compileUnit = it->get();
+  if (it == units.end())
+    compileUnit = nullptr;
+  else
+    compileUnit = it->get();
 }
 
 ArrayRef<data_in_code_entry> ObjFile::getDataInCode() const {
@@ -1376,6 +1379,8 @@ void ObjFile::registerEhFrames(Section &ehFrameSection) {
 }
 
 std::string ObjFile::sourceFile() const {
+  if (!compileUnit)
+    return {};
   SmallString<261> dir(compileUnit->getCompilationDir());
   StringRef sep = sys::path::get_separator();
   // We don't use `path::append` here because we want an empty `dir` to result

I'll set up a build on Linux to check if the failures there go away as well.

[BertalanD]

Fix crash if no DWARF compile unit info is present.

[thakis]

It looks like lots of tests failed on the expensive-check bots (eg here https://lab.llvm.org/buildbot/#/builders/42/builds/5914) so we do have test coverage. Do you think it's easy to make a test that fails without expensive checks? (If not, it's fine as-is, given that some of the bots did catch this.)

[thakis]

In D128184#3597967, @BertalanD wrote:

Looks like ObjFile::parseDebugInfo wasn't checking if there were any compilation units before assigning the iterator's value to compileUnit. I'm not sure why that didn't cause issues previously, it's maybe because we were taking slightly different code paths as we did not parse __debug_line.

I think your __debug_line theory has legs. If I take the original patch and change just this:

 % git diff
diff --git a/lld/MachO/Dwarf.cpp b/lld/MachO/Dwarf.cpp
index 357503a655cd..24a6530795dd 100644
--- a/lld/MachO/Dwarf.cpp
+++ b/lld/MachO/Dwarf.cpp
@@ -29,7 +29,7 @@ std::unique_ptr<DwarfObject> DwarfObject::create(ObjFile *obj) {
     if (StringRef *s =
             StringSwitch<StringRef *>(isec->getName())
                 .Case(section_names::debugInfo, &dObj->infoSection.Data)
-                .Case(section_names::debugLine, &dObj->lineSection.Data)
+                //.Case(section_names::debugLine, &dObj->lineSection.Data)
                 .Case(section_names::debugAbbrev, &dObj->abbrevSection)
                 .Case(section_names::debugStr, &dObj->strSection)
                 .Default(nullptr)) {

…then my repro case no longer crashes.

So dereferencing end() happens to produce nullptr before by dumb luck, but doesn't after. And scarily, we don't have anything that catches us derefing end() in this scenario.

[BertalanD]

I checked the object in Chromium that caused the crash, and it indeed only has __debug_line but not the other DWARF sections. I'll have a think about crafting an object that has only one of the three sections that are currently parsed on trunk, and see if we can produce the same crash with it. I suppose if that works, I'll submit a separate diff with a fix for trunk and the test case.

[BertalanD]

Rebased onto D128294, which should fix the segmentation fault.

[thakis]

lld/MachO/InputFiles.cpp

1379

Do we need this check? All current callers of sourceFile() check compileUnit before calling this.

[BertalanD]

lld/MachO/InputFiles.cpp

1379

This sounds like one of those narrow vs wide contract API questions. Should I remove the check from here, replace it with an assert, or remove the check from getSourceLocation? I don't really have a preference.

[thakis]

lld/MachO/InputFiles.cpp

1379

I'd just remove the check. Adding an assert is fine, but it's kind of implied be the (then) unguarded deref

[BertalanD]

remove unnecessary null check

lld/MachO/Dwarf.h

public:
   void forEachInfoSections(
       llvm::function_ref<void(const llvm::DWARFSection &)> f) const override {
     f(infoSection);
   }
 
   llvm::StringRef getAbbrevSection() const override { return abbrevSection; }
   llvm::StringRef getStrSection() const override { return strSection; }
 
+  llvm::DWARFSection const &getLineSection() const override {
+    return lineSection;
+  }
+
   // Returns an instance of DwarfObject if the given object file has the
   // relevant DWARF debug sections.
   static std::unique_ptr<DwarfObject> create(ObjFile *);
 
 private:
   llvm::DWARFSection infoSection;
+  llvm::DWARFSection lineSection;
   llvm::StringRef abbrevSection;
   llvm::StringRef strSection;
 };
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Dwarf.cpp

 
 using namespace lld;
 using namespace lld::macho;
 using namespace llvm;
 
 std::unique_ptr<DwarfObject> DwarfObject::create(ObjFile *obj) {
   auto dObj = std::make_unique<DwarfObject>();
   bool hasDwarfInfo = false;
-  // LLD only needs to extract the source file path from the debug info, so we
-  // initialize DwarfObject with just the sections necessary to get that path.
-  // The debugger will locate the debug info via the object file paths that we
-  // emit in our STABS symbols, so we don't need to process & emit them
-  // ourselves.
+  // LLD only needs to extract the source file path and line numbers from the
+  // debug info, so we initialize DwarfObject with just the sections necessary
+  // to get that path. The debugger will locate the debug info via the object
+  // file paths that we emit in our STABS symbols, so we don't need to process &
+  // emit them ourselves.
   for (const InputSection *isec : obj->debugSections) {
     if (StringRef *s =
             StringSwitch<StringRef *>(isec->getName())
                 .Case(section_names::debugInfo, &dObj->infoSection.Data)
+                .Case(section_names::debugLine, &dObj->lineSection.Data)
                 .Case(section_names::debugAbbrev, &dObj->abbrevSection)
                 .Case(section_names::debugStr, &dObj->strSection)
                 .Default(nullptr)) {
       *s = toStringRef(isec->data);
       hasDwarfInfo = true;
     }
   }
 
   if (hasDwarfInfo)
     return dObj;
   return nullptr;
 }

lld/MachO/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_INPUT_FILES_H
 #define LLD_MACHO_INPUT_FILES_H
 
 #include "MachOStructs.h"
 #include "Target.h"
 
+#include "lld/Common/DWARF.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/TextAPI/TextAPIReader.h"
 
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class InputFile;
 } // namespace lto

 public:
   ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName,
           bool lazy = false);
   ArrayRef<llvm::MachO::data_in_code_entry> getDataInCode() const;
   template <class LP> void parse();
 
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
+  std::string sourceFile() const;
+  // Parses line table information for diagnostics. compileUnit should be used
+  // for other purposes.
+  lld::DWARFCache *getDwarf();
+
   llvm::DWARFUnit *compileUnit = nullptr;
+  std::unique_ptr<lld::DWARFCache> dwarfCache;
   Section *addrSigSection = nullptr;
   const uint32_t modTime;
   std::vector<ConcatInputSection *> debugSections;
   std::vector<CallGraphEntry> callGraph;
   llvm::DenseMap<ConcatInputSection *, FDE> fdes;
 
 private:
+  llvm::once_flag initDwarf;
   template <class LP> void parseLazy();
   template <class SectionHeader> void parseSections(ArrayRef<SectionHeader>);
   template <class LP>
   void parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                     ArrayRef<typename LP::nlist> nList, const char *strtab,
                     bool subsectionsViaSymbols);
   template <class NList>
   Symbol *parseNonSectionSymbol(const NList &sym, StringRef name);

lld/MachO/InputFiles.cpp

template <class LP> void ObjFile::parseLazy() {
   }
 }
 
 void ObjFile::parseDebugInfo() {
   std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
   if (!dObj)
     return;
 
+  // We do not re-use the context from getDwarf() here as that function
+  // constructs an expensive DWARFCache object.
   auto *ctx = make<DWARFContext>(
       std::move(dObj), "",
       [&](Error err) {
         warn(toString(this) + ": " + toString(std::move(err)));
       },
       [&](Error warning) {
         warn(toString(this) + ": " + toString(std::move(warning)));
       });
 
   // TODO: Since object files can contain a lot of DWARF info, we should verify
   // that we are parsing just the info we need
   const DWARFContext::compile_unit_range &units = ctx->compile_units();
   // FIXME: There can be more than one compile unit per object file. See
   // PR48637.
   auto it = units.begin();
-  compileUnit = it->get();
+  compileUnit = (it != units.end()) ? it->get() : nullptr;
 }
 
 ArrayRef<data_in_code_entry> ObjFile::getDataInCode() const {
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   const load_command *cmd = findCommand(buf, LC_DATA_IN_CODE);
   if (!cmd)
     return {};
   const auto *c = reinterpret_cast<const linkedit_data_command *>(cmd);
for (const Subsection &subsec : ehFrameSection.subsections) {
     }
 
     fdes[isec] = {funcLength, cie.personalitySymbol, lsdaIsec};
     funcSym->unwindEntry = isec;
     ehRelocator.commit();
   }
 }
 
+std::string ObjFile::sourceFile() const {
+  if (!compileUnit)
+    return {};
+  SmallString<261> dir(compileUnit->getCompilationDir());
+  StringRef sep = sys::path::get_separator();
+  // We don't use `path::append` here because we want an empty `dir` to result
+  // in an absolute path. `append` would give us a relative path for that case.
+  if (!dir.endswith(sep))
+    dir += sep;
+  return (dir + compileUnit->getUnitDIE().getShortName()).str();
+}
+
+lld::DWARFCache *ObjFile::getDwarf() {
+  llvm::call_once(initDwarf, [this]() {
+    auto dwObj = DwarfObject::create(this);
+    if (!dwObj)
+      return;
+    dwarfCache = std::make_unique<DWARFCache>(std::make_unique<DWARFContext>(
+        std::move(dwObj), "",
+        [&](Error err) { warn(getName() + ": " + toString(std::move(err))); },
+        [&](Error warning) {
+          warn(getName() + ": " + toString(std::move(warning)));
+        }));
+  });
+
+  return dwarfCache.get();
+}
 // The path can point to either a dylib or a .tbd file.
 static DylibFile *loadDylib(StringRef path, DylibFile *umbrella) {
   Optional<MemoryBufferRef> mbref = readFile(path);
   if (!mbref) {
     error("could not read dylib file at " + path);
     return nullptr;
   }
   return loadDylib(*mbref, umbrella);

lld/MachO/InputSection.h

public:
   uint32_t getFlags() const { return section.flags; }
   uint64_t getFileSize() const;
   // Translates \p off -- an offset relative to this InputSection -- into an
   // offset from the beginning of its parent OutputSection.
   virtual uint64_t getOffset(uint64_t off) const = 0;
   // The offset from the beginning of the file.
   uint64_t getVA(uint64_t off) const;
   // Return a user-friendly string for use in diagnostics.
+  // Format: /path/to/object.o:(symbol _func+0x123)
   std::string getLocation(uint64_t off) const;
+  // Return the source line corresponding to an address, or the empty string.
+  // Format: Source.cpp:123 (/path/to/Source.cpp:123)
+  std::string getSourceLocation(uint64_t off) const;
   // Whether the data at \p off in this InputSection is live.
   virtual bool isLive(uint64_t off) const = 0;
   virtual void markLive(uint64_t off) = 0;
   virtual InputSection *canonical() { return this; }
   virtual const InputSection *canonical() const { return this; }
 
 protected:
   InputSection(Kind kind, const Section &section, ArrayRef<uint8_t> data,
public:
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
   // The symbols that belong to this InputSection, sorted by value. With
   // .subsections_via_symbols, there is typically only one element here.
   llvm::TinyPtrVector<Defined *> symbols;
 
 protected:
   const Section &section;
+
+  const Defined *getContainingSymbol(uint64_t off) const;
 };
 
 // ConcatInputSections are combined into (Concat)OutputSections through simple
 // concatenation, in contrast with literal sections which may have their
 // contents merged before output.
 class ConcatInputSection final : public InputSection {
 public:
   ConcatInputSection(const Section &section, ArrayRef<uint8_t> data,

 constexpr const char cfString[] = "__cfstring";
 constexpr const char cgProfile[] = "__cg_profile";
 constexpr const char codeSignature[] = "__code_signature";
 constexpr const char common[] = "__common";
 constexpr const char compactUnwind[] = "__compact_unwind";
 constexpr const char data[] = "__data";
 constexpr const char debugAbbrev[] = "__debug_abbrev";
 constexpr const char debugInfo[] = "__debug_info";
+constexpr const char debugLine[] = "__debug_line";
 constexpr const char debugStr[] = "__debug_str";
 constexpr const char ehFrame[] = "__eh_frame";
 constexpr const char gccExceptTab[] = "__gcc_except_tab";
 constexpr const char export_[] = "__export";
 constexpr const char dataInCode[] = "__data_in_code";
 constexpr const char functionStarts[] = "__func_starts";
 constexpr const char got[] = "__got";
 constexpr const char header[] = "__mach_header";

lld/MachO/InputSection.cpp

if (relocAttrs.hasAttr(RelocAttrBits::BRANCH))
     return sym->resolveBranchVA();
   if (relocAttrs.hasAttr(RelocAttrBits::GOT))
     return sym->resolveGotVA();
   if (relocAttrs.hasAttr(RelocAttrBits::TLV))
     return sym->resolveTlvVA();
   return sym->getVA();
 }
 
+const Defined *InputSection::getContainingSymbol(uint64_t off) const {
+  auto *nextSym = llvm::upper_bound(
+      symbols, off, [](uint64_t a, const Defined *b) { return a < b->value; });
+  if (nextSym == symbols.begin())
+    return nullptr;
+  return *std::prev(nextSym);
+}
+
 std::string InputSection::getLocation(uint64_t off) const {
   // First, try to find a symbol that's near the offset. Use it as a reference
   // point.
-  auto *nextSym = llvm::upper_bound(
-      symbols, off, [](uint64_t a, const Defined *b) { return a < b->value; });
-  if (nextSym != symbols.begin()) {
-    auto &sym = *std::prev(nextSym);
+  if (auto *sym = getContainingSymbol(off))
     return (toString(getFile()) + ":(symbol " + sym->getName() + "+0x" +
             Twine::utohexstr(off - sym->value) + ")")
         .str();
-  }
 
   // If that fails, use the section itself as a reference point.
   for (const Subsection &subsec : section.subsections) {
     if (subsec.isec == this) {
       off += subsec.offset;
       break;
     }
   }
+
   return (toString(getFile()) + ":(" + getName() + "+0x" +
           Twine::utohexstr(off) + ")")
       .str();
 }
 
+std::string InputSection::getSourceLocation(uint64_t off) const {
+  auto *obj = dyn_cast<ObjFile>(getFile());
+  if (!obj)
+    return {};
+
+  DWARFCache *dwarf = obj->getDwarf();
+  if (!dwarf)
+    return std::string();
+
+  for (const Subsection &subsec : section.subsections) {
+    if (subsec.isec == this) {
+      off += subsec.offset;
+      break;
+    }
+  }
+
+  auto createMsg = [&](StringRef path, unsigned line) {
+    std::string filename = sys::path::filename(path).str();
+    std::string lineStr = (":" + Twine(line)).str();
+    if (filename == path)
+      return filename + lineStr;
+    return (filename + lineStr + " (" + path + lineStr + ")").str();
+  };
+
+  // First, look up a function for a given offset.
+  if (Optional<DILineInfo> li = dwarf->getDILineInfo(
+          section.addr + off, object::SectionedAddress::UndefSection))
+    return createMsg(li->FileName, li->Line);
+
+  // If it failed, look up again as a variable.
+  if (const Defined *sym = getContainingSymbol(off)) {
+    // Symbols are generally prefixed with an underscore, which is not included
+    // in the debug information.
+    StringRef symName = sym->getName();
+    if (!symName.empty() && symName[0] == '_')
+      symName = symName.substr(1);
+
+    if (Optional<std::pair<std::string, unsigned>> fileLine =
+            dwarf->getVariableLoc(symName))
+      return createMsg(fileLine->first, fileLine->second);
+  }
+
+  // Try to get the source file's name from the DWARF information.
+  if (obj->compileUnit)
+    return obj->sourceFile();
+
+  return {};
+}
+
 void ConcatInputSection::foldIdentical(ConcatInputSection *copy) {
   align = std::max(align, copy->align);
   copy->live = false;
   copy->wasCoalesced = true;
   copy->replacement = this;
   for (auto &copySym : copy->symbols)
     copySym->wasIdenticalCodeFolded = true;
 

lld/MachO/SymbolTable.cpp

for (const std::string &loc : locations.otherReferences) {
       message += "\n>>> referenced by " + loc;
       ++i;
     }
 
     for (const UndefinedDiag::SectionAndOffset &loc :
          locations.codeReferences) {
       if (i >= maxUndefinedReferences)
         break;
-      // TODO: Get source file/line from debug information.
-      message += "\n>>> referenced by " + loc.isec->getLocation(loc.offset);
+      message += "\n>>> referenced by ";
+      std::string src = loc.isec->getSourceLocation(loc.offset);
+      if (!src.empty())
+        message += src + "\n>>>               ";
+      message += loc.isec->getLocation(loc.offset);
       ++i;
     }
 
     size_t totalReferences =
         locations.otherReferences.size() + locations.codeReferences.size();
     if (totalReferences > i)
       message +=
           ("\n>>> referenced " + Twine(totalReferences - i) + " more times")

lld/MachO/SyntheticSections.h

public:
   uint32_t getNumSymbols() const;
   uint32_t getNumLocalSymbols() const {
     return stabs.size() + localSymbols.size();
   }
   uint32_t getNumExternalSymbols() const { return externalSymbols.size(); }
   uint32_t getNumUndefinedSymbols() const { return undefinedSymbols.size(); }
 
 private:
-  void emitBeginSourceStab(llvm::DWARFUnit *compileUnit);
+  void emitBeginSourceStab(StringRef);
   void emitEndSourceStab();
   void emitObjectFileStab(ObjFile *);
   void emitEndFunStab(Defined *);
   void emitStabs();
 
 protected:
   SymtabSection(StringTableSection &);
 

lld/MachO/SyntheticSections.cpp

 void FunctionStartsSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 SymtabSection::SymtabSection(StringTableSection &stringTableSection)
     : LinkEditSection(segment_names::linkEdit, section_names::symbolTable),
       stringTableSection(stringTableSection) {}
 
-void SymtabSection::emitBeginSourceStab(DWARFUnit *compileUnit) {
+void SymtabSection::emitBeginSourceStab(StringRef sourceFile) {
   StabsEntry stab(N_SO);
-  SmallString<261> dir(compileUnit->getCompilationDir());
-  StringRef sep = sys::path::get_separator();
-  // We don't use `path::append` here because we want an empty `dir` to result
-  // in an absolute path. `append` would give us a relative path for that case.
-  if (!dir.endswith(sep))
-    dir += sep;
-  stab.strx = stringTableSection.addString(
-      saver().save(dir + compileUnit->getUnitDIE().getShortName()));
+  stab.strx = stringTableSection.addString(saver().save(sourceFile));
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitEndSourceStab() {
   StabsEntry stab(N_SO);
   stab.sect = 1;
   stabs.emplace_back(std::move(stab));
 }
for (SortingPair &pair : symbolsNeedingStabs) {
     InputSection *isec = defined->isec;
     ObjFile *file = cast<ObjFile>(isec->getFile());
 
     if (lastFile == nullptr || lastFile != file) {
       if (lastFile != nullptr)
         emitEndSourceStab();
       lastFile = file;
 
-      emitBeginSourceStab(file->compileUnit);
+      emitBeginSourceStab(file->sourceFile());
       emitObjectFileStab(file);
     }
 
     StabsEntry symStab;
     symStab.sect = defined->isec->parent->index;
     symStab.strx = stringTableSection.addString(defined->getName());
     symStab.value = defined->getVA();
 

lld/test/MachO/invalid/undef-debug.s

+# REQUIRES: aarch64
+# RUN: llvm-mc -filetype=obj -triple=arm64-apple-macos %s -o %t.o
+# RUN: not %lld -arch arm64 %t.o -o /dev/null 2>&1 | FileCheck %s
+
+# CHECK: undefined symbol: _undef
+# CHECK-NEXT: >>> referenced by test.c:3
+# CHECK-NEXT: >>>               {{.*}}.o:(symbol _main+0x0)
+# CHECK-NEXT: >>> referenced by test.c:2
+# CHECK-NEXT  >>>               {{.*}}.o:(symbol _ptr+0x0)
+
+## This is the output of `clang -g2 -O2 -fdebug-compilation-dir=. -fno-ident` called on the following file, with the
+## Apple DWARF tables removed:
+##
+## int undef();
+## int (*ptr)() = &undef;
+## int main() { return undef(); };
+
+
+  .section  __TEXT,__text,regular,pure_instructions
+  .build_version macos, 12, 0  sdk_version 13, 0
+  .file 1 "." "test.c"
+  .globl  _main                           ; -- Begin function main
+  .p2align  2
+_main:                                  ; @main
+Lfunc_begin0:
+  .loc  1 3 0                           ; test.c:3:0
+  .cfi_startproc
+; %bb.0:
+  .loc  1 3 21 prologue_end             ; test.c:3:21
+  b _undef
+Ltmp0:
+Lfunc_end0:
+  .cfi_endproc
+                                        ; -- End function
+  .section  __DATA,__data
+  .globl  _ptr                            ; @ptr
+  .p2align  3
+_ptr:
+  .quad _undef
+
+  .section  __DWARF,__debug_abbrev,regular,debug
+Lsection_abbrev:
+  .byte 1                               ; Abbreviation Code
+  .byte 17                              ; DW_TAG_compile_unit
+  .byte 1                               ; DW_CHILDREN_yes
+  .byte 37                              ; DW_AT_producer
+  .byte 14                              ; DW_FORM_strp
+  .byte 19                              ; DW_AT_language
+  .byte 5                               ; DW_FORM_data2
+  .byte 3                               ; DW_AT_name
+  .byte 14                              ; DW_FORM_strp
+  .ascii  "\202|"                         ; DW_AT_LLVM_sysroot
+  .byte 14                              ; DW_FORM_strp
+  .ascii  "\357\177"                      ; DW_AT_APPLE_sdk
+  .byte 14                              ; DW_FORM_strp
+  .byte 16                              ; DW_AT_stmt_list
+  .byte 23                              ; DW_FORM_sec_offset
+  .byte 27                              ; DW_AT_comp_dir
+  .byte 14                              ; DW_FORM_strp
+  .ascii  "\341\177"                      ; DW_AT_APPLE_optimized
+  .byte 25                              ; DW_FORM_flag_present
+  .byte 17                              ; DW_AT_low_pc
+  .byte 1                               ; DW_FORM_addr
+  .byte 18                              ; DW_AT_high_pc
+  .byte 6                               ; DW_FORM_data4
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 2                               ; Abbreviation Code
+  .byte 52                              ; DW_TAG_variable
+  .byte 0                               ; DW_CHILDREN_no
+  .byte 3                               ; DW_AT_name
+  .byte 14                              ; DW_FORM_strp
+  .byte 73                              ; DW_AT_type
+  .byte 19                              ; DW_FORM_ref4
+  .byte 63                              ; DW_AT_external
+  .byte 25                              ; DW_FORM_flag_present
+  .byte 58                              ; DW_AT_decl_file
+  .byte 11                              ; DW_FORM_data1
+  .byte 59                              ; DW_AT_decl_line
+  .byte 11                              ; DW_FORM_data1
+  .byte 2                               ; DW_AT_location
+  .byte 24                              ; DW_FORM_exprloc
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 3                               ; Abbreviation Code
+  .byte 15                              ; DW_TAG_pointer_type
+  .byte 0                               ; DW_CHILDREN_no
+  .byte 73                              ; DW_AT_type
+  .byte 19                              ; DW_FORM_ref4
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 4                               ; Abbreviation Code
+  .byte 21                              ; DW_TAG_subroutine_type
+  .byte 1                               ; DW_CHILDREN_yes
+  .byte 73                              ; DW_AT_type
+  .byte 19                              ; DW_FORM_ref4
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 5                               ; Abbreviation Code
+  .byte 24                              ; DW_TAG_unspecified_parameters
+  .byte 0                               ; DW_CHILDREN_no
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 6                               ; Abbreviation Code
+  .byte 36                              ; DW_TAG_base_type
+  .byte 0                               ; DW_CHILDREN_no
+  .byte 3                               ; DW_AT_name
+  .byte 14                              ; DW_FORM_strp
+  .byte 62                              ; DW_AT_encoding
+  .byte 11                              ; DW_FORM_data1
+  .byte 11                              ; DW_AT_byte_size
+  .byte 11                              ; DW_FORM_data1
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 7                               ; Abbreviation Code
+  .byte 46                              ; DW_TAG_subprogram
+  .byte 0                               ; DW_CHILDREN_no
+  .byte 17                              ; DW_AT_low_pc
+  .byte 1                               ; DW_FORM_addr
+  .byte 18                              ; DW_AT_high_pc
+  .byte 6                               ; DW_FORM_data4
+  .ascii  "\347\177"                      ; DW_AT_APPLE_omit_frame_ptr
+  .byte 25                              ; DW_FORM_flag_present
+  .byte 64                              ; DW_AT_frame_base
+  .byte 24                              ; DW_FORM_exprloc
+  .byte 3                               ; DW_AT_name
+  .byte 14                              ; DW_FORM_strp
+  .byte 58                              ; DW_AT_decl_file
+  .byte 11                              ; DW_FORM_data1
+  .byte 59                              ; DW_AT_decl_line
+  .byte 11                              ; DW_FORM_data1
+  .byte 73                              ; DW_AT_type
+  .byte 19                              ; DW_FORM_ref4
+  .byte 63                              ; DW_AT_external
+  .byte 25                              ; DW_FORM_flag_present
+  .ascii  "\341\177"                      ; DW_AT_APPLE_optimized
+  .byte 25                              ; DW_FORM_flag_present
+  .byte 0                               ; EOM(1)
+  .byte 0                               ; EOM(2)
+  .byte 0                               ; EOM(3)
+  .section  __DWARF,__debug_info,regular,debug
+Lsection_info:
+Lcu_begin0:
+.set Lset0, Ldebug_info_end0-Ldebug_info_start0 ; Length of Unit
+  .long Lset0
+Ldebug_info_start0:
+  .short  4                               ; DWARF version number
+.set Lset1, Lsection_abbrev-Lsection_abbrev ; Offset Into Abbrev. Section
+  .long Lset1
+  .byte 8                               ; Address Size (in bytes)
+  .byte 1                               ; Abbrev [1] 0xb:0x69 DW_TAG_compile_unit
+  .long 0                               ; DW_AT_producer
+  .short  12                              ; DW_AT_language
+  .long 1                               ; DW_AT_name
+  .long 8                               ; DW_AT_LLVM_sysroot
+  .long 60                              ; DW_AT_APPLE_sdk
+.set Lset2, Lline_table_start0-Lsection_line ; DW_AT_stmt_list
+  .long Lset2
+  .long 71                              ; DW_AT_comp_dir
+                                        ; DW_AT_APPLE_optimized
+  .quad Lfunc_begin0                    ; DW_AT_low_pc
+.set Lset3, Lfunc_end0-Lfunc_begin0     ; DW_AT_high_pc
+  .long Lset3
+  .byte 2                               ; Abbrev [2] 0x32:0x15 DW_TAG_variable
+  .long 73                              ; DW_AT_name
+  .long 71                              ; DW_AT_type
+                                        ; DW_AT_external
+  .byte 1                               ; DW_AT_decl_file
+  .byte 2                               ; DW_AT_decl_line
+  .byte 9                               ; DW_AT_location
+  .byte 3
+  .quad _ptr
+  .byte 3                               ; Abbrev [3] 0x47:0x5 DW_TAG_pointer_type
+  .long 76                              ; DW_AT_type
+  .byte 4                               ; Abbrev [4] 0x4c:0x7 DW_TAG_subroutine_type
+  .long 83                              ; DW_AT_type
+  .byte 5                               ; Abbrev [5] 0x51:0x1 DW_TAG_unspecified_parameters
+  .byte 0                               ; End Of Children Mark
+  .byte 6                               ; Abbrev [6] 0x53:0x7 DW_TAG_base_type
+  .long 77                              ; DW_AT_name
+  .byte 5                               ; DW_AT_encoding
+  .byte 4                               ; DW_AT_byte_size
+  .byte 7                               ; Abbrev [7] 0x5a:0x19 DW_TAG_subprogram
+  .quad Lfunc_begin0                    ; DW_AT_low_pc
+.set Lset4, Lfunc_end0-Lfunc_begin0     ; DW_AT_high_pc
+  .long Lset4
+                                        ; DW_AT_APPLE_omit_frame_ptr
+  .byte 1                               ; DW_AT_frame_base
+  .byte 111
+  .long 81                              ; DW_AT_name
+  .byte 1                               ; DW_AT_decl_file
+  .byte 3                               ; DW_AT_decl_line
+  .long 83                              ; DW_AT_type
+                                        ; DW_AT_external
+                                        ; DW_AT_APPLE_optimized
+  .byte 0                               ; End Of Children Mark
+Ldebug_info_end0:
+  .section  __DWARF,__debug_str,regular,debug
+Linfo_string:
+  .byte 0                               ; string offset=0
+  .asciz  "test.c"                        ; string offset=1
+  .asciz  "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk" ; string offset=8
+  .asciz  "MacOSX.sdk"                    ; string offset=60
+  .asciz  "."                             ; string offset=71
+  .asciz  "ptr"                           ; string offset=73
+  .asciz  "int"                           ; string offset=77
+  .asciz  "main"                          ; string offset=81
+  .section  __DWARF,__debug_line,regular,debug
+Lsection_line:
+Lline_table_start0: