[lld-macho][nfc] Give every SyntheticSection a fake InputSection

Previously, it was difficult to write code that handled both synthetic
and regular sections generically. We solve this problem by creating a
fake InputSection at the start of every SyntheticSection.

This refactor allows us to handle DSOHandle like a regular Defined
symbol (since Defined symbols must be attached to an InputSection), and
paves the way for supporting `__mh_*header` symbols. Additionally, it
simplifies our binding/rebase code.

I did have to extend Defined a little -- it now has a `linkerInternal`
flag, to indicate that `___dso_handle` should not be in the final symbol
table.

I've also added some additional testing for `___dso_handle`.

Reviewed By: #lld-macho, oontvoo

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

Author: int3

lld/MachO/Driver.cpp

@@ -1031,7 +1031,14 @@ bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
     }
 
     createSyntheticSections();
-    symtab->addDSOHandle(in.header);
+
+    // The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit
+    // which does e.g. cleanup of static global variables. The ABI document says
+    // that the pointer can point to any address in one of the dylib's segments,
+    // but in practice ld64 seems to set it to point to the header, so that's
+    // what's implemented here.
+    symtab->addSynthetic("___dso_handle", in.header->isec, 0,
+                         /*privateExtern=*/true, /*linkerInternal=*/true);
 
     for (const Arg *arg : args.filtered(OPT_sectcreate)) {
       StringRef segName = arg->getValue(0);

lld/MachO/SymbolTable.cpp

@@ -37,9 +37,9 @@ std::pair<Symbol *, bool> SymbolTable::insert(StringRef name) {
   return {sym, true};
 }
 
-Symbol *SymbolTable::addDefined(StringRef name, InputFile *file,
-                                InputSection *isec, uint32_t value,
-                                bool isWeakDef, bool isPrivateExtern) {
+Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
+                                 InputSection *isec, uint32_t value,
+                                 bool isWeakDef, bool isPrivateExtern) {
   Symbol *s;
   bool wasInserted;
   bool overridesWeakDef = false;
@@ -52,7 +52,7 @@ Symbol *SymbolTable::addDefined(StringRef name, InputFile *file,
         // If one of them isn't private extern, the merged symbol isn't.
         if (defined->isWeakDef())
           defined->privateExtern &= isPrivateExtern;
-        return s;
+        return defined;
       }
       if (!defined->isWeakDef()) {
         error("duplicate symbol: " + name + "\n>>> defined in " +
@@ -70,7 +70,7 @@ Symbol *SymbolTable::addDefined(StringRef name, InputFile *file,
       replaceSymbol<Defined>(s, name, file, isec, value, isWeakDef,
                              /*isExternal=*/true, isPrivateExtern);
   defined->overridesWeakDef = overridesWeakDef;
-  return s;
+  return defined;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
@@ -158,18 +158,12 @@ Symbol *SymbolTable::addLazy(StringRef name, ArchiveFile *file,
   return s;
 }
 
-Symbol *SymbolTable::addDSOHandle(const MachHeaderSection *header) {
-  Symbol *s;
-  bool wasInserted;
-  std::tie(s, wasInserted) = insert(DSOHandle::name);
-  if (!wasInserted) {
-    // FIXME: Make every symbol (including absolute symbols) contain a
-    // reference to their originating file, then add that file name to this
-    // error message. dynamic_lookup symbols don't have an originating file.
-    if (isa<Defined>(s))
-      error("found defined symbol with illegal name " + DSOHandle::name);
-  }
-  replaceSymbol<DSOHandle>(s, header);
+Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
+                                   uint32_t value, bool isPrivateExtern,
+                                   bool isLinkerInternal) {
+  Defined *s = addDefined(name, nullptr, isec, value, /*isWeakDef=*/false,
+                          isPrivateExtern);
+  s->linkerInternal = isLinkerInternal;
   return s;
 }
 

lld/MachO/SymbolTable.h

@@ -24,6 +24,7 @@ class ObjFile;
 class InputSection;
 class MachHeaderSection;
 class Symbol;
+class Defined;
 class Undefined;
 
 /*
@@ -34,8 +35,8 @@ class Undefined;
  */
 class SymbolTable {
 public:
-  Symbol *addDefined(StringRef name, InputFile *, InputSection *,
-                     uint32_t value, bool isWeakDef, bool isPrivateExtern);
+  Defined *addDefined(StringRef name, InputFile *, InputSection *,
+                      uint32_t value, bool isWeakDef, bool isPrivateExtern);
 
   Symbol *addUndefined(StringRef name, InputFile *, bool isWeakRef);
 
@@ -48,7 +49,8 @@ class SymbolTable {
   Symbol *addLazy(StringRef name, ArchiveFile *file,
                   const llvm::object::Archive::Symbol &sym);
 
-  Symbol *addDSOHandle(const MachHeaderSection *);
+  Defined *addSynthetic(StringRef name, InputSection *, uint32_t value,
+                        bool isPrivateExtern, bool isLinkerInternal);
 
   ArrayRef<Symbol *> getSymbols() const { return symVector; }
   Symbol *find(StringRef name);

lld/MachO/Symbols.cpp

@@ -45,9 +45,3 @@ uint64_t Defined::getFileOffset() const {
 }
 
 void LazySymbol::fetchArchiveMember() { getFile()->fetch(sym); }
-
-uint64_t DSOHandle::getVA() const { return header->addr; }
-
-uint64_t DSOHandle::getFileOffset() const { return header->fileOff; }
-
-constexpr StringRef DSOHandle::name;

lld/MachO/Symbols.h

@@ -39,7 +39,6 @@ class Symbol {
     CommonKind,
     DylibKind,
     LazyKind,
-    DSOHandleKind,
   };
 
   virtual ~Symbol() {}
@@ -100,7 +99,7 @@ class Defined : public Symbol {
           bool isWeakDef, bool isExternal, bool isPrivateExtern)
       : Symbol(DefinedKind, name, file), isec(isec), value(value),
         overridesWeakDef(false), privateExtern(isPrivateExtern),
-        weakDef(isWeakDef), external(isExternal) {}
+        linkerInternal(false), weakDef(isWeakDef), external(isExternal) {}
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
@@ -123,7 +122,10 @@ class Defined : public Symbol {
   uint32_t value;
 
   bool overridesWeakDef : 1;
+  // Whether this symbol should appear in the output binary's export trie.
   bool privateExtern : 1;
+  // Whether this symbol should appear in the output binary's symbol table.
+  bool linkerInternal : 1;
 
 private:
   const bool weakDef : 1;
@@ -228,44 +230,12 @@ class LazySymbol : public Symbol {
   const llvm::object::Archive::Symbol sym;
 };
 
-// The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit which
-// does e.g. cleanup of static global variables. The ABI document says that the
-// pointer can point to any address in one of the dylib's segments, but in
-// practice ld64 seems to set it to point to the header, so that's what's
-// implemented here.
-//
-// The ARM C++ ABI uses __dso_handle similarly, but I (int3) have not yet
-// tested this on an ARM platform.
-//
-// DSOHandle effectively functions like a Defined symbol, but it doesn't belong
-// to an InputSection.
-class DSOHandle : public Symbol {
-public:
-  DSOHandle(const MachHeaderSection *header)
-      : Symbol(DSOHandleKind, name, nullptr), header(header) {}
-
-  const MachHeaderSection *header;
-
-  uint64_t getVA() const override;
-
-  uint64_t getFileOffset() const override;
-
-  bool isWeakDef() const override { return false; }
-
-  bool isTlv() const override { return false; }
-
-  static constexpr StringRef name = "___dso_handle";
-
-  static bool classof(const Symbol *s) { return s->kind() == DSOHandleKind; }
-};
-
 union SymbolUnion {
   alignas(Defined) char a[sizeof(Defined)];
   alignas(Undefined) char b[sizeof(Undefined)];
   alignas(CommonSymbol) char c[sizeof(CommonSymbol)];
   alignas(DylibSymbol) char d[sizeof(DylibSymbol)];
   alignas(LazySymbol) char e[sizeof(LazySymbol)];
-  alignas(DSOHandle) char f[sizeof(DSOHandle)];
 };
 
 template <typename T, typename... ArgT>

lld/MachO/SyntheticSections.cpp

@@ -42,6 +42,11 @@ std::vector<SyntheticSection *> macho::syntheticSections;
 
 SyntheticSection::SyntheticSection(const char *segname, const char *name)
     : OutputSection(SyntheticKind, name), segname(segname) {
+  isec = make<InputSection>();
+  isec->segname = segname;
+  isec->name = name;
+  isec->parent = this;
+  isec->outSecOff = 0;
   syntheticSections.push_back(this);
 }
 
@@ -118,12 +123,6 @@ void MachHeaderSection::writeTo(uint8_t *buf) const {
 PageZeroSection::PageZeroSection()
     : SyntheticSection(segment_names::pageZero, section_names::pageZero) {}
 
-uint64_t Location::getVA() const {
-  if (const auto *isec = section.dyn_cast<const InputSection *>())
-    return isec->getVA() + offset;
-  return section.get<const OutputSection *>()->addr + offset;
-}
-
 RebaseSection::RebaseSection()
     : LinkEditSection(segment_names::linkEdit, section_names::rebase) {}
 
@@ -186,16 +185,11 @@ void RebaseSection::finalizeContents() {
   os << static_cast<uint8_t>(REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER);
 
   llvm::sort(locations, [](const Location &a, const Location &b) {
-    return a.getVA() < b.getVA();
+    return a.isec->getVA() < b.isec->getVA();
   });
-  for (const Location &loc : locations) {
-    if (const auto *isec = loc.section.dyn_cast<const InputSection *>()) {
-      encodeRebase(isec->parent, isec->outSecOff + loc.offset, lastRebase, os);
-    } else {
-      const auto *osec = loc.section.get<const OutputSection *>();
-      encodeRebase(osec, loc.offset, lastRebase, os);
-    }
-  }
+  for (const Location &loc : locations)
+    encodeRebase(loc.isec->parent, loc.isec->outSecOff + loc.offset, lastRebase,
+                 os);
   if (lastRebase.consecutiveCount != 0)
     encodeDoRebase(lastRebase, os);
 
@@ -218,7 +212,7 @@ void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
     assert(!sym->isInGot());
     sym->gotIndex = entries.size() - 1;
 
-    addNonLazyBindingEntries(sym, this, sym->gotIndex * WordSize);
+    addNonLazyBindingEntries(sym, isec, sym->gotIndex * WordSize);
   }
 }
 
@@ -336,14 +330,9 @@ void BindingSection::finalizeContents() {
       encodeDylibOrdinal(ordinal, os);
       lastBinding.ordinal = ordinal;
     }
-    if (auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
-      encodeBinding(b.dysym, isec->parent, isec->outSecOff + b.target.offset,
-                    b.addend, /*isWeakBinding=*/false, lastBinding, os);
-    } else {
-      auto *osec = b.target.section.get<const OutputSection *>();
-      encodeBinding(b.dysym, osec, b.target.offset, b.addend,
-                    /*isWeakBinding=*/false, lastBinding, os);
-    }
+    encodeBinding(b.dysym, b.target.isec->parent,
+                  b.target.isec->outSecOff + b.target.offset, b.addend,
+                  /*isWeakBinding=*/false, lastBinding, os);
   }
   if (!bindings.empty())
     os << static_cast<uint8_t>(BIND_OPCODE_DONE);
@@ -369,16 +358,10 @@ void WeakBindingSection::finalizeContents() {
              [](const WeakBindingEntry &a, const WeakBindingEntry &b) {
                return a.target.getVA() < b.target.getVA();
              });
-  for (const WeakBindingEntry &b : bindings) {
-    if (const auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
-      encodeBinding(b.symbol, isec->parent, isec->outSecOff + b.target.offset,
-                    b.addend, /*isWeakBinding=*/true, lastBinding, os);
-    } else {
-      const auto *osec = b.target.section.get<const OutputSection *>();
-      encodeBinding(b.symbol, osec, b.target.offset, b.addend,
-                    /*isWeakBinding=*/true, lastBinding, os);
-    }
-  }
+  for (const WeakBindingEntry &b : bindings)
+    encodeBinding(b.symbol, b.target.isec->parent,
+                  b.target.isec->outSecOff + b.target.offset, b.addend,
+                  /*isWeakBinding=*/true, lastBinding, os);
   if (!bindings.empty() || !definitions.empty())
     os << static_cast<uint8_t>(BIND_OPCODE_DONE);
 }
@@ -396,23 +379,21 @@ bool macho::needsBinding(const Symbol *sym) {
 }
 
 void macho::addNonLazyBindingEntries(const Symbol *sym,
-                                     SectionPointerUnion section,
-                                     uint64_t offset, int64_t addend) {
+                                     const InputSection *isec, uint64_t offset,
+                                     int64_t addend) {
   if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
-    in.binding->addEntry(dysym, section, offset, addend);
+    in.binding->addEntry(dysym, isec, offset, addend);
     if (dysym->isWeakDef())
-      in.weakBinding->addEntry(sym, section, offset, addend);
+      in.weakBinding->addEntry(sym, isec, offset, addend);
   } else if (auto *defined = dyn_cast<Defined>(sym)) {
-    in.rebase->addEntry(section, offset);
+    in.rebase->addEntry(isec, offset);
     if (defined->isExternalWeakDef())
-      in.weakBinding->addEntry(sym, section, offset, addend);
-  } else if (!isa<DSOHandle>(sym)) {
+      in.weakBinding->addEntry(sym, isec, offset, addend);
+  } else {
     // Undefined symbols are filtered out in scanRelocations(); we should never
     // get here
     llvm_unreachable("cannot bind to an undefined symbol");
   }
-  // TODO: understand the DSOHandle case better.
-  // Is it bindable?  Add a new test?
 }
 
 StubsSection::StubsSection()
@@ -538,7 +519,7 @@ void LazyBindingSection::writeTo(uint8_t *buf) const {
 void LazyBindingSection::addEntry(DylibSymbol *dysym) {
   if (entries.insert(dysym)) {
     dysym->stubsHelperIndex = entries.size() - 1;
-    in.rebase->addEntry(in.lazyPointers, dysym->stubsIndex * WordSize);
+    in.rebase->addEntry(in.lazyPointers->isec, dysym->stubsIndex * WordSize);
   }
 }
 
@@ -572,9 +553,9 @@ void macho::prepareBranchTarget(Symbol *sym) {
   if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     if (in.stubs->addEntry(dysym)) {
       if (sym->isWeakDef()) {
-        in.binding->addEntry(dysym, in.lazyPointers,
+        in.binding->addEntry(dysym, in.lazyPointers->isec,
                              sym->stubsIndex * WordSize);
-        in.weakBinding->addEntry(sym, in.lazyPointers,
+        in.weakBinding->addEntry(sym, in.lazyPointers->isec,
                                  sym->stubsIndex * WordSize);
       } else {
         in.lazyBinding->addEntry(dysym);
@@ -583,8 +564,8 @@ void macho::prepareBranchTarget(Symbol *sym) {
   } else if (auto *defined = dyn_cast<Defined>(sym)) {
     if (defined->isExternalWeakDef()) {
       if (in.stubs->addEntry(sym)) {
-        in.rebase->addEntry(in.lazyPointers, sym->stubsIndex * WordSize);
-        in.weakBinding->addEntry(sym, in.lazyPointers,
+        in.rebase->addEntry(in.lazyPointers->isec, sym->stubsIndex * WordSize);
+        in.weakBinding->addEntry(sym, in.lazyPointers->isec,
                                  sym->stubsIndex * WordSize);
       }
     }
@@ -786,9 +767,10 @@ void SymtabSection::finalizeContents() {
 
   for (Symbol *sym : symtab->getSymbols()) {
     if (auto *defined = dyn_cast<Defined>(sym)) {
+      if (defined->linkerInternal)
+        continue;
       assert(defined->isExternal());
-      (void)defined;
-      addSymbol(externalSymbols, sym);
+      addSymbol(externalSymbols, defined);
     } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       if (dysym->isReferenced())
         addSymbol(undefinedSymbols, sym);