[lld-macho][re-land] Support .subsections_via_symbols

Summary:
This diff restores and builds upon @pcc and @RuiU's initial work on
subsections.

The .subsections_via_symbols directive indicates we can split each
section along symbol boundaries, unless those symbols have been marked
with `.alt_entry`.

We exercise this functionality in our tests by using order files that
rearrange those symbols.

Depends on D79668.

Reviewers: ruiu, pcc, MaskRay, smeenai, alexshap, gkm, Ktwu, christylee

Reviewed By: smeenai

Subscribers: thakis, llvm-commits, pcc, ruiu

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D79926

Author: int3

lld/MachO/Driver.cpp

@@ -326,9 +326,14 @@ bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   createSyntheticSections();
 
   // Initialize InputSections.
-  for (InputFile *file : inputFiles)
-    for (InputSection *sec : file->sections)
-      inputSections.push_back(sec);
+  for (InputFile *file : inputFiles) {
+    for (SubsectionMap &map : file->subsections) {
+      for (auto &p : map) {
+        InputSection *isec = p.second;
+        inputSections.push_back(isec);
+      }
+    }
+  }
 
   // Write to an output file.
   writeResult();

lld/MachO/InputFiles.cpp

@@ -127,17 +127,13 @@ static const load_command *findCommand(const mach_header_64 *hdr,
   return nullptr;
 }
 
-std::vector<InputSection *>
-InputFile::parseSections(ArrayRef<section_64> sections) {
-  std::vector<InputSection *> ret;
-  ret.reserve(sections.size());
-
+void InputFile::parseSections(ArrayRef<section_64> sections) {
+  subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
   for (const section_64 &sec : sections) {
     InputSection *isec = make<InputSection>();
     isec->file = this;
-    isec->header = &sec;
     isec->name = StringRef(sec.sectname, strnlen(sec.sectname, 16));
     isec->segname = StringRef(sec.segname, strnlen(sec.segname, 16));
     isec->data = {buf + sec.offset, static_cast<size_t>(sec.size)};
@@ -147,96 +143,185 @@ InputFile::parseSections(ArrayRef<section_64> sections) {
     else
       isec->align = 1 << sec.align;
     isec->flags = sec.flags;
-    ret.push_back(isec);
+    subsections.push_back({{0, isec}});
   }
+}
 
-  return ret;
+// 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.
+static InputSection *findContainingSubsection(SubsectionMap &map,
+                                              uint32_t *offset) {
+  auto it = std::prev(map.upper_bound(*offset));
+  *offset -= it->first;
+  return it->second;
 }
 
 void InputFile::parseRelocations(const section_64 &sec,
-                                 std::vector<Reloc> &relocs) {
+                                 SubsectionMap &subsecMap) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<any_relocation_info> relInfos(
       reinterpret_cast<const any_relocation_info *>(buf + sec.reloff),
       sec.nreloc);
 
   for (const any_relocation_info &anyRel : relInfos) {
+    if (anyRel.r_word0 & R_SCATTERED)
+      fatal("TODO: Scattered relocations not supported");
+
+    auto rel = reinterpret_cast<const relocation_info &>(anyRel);
+    if (!rel.r_pcrel)
+      fatal("TODO: Only pcrel relocations are supported");
+
     Reloc r;
-    if (anyRel.r_word0 & R_SCATTERED) {
-      error("TODO: Scattered relocations not supported");
+    r.type = rel.r_type;
+    uint32_t secRelOffset = rel.r_address;
+    uint64_t rawAddend =
+        target->getImplicitAddend(buf + sec.offset + secRelOffset, r.type);
+
+    if (rel.r_extern) {
+      r.target = symbols[rel.r_symbolnum];
+      r.addend = rawAddend;
     } else {
-      auto rel = reinterpret_cast<const relocation_info &>(anyRel);
-      r.type = rel.r_type;
-      r.offset = rel.r_address;
-      r.addend = target->getImplicitAddend(buf + sec.offset + r.offset, r.type);
-      if (rel.r_extern) {
-        r.target = symbols[rel.r_symbolnum];
-      } else {
-        if (rel.r_symbolnum == 0 || rel.r_symbolnum > sections.size())
-          fatal("invalid section index in relocation for offset " +
-                std::to_string(r.offset) + " in section " + sec.sectname +
-                " of " + getName());
-        r.target = sections[rel.r_symbolnum - 1];
-      }
+      if (rel.r_symbolnum == 0 || rel.r_symbolnum > subsections.size())
+        fatal("invalid section index in relocation for offset " +
+              std::to_string(r.offset) + " in section " + sec.sectname +
+              " of " + getName());
+
+      SubsectionMap &targetSubsecMap = subsections[rel.r_symbolnum - 1];
+      const section_64 &targetSec = sectionHeaders[rel.r_symbolnum - 1];
+      // The implicit addend for pcrel section relocations is the pcrel offset
+      // in terms of the addresses in the input file. Here we adjust it so that
+      // it describes the offset from the start of the target section.
+      // TODO: Figure out what to do for non-pcrel section relocations.
+      // TODO: The offset of 4 is probably not right for ARM64, nor for
+      //       relocations with r_length != 2.
+      uint32_t targetOffset =
+          sec.addr + secRelOffset + 4 + rawAddend - targetSec.addr;
+      r.target = findContainingSubsection(targetSubsecMap, &targetOffset);
+      r.addend = targetOffset;
     }
-    relocs.push_back(r);
+
+    InputSection *subsec = findContainingSubsection(subsecMap, &secRelOffset);
+    r.offset = secRelOffset;
+    subsec->relocs.push_back(r);
+  }
+}
+
+void InputFile::parseSymbols(ArrayRef<nlist_64> nList, const char *strtab,
+                             bool subsectionsViaSymbols) {
+  // resize(), not reserve(), because we are going to create N_ALT_ENTRY symbols
+  // out-of-sequence.
+  symbols.resize(nList.size());
+  std::vector<size_t> altEntrySymIdxs;
+
+  auto createDefined = [&](const nlist_64 &sym, InputSection *isec,
+                           uint32_t value) -> Symbol * {
+    StringRef name = strtab + sym.n_strx;
+    if (sym.n_type & N_EXT)
+      // Global defined symbol
+      return symtab->addDefined(name, isec, value);
+    else
+      // Local defined symbol
+      return make<Defined>(name, isec, value);
+  };
+
+  for (size_t i = 0, n = nList.size(); i < n; ++i) {
+    const nlist_64 &sym = nList[i];
+
+    // Undefined symbol
+    if (!sym.n_sect) {
+      StringRef name = strtab + sym.n_strx;
+      symbols[i] = symtab->addUndefined(name);
+      continue;
+    }
+
+    const section_64 &sec = sectionHeaders[sym.n_sect - 1];
+    SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
+    uint64_t offset = sym.n_value - sec.addr;
+
+    // If the input file does not use subsections-via-symbols, all symbols can
+    // use the same subsection. Otherwise, we must split the sections along
+    // symbol boundaries.
+    if (!subsectionsViaSymbols) {
+      symbols[i] = createDefined(sym, subsecMap[0], offset);
+      continue;
+    }
+
+    // nList entries aren't necessarily arranged in address order. Therefore,
+    // we can't create alt-entry symbols at this point because a later symbol
+    // may split its section, which may affect which subsection the alt-entry
+    // symbol is assigned to. So we need to handle them in a second pass below.
+    if (sym.n_desc & N_ALT_ENTRY) {
+      altEntrySymIdxs.push_back(i);
+      continue;
+    }
+
+    // Find the subsection corresponding to the greatest section offset that is
+    // <= that of the current symbol. The subsection that we find either needs
+    // to be used directly or split in two.
+    uint32_t firstSize = offset;
+    InputSection *firstIsec = findContainingSubsection(subsecMap, &firstSize);
+
+    if (firstSize == 0) {
+      // Alias of an existing symbol, or the first symbol in the section. These
+      // are handled by reusing the existing section.
+      symbols[i] = createDefined(sym, firstIsec, 0);
+      continue;
+    }
+
+    // We saw a symbol definition at a new offset. Split the section into two
+    // subsections. The new symbol uses the second subsection.
+    auto *secondIsec = make<InputSection>(*firstIsec);
+    secondIsec->data = firstIsec->data.slice(firstSize);
+    firstIsec->data = firstIsec->data.slice(0, firstSize);
+    // TODO: ld64 appears to preserve the original alignment as well as each
+    // subsection's offset from the last aligned address. We should consider
+    // emulating that behavior.
+    secondIsec->align = MinAlign(firstIsec->align, offset);
+
+    subsecMap[offset] = secondIsec;
+    // By construction, the symbol will be at offset zero in the new section.
+    symbols[i] = createDefined(sym, secondIsec, 0);
+  }
+
+  for (size_t idx : altEntrySymIdxs) {
+    const nlist_64 &sym = nList[idx];
+    SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
+    uint32_t off = sym.n_value - sectionHeaders[sym.n_sect - 1].addr;
+    InputSection *subsec = findContainingSubsection(subsecMap, &off);
+    symbols[idx] = createDefined(sym, subsec, off);
   }
 }
 
 ObjFile::ObjFile(MemoryBufferRef mb) : InputFile(ObjKind, mb) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
-  ArrayRef<section_64> objSections;
 
   if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
     auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
-    objSections = ArrayRef<section_64>{
+    sectionHeaders = ArrayRef<section_64>{
         reinterpret_cast<const section_64 *>(c + 1), c->nsects};
-    sections = parseSections(objSections);
+    parseSections(sectionHeaders);
   }
 
   // TODO: Error on missing LC_SYMTAB?
   if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
     auto *c = reinterpret_cast<const symtab_command *>(cmd);
-    const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
-    ArrayRef<const nlist_64> nList(
+    ArrayRef<nlist_64> nList(
         reinterpret_cast<const nlist_64 *>(buf + c->symoff), c->nsyms);
-
-    symbols.reserve(c->nsyms);
-
-    for (const nlist_64 &sym : nList) {
-      StringRef name = strtab + sym.n_strx;
-
-      // Undefined symbol
-      if (!sym.n_sect) {
-        symbols.push_back(symtab->addUndefined(name));
-        continue;
-      }
-
-      InputSection *isec = sections[sym.n_sect - 1];
-      const section_64 &objSec = objSections[sym.n_sect - 1];
-      uint64_t value = sym.n_value - objSec.addr;
-
-      // Global defined symbol
-      if (sym.n_type & N_EXT) {
-        symbols.push_back(symtab->addDefined(name, isec, value));
-        continue;
-      }
-
-      // Local defined symbol
-      symbols.push_back(make<Defined>(name, isec, value));
-    }
+    const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
+    bool subsectionsViaSymbols = hdr->flags & MH_SUBSECTIONS_VIA_SYMBOLS;
+    parseSymbols(nList, strtab, subsectionsViaSymbols);
   }
 
   // The relocations may refer to the symbols, so we parse them after we have
-  // the symbols loaded.
-  if (!sections.empty()) {
-    auto it = sections.begin();
-    for (const section_64 &sec : objSections) {
-      parseRelocations(sec, (*it)->relocs);
-      ++it;
-    }
-  }
+  // parsed all the symbols.
+  for (size_t i = 0, n = subsections.size(); i < n; ++i)
+    parseRelocations(sectionHeaders[i], subsections[i]);
 }
 
 DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella)
@@ -324,7 +409,8 @@ void ArchiveFile::fetch(const object::Archive::Symbol &sym) {
                 sym.getName());
   auto file = make<ObjFile>(mb);
   symbols.insert(symbols.end(), file->symbols.begin(), file->symbols.end());
-  sections.insert(sections.end(), file->sections.begin(), file->sections.end());
+  subsections.insert(subsections.end(), file->subsections.begin(),
+                     file->subsections.end());
 }
 
 // Returns "<internal>" or "baz.o".

lld/MachO/InputFiles.h

@@ -14,6 +14,8 @@
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MemoryBuffer.h"
+
+#include <map>
 #include <vector>
 
 namespace lld {
@@ -23,6 +25,11 @@ class InputSection;
 class Symbol;
 struct Reloc;
 
+// If .subsections_via_symbols is set, each InputSection will be split along
+// symbol boundaries. The keys of a SubsectionMap represent the offsets of
+// each subsection from the start of the original pre-split InputSection.
+using SubsectionMap = std::map<uint32_t, InputSection *>;
+
 class InputFile {
 public:
   enum Kind {
@@ -37,15 +44,18 @@ class InputFile {
 
   MemoryBufferRef mb;
   std::vector<Symbol *> symbols;
-  std::vector<InputSection *> sections;
+  ArrayRef<llvm::MachO::section_64> sectionHeaders;
+  std::vector<SubsectionMap> subsections;
 
 protected:
   InputFile(Kind kind, MemoryBufferRef mb) : mb(mb), fileKind(kind) {}
 
-  std::vector<InputSection *> parseSections(ArrayRef<llvm::MachO::section_64>);
+  void parseSections(ArrayRef<llvm::MachO::section_64>);
+
+  void parseSymbols(ArrayRef<llvm::MachO::nlist_64> nList, const char *strtab,
+                    bool subsectionsViaSymbols);
 
-  void parseRelocations(const llvm::MachO::section_64 &,
-                        std::vector<Reloc> &relocs);
+  void parseRelocations(const llvm::MachO::section_64 &, SubsectionMap &);
 
 private:
   const Kind fileKind;

lld/MachO/InputSection.cpp

@@ -32,7 +32,6 @@ void InputSection::writeTo(uint8_t *buf) {
 
   for (Reloc &r : relocs) {
     uint64_t va = 0;
-    uint64_t addend = r.addend;
     if (auto *s = r.target.dyn_cast<Symbol *>()) {
       if (auto *dylibSymbol = dyn_cast<DylibSymbol>(s)) {
         va = target->getDylibSymbolVA(*dylibSymbol, r.type);
@@ -41,15 +40,9 @@ void InputSection::writeTo(uint8_t *buf) {
       }
     } else if (auto *isec = r.target.dyn_cast<InputSection *>()) {
       va = isec->getVA();
-      // The implicit addend for pcrel section relocations is the pcrel offset
-      // in terms of the addresses in the input file. Here we adjust it so that
-      // it describes the offset from the start of the target section.
-      // TODO: Figure out what to do for non-pcrel section relocations.
-      // TODO: The offset of 4 is probably not right for ARM64.
-      addend -= isec->header->addr - (header->addr + r.offset + 4);
     }
 
-    uint64_t val = va + addend;
+    uint64_t val = va + r.addend;
     if (1) // TODO: handle non-pcrel relocations
       val -= getVA() + r.offset;
     target->relocateOne(buf + r.offset, r.type, val);

lld/MachO/InputSection.h

@@ -24,7 +24,11 @@ class Symbol;
 
 struct Reloc {
   uint8_t type;
+  // Adding this offset to the address of the target symbol or subsection gives
+  // the destination that this relocation refers to.
   uint32_t addend;
+  // The offset from the start of the subsection that this relocation belongs
+  // to.
   uint32_t offset;
   llvm::PointerUnion<Symbol *, InputSection *> target;
 };
@@ -42,8 +46,6 @@ class InputSection {
   InputFile *file = nullptr;
   StringRef name;
   StringRef segname;
-  // This provides access to the address of the section in the input file.
-  const llvm::MachO::section_64 *header;
 
   OutputSection *parent = nullptr;
   uint64_t outSecOff = 0;