[lld-macho] Add addition debug info

[oontvoo]

@int3: not sure how to write a good test for this ?

[int3]

This is for https://bugs.llvm.org/show_bug.cgi?id=49282 right? For testing you could create a file with an undefined symbol. See e.g. test/ELF/undef.s.

Btw, I think you didn't upload all your local changes, since DwarfObject::find doesn't exist in my local repo :)

[oontvoo]

updated diff to include the whole patch

[oontvoo]

In D99385#2651954, @int3 wrote:

This is for https://bugs.llvm.org/show_bug.cgi?id=49282 right? For testing you could create a file with an undefined symbol. See e.g. test/ELF/undef.s.

Yeah. Thanks

Btw, I think you didn't upload all your local changes, since DwarfObject::find doesn't exist in my local repo :)

Updated. Sorry about that!

[int3]

will do the rest of the review when the diff is ready :)

lld/MachO/Dwarf.cpp

64

apparently the convention (not my personal favorite) is to do nullchecks this way

68

I don't think the Mach-O format guarantees they're sorted

[oontvoo]

updated diff:

• stop excluding debug sessions from reloc-parsing (cos we need the info)
• added some test

pending issue: test didn't pass :-( ... it seems the reloc offset is wrong (and we coulnd't find it ...) Or I'm mis-interpretting it. Thoughts?

[int3]

hmm how is find() getting called?

[oontvoo]

rebase + addressed comments

[oontvoo]

Wait, I've messed up the rebase ...

[oontvoo]

move str literals into section_names

[thakis]

Just for my understanding: This loads more dwarf data into memory (so that we can use it for diags), but it doesn't write it to the output, right?

[oontvoo]

In D99385#2797035, @thakis wrote:

Just for my understanding: This loads more dwarf data into memory (so that we can use it for diags), but it doesn't write it to the output, right?

Yes - that's correct

[int3]

I don't see any tests, so I'm assuming that you're still iterating on this?

[int3]

clearing my queue

lld/MachO/Dwarf.h

 //===- DWARF.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_DWARF_H
 #define LLD_MACHO_DWARF_H
 
+#include "Relocations.h"
+
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DWARF/DWARFObject.h"
 
 namespace lld {
 namespace macho {
 
 class ObjFile;
 
+class MachODWARFSection final : public llvm::DWARFSection {
+public:
+  const InputSection *isec = nullptr;
+};
+
 // Implements the interface between LLVM's DWARF-parsing utilities and LLD's
 // InputSection structures.
 class DwarfObject final : public llvm::DWARFObject {
 public:
   bool isLittleEndian() const override { return true; }
 
   llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &sec,
-                                            uint64_t pos) const override {
-    // TODO: implement this
-    return llvm::None;
-  }
+                                            uint64_t pos) const override;
 
   void forEachInfoSections(
       llvm::function_ref<void(const llvm::DWARFSection &)> f) const override {
     f(infoSection);
   }
 
+  const llvm::DWARFSection &getLineSection() const override {
+    return lineSection;
+  }
+
+  const llvm::DWARFSection &getAddrSection() const override {
+    return addrSection;
+  }
+
   llvm::StringRef getAbbrevSection() const override { return abbrevSection; }
+  llvm::StringRef getLineStrSection() const override { return lineStrSection; }
   llvm::StringRef getStrSection() const override { return strSection; }
 
   // 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;
+  MachODWARFSection addrSection;
+  MachODWARFSection infoSection;
+  MachODWARFSection lineSection;
+
   llvm::StringRef abbrevSection;
+  llvm::StringRef lineStrSection;
   llvm::StringRef strSection;
 };
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Dwarf.cpp

std::unique_ptr<DwarfObject> DwarfObject::create(ObjFile *obj) {
   // 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.
   for (const InputSection *isec : obj->debugSections) {
     if (StringRef *s =
             StringSwitch<StringRef *>(isec->name)
-                .Case(section_names::debugInfo, &dObj->infoSection.Data)
+                .Case(section_names::debugLineStr, &dObj->lineStrSection)
                 .Case(section_names::debugAbbrev, &dObj->abbrevSection)
                 .Case(section_names::debugStr, &dObj->strSection)
                 .Default(nullptr)) {
       *s = toStringRef(isec->data);
       hasDwarfInfo = true;
+
+    } else if (MachODWARFSection *m =
+                   StringSwitch<MachODWARFSection *>(isec->name)
+                       .Case(section_names::debugAddr, &dObj->addrSection)
+                       .Case(section_names::debugInfo, &dObj->infoSection)
+                       .Case(section_names::debugLine, &dObj->lineSection)
+                       .Default(nullptr)) {
+      m->Data = toStringRef(isec->data);
+      m->isec = isec;
+      hasDwarfInfo = true;
+      continue;
     }
   }
 
   if (hasDwarfInfo)
     return dObj;
   return nullptr;
 }
+
+static uint64_t resolver(uint64_t type, uint64_t offset, uint64_t s,
+                         uint64_t locData, int64_t addend) {
+  return s + addend;
+}
+
+llvm::Optional<RelocAddrEntry> DwarfObject::find(const llvm::DWARFSection &sec,
+                                                 uint64_t pos) const {
+  auto &msec = static_cast<const MachODWARFSection &>(sec);
+  if (!msec.isec)
+    return llvm::None;
+
+  const Reloc *found = nullptr;
+  for (const auto &reloc : msec.isec->relocs) {
+    if (reloc.offset == pos) {
+      found = &reloc;
+      break;
+    }
+  }
+  if (!found)
+    return llvm::None;
+
+  const Symbol *sym = found->referent.dyn_cast<Symbol *>();
+  if (!sym)
+    return llvm::None;
+
+  uint32_t secIndex = sym->symtabIndex;
+  uint64_t val = 0;
+  if (const auto *def = dyn_cast<Defined>(sym)) {
+    val = def->value;
+  }
+
+  object::DataRefImpl d;
+  d.p = found->addend;
+
+  return RelocAddrEntry{secIndex, object::RelocationRef(d, nullptr),
+                        val,      llvm::Optional<object::RelocationRef>(),
+                        0,        resolver};
+}

lld/MachO/InputFiles.cpp

isec->data = {isZeroFill(sec.flags) ? nullptr : buf + sec.offset,
                   static_cast<size_t>(sec.size)};
     if (sec.align >= 32)
       error("alignment " + std::to_string(sec.align) + " of section " +
             isec->name + " is too large");
     else
       isec->align = 1 << sec.align;
     isec->flags = sec.flags;
 
-    if (!(isDebugSection(isec->flags) &&
-          isec->segname == segment_names::dwarf)) {
-      subsections.push_back({{0, isec}});
-    } else {
-      // Instead of emitting DWARF sections, we emit STABS symbols to the
-      // object files that contain them. We filter them out early to avoid
-      // parsing their relocations unnecessarily. But we must still push an
-      // empty map to ensure the indices line up for the remaining sections.
-      subsections.push_back({});
+    if (isDebugSection(isec->flags) && isec->segname == segment_names::dwarf)
       debugSections.push_back(isec);
-    }
-  }
-}
 
 // Find the subsection corresponding to the greatest section offset that is <=
 // that of the given offset.
 //
 // offset: an offset relative to the start of the original InputSection (before
 // any subsection splitting has occurred). It will be updated to represent the
 // same location as an offset relative to the start of the containing
 // subsection.

lld/MachO/InputSection.h

 constexpr const char binding[] = "__binding";
 constexpr const char bitcodeBundle[] = "__bundle";
 constexpr const char cfString[] = "__cfstring";
 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 debugAddr[] = "__debug_addr";
 constexpr const char debugInfo[] = "__debug_info";
+constexpr const char debugLine[] = "__debug_line";
+constexpr const char debugLineStr[] = "__debug_line_str";
 constexpr const char debugStr[] = "__debug_str";
 constexpr const char ehFrame[] = "__eh_frame";
 constexpr const char export_[] = "__export";
 constexpr const char functionStarts[] = "__func_starts";
 constexpr const char got[] = "__got";
 constexpr const char header[] = "__mach_header";
 constexpr const char indirectSymbolTable[] = "__ind_sym_tab";
 constexpr const char const_[] = "__const";