[lld-macho] Implement weak bindings for GOT/TLV

[int3]

Summary

Previously, we were only emitting regular bindings to weak
dynamic symbols; this diff adds support for the weak bindings too, which
can overwrite the regular bindings at runtime. We also treat weak
defined global symbols similarly -- since they can also be interposed at
runtime, they need to be treated as potentially dynamic symbols.

Note that weak bindings differ from regular bindings in that they do not
specify the dylib to do the lookup in (i.e. weak symbol lookup happens
in a flat namespace.)

[smeenai]

LGTM

lld/MachO/Symbols.h

78

How much more work would it be to have this not have a default value, and instead set it explicitly for each constructor call? I'd like to explicit with this if it's not too onerous.

86

The terminology used by Mach-O for this appears to be external/non-external, vs. global/local (as ELF does it). I'd prefer using that terminology in the linker as well.

lld/MachO/SyntheticSections.cpp

224

Nit: put this in the header?

lld/MachO/SyntheticSections.h

217

Typo: neeed -> need

lld/test/MachO/weak-binding.s

83

Mind adding a test for a weak local TLV symbol as well?

[int3]

address comments

[int3]

update

lld/MachO/Arch/X86_64.cpp

writeRipRelative(buf, entryAddr, sizeof(stubHelperEntry),
                    in.stubHelper->addr);
 }
 
 void X86_64::prepareSymbolRelocation(lld::macho::Symbol *sym,
                                      const InputSection *isec, const Reloc &r) {
   switch (r.type) {
   case X86_64_RELOC_GOT_LOAD:
     // TODO: implement mov -> lea relaxation for non-dynamic symbols
-  case X86_64_RELOC_GOT:
+  case X86_64_RELOC_GOT: {
     in.got->addEntry(sym);
+
     if (sym->isTlv())
       error("found GOT relocation referencing thread-local variable in " +
             toString(isec));
     break;
+  }
   case X86_64_RELOC_BRANCH: {
     // TODO: weak dysyms should go into the weak binding section instead
     if (auto *dysym = dyn_cast<DylibSymbol>(sym))
       in.stubs->addEntry(dysym);
     break;
   }
   case X86_64_RELOC_UNSIGNED: {
     if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       if (r.length != 3) {
         error("X86_64_RELOC_UNSIGNED referencing the dynamic symbol " +
               dysym->getName() + " must have r_length = 3");
         return;
       }
-      in.binding->addEntry(dysym, isec, r.offset, r.addend);
     }
+    addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
     break;
   }
   case X86_64_RELOC_SIGNED:
   case X86_64_RELOC_SIGNED_1:
   case X86_64_RELOC_SIGNED_2:
   case X86_64_RELOC_SIGNED_4:
+    // TODO: warn if they refer to a weak global
     break;
-  case X86_64_RELOC_TLV:
-    if (isa<DylibSymbol>(sym)) {
+  case X86_64_RELOC_TLV: {
+    if (sym->isWeakDef() || isa<DylibSymbol>(sym))
       in.tlvPointers->addEntry(sym);
-    } else {
-      assert(isa<Defined>(sym));
-      // TLV relocations on x86_64 are always used with a movq opcode, which
-      // can be converted to leaq opcodes if they reference a defined symbol.
-      // (This is in contrast to GOT relocations, which can be used with
-      // non-movq opcodes.) As such, there is no need to add an entry to
-      // tlvPointers here.
-    }
+
     if (!sym->isTlv())
       error(
           "found X86_64_RELOC_TLV referencing a non-thread-local variable in " +
           toString(isec));
     break;
+  }
   case X86_64_RELOC_SUBTRACTOR:
     fatal("TODO: handle relocation type " + std::to_string(r.type));
     break;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
case X86_64_RELOC_BRANCH:
     return sym.getVA();
   case X86_64_RELOC_UNSIGNED:
   case X86_64_RELOC_SIGNED:
   case X86_64_RELOC_SIGNED_1:
   case X86_64_RELOC_SIGNED_2:
   case X86_64_RELOC_SIGNED_4:
     return sym.getVA();
   case X86_64_RELOC_TLV: {
-    if (isa<DylibSymbol>(&sym))
+    if (sym.isInGot())
       return in.tlvPointers->addr + sym.gotIndex * WordSize;
 
     // Convert the movq to a leaq.
     assert(isa<Defined>(&sym));
     if (buf[-2] != 0x8b)
       error("X86_64_RELOC_TLV must be used with movq instructions");
     buf[-2] = 0x8d;
     return sym.getVA();

lld/MachO/InputFiles.cpp

void InputFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
 
   auto createDefined = [&](const structs::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, sym.n_desc & N_WEAK_DEF);
     // Local defined symbol
-    return make<Defined>(name, isec, value, sym.n_desc & N_WEAK_DEF);
+    return make<Defined>(name, isec, value, sym.n_desc & N_WEAK_DEF,
+                         /*isExternal=*/false);
   };
 
   for (size_t i = 0, n = nList.size(); i < n; ++i) {
     const structs::nlist_64 &sym = nList[i];
 
     // Undefined symbol
     if (!sym.n_sect) {
       StringRef name = strtab + sym.n_strx;

lld/MachO/SymbolTable.cpp

if (auto *defined = dyn_cast<Defined>(s)) {
         return s;
       if (!defined->isWeakDef())
         error("duplicate symbol: " + name);
     }
     // Defined symbols take priority over other types of symbols, so in case
     // of a name conflict, we fall through to the replaceSymbol() call below.
   }
 
-  replaceSymbol<Defined>(s, name, isec, value, isWeakDef);
+  replaceSymbol<Defined>(s, name, isec, value, isWeakDef, /*isExternal=*/true);
   return s;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef name) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
 

lld/MachO/Symbols.h

public:
   virtual uint64_t getFileOffset() const {
     llvm_unreachable("attempt to get an offset from a non-defined symbol");
   }
 
   virtual bool isWeakDef() const { llvm_unreachable("cannot be weak"); }
 
   virtual bool isTlv() const { llvm_unreachable("cannot be TLV"); }
 
+  // Whether this symbol is in the GOT or TLVPointer sections.
+  bool isInGot() const { return gotIndex != UINT32_MAX; }
+
   // The index of this symbol in the GOT or the TLVPointer section, depending
   // on whether it is a thread-local. A given symbol cannot be referenced by
   // both these sections at once.
   uint32_t gotIndex = UINT32_MAX;
 
 protected:
   Symbol(Kind k, StringRefZ name) : symbolKind(k), name(name) {}
 
   Kind symbolKind;
   StringRefZ name;
 };
 
 class Defined : public Symbol {
 public:
-  Defined(StringRefZ name, InputSection *isec, uint32_t value, bool isWeakDef)
-      : Symbol(DefinedKind, name), isec(isec), value(value),
-        weakDef(isWeakDef) {}
+  Defined(StringRefZ name, InputSection *isec, uint32_t value, bool isWeakDef,
+          bool isExternal)
+      : Symbol(DefinedKind, name), isec(isec), value(value), weakDef(isWeakDef),
+        external(isExternal) {}
 
   bool isWeakDef() const override { return weakDef; }
 
   bool isTlv() const override { return isThreadLocalVariables(isec->flags); }
 
+  bool isExternal() const { return external; }
+
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 
   uint64_t getVA() const override { return isec->getVA() + value; }
 
   uint64_t getFileOffset() const override {
     return isec->getFileOffset() + value;
   }
 
   InputSection *isec;
   uint32_t value;
 
 private:
   const bool weakDef;
+  const bool external;
 };
 
 class Undefined : public Symbol {
 public:
   Undefined(StringRefZ name) : Symbol(UndefinedKind, name) {}
 
   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
 };

lld/MachO/SyntheticSections.h

 namespace lld {
 namespace macho {
 
 namespace section_names {
 
 constexpr const char pageZero[] = "__pagezero";
 constexpr const char header[] = "__mach_header";
 constexpr const char binding[] = "__binding";
+constexpr const char weakBinding[] = "__weak_binding";
 constexpr const char lazyBinding[] = "__lazy_binding";
 constexpr const char export_[] = "__export";
 constexpr const char symbolTable[] = "__symbol_table";
 constexpr const char stringTable[] = "__string_table";
 constexpr const char got[] = "__got";
 constexpr const char threadPtrs[] = "__thread_ptrs";
 
 } // namespace section_names
public:
   TlvPointerSection()
       : NonLazyPointerSectionBase(segment_names::data,
                                   section_names::threadPtrs) {}
 };
 
 using SectionPointerUnion =
     llvm::PointerUnion<const InputSection *, const OutputSection *>;
 
-struct BindingEntry {
-  const DylibSymbol *dysym;
+struct BindingTarget {
   SectionPointerUnion section;
   uint64_t offset;
   int64_t addend;
 
-  BindingEntry(const DylibSymbol *dysym, SectionPointerUnion section,
-               uint64_t offset, int64_t addend)
-      : dysym(dysym), section(section), offset(offset), addend(addend) {}
+  BindingTarget(SectionPointerUnion section, uint64_t offset, int64_t addend)
+      : section(section), offset(offset), addend(addend) {}
 
   uint64_t getVA() const;
 };
 
+struct BindingEntry {
+  const DylibSymbol *dysym;
+  BindingTarget target;
+  BindingEntry(const DylibSymbol *dysym, BindingTarget target)
+      : dysym(dysym), target(std::move(target)) {}
+};
+
 // Stores bind opcodes for telling dyld which symbols to load non-lazily.
 class BindingSection : public LinkEditSection {
 public:
   BindingSection();
   void finalizeContents();
   uint64_t getRawSize() const override { return contents.size(); }
   // Like other sections in __LINKEDIT, the binding section is special: its
   // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
   // section headers.
   bool isHidden() const override { return true; }
   bool isNeeded() const override { return !bindings.empty(); }
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(const DylibSymbol *dysym, SectionPointerUnion section,
                 uint64_t offset, int64_t addend = 0) {
-    bindings.emplace_back(dysym, section, offset, addend);
+    bindings.emplace_back(dysym, BindingTarget(section, offset, addend));
   }
 
 private:
   std::vector<BindingEntry> bindings;
   SmallVector<char, 128> contents;
 };
 
+struct WeakBindingEntry {
+  const Symbol *symbol;
+  BindingTarget target;
+  WeakBindingEntry(const Symbol *symbol, BindingTarget target)
+      : symbol(symbol), target(std::move(target)) {}
+};
+
+// Stores bind opcodes for telling dyld which weak symbols to load. Note that
+// the bind opcodes will only refer to these symbols by name, but will not
+// specify which dylib to load them from.
+class WeakBindingSection : public LinkEditSection {
+public:
+  WeakBindingSection();
+  void finalizeContents();
+  uint64_t getRawSize() const override { return contents.size(); }
+  // Like other sections in __LINKEDIT, the binding section is special: its
+  // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
+  // section headers.
+  bool isHidden() const override { return true; }
+  bool isNeeded() const override { return !bindings.empty(); }
+
+  void writeTo(uint8_t *buf) const override;
+
+  void addEntry(const Symbol *symbol, SectionPointerUnion section,
+                uint64_t offset, int64_t addend = 0) {
+    bindings.emplace_back(symbol, BindingTarget(section, offset, addend));
+  }
+
+private:
+  std::vector<WeakBindingEntry> bindings;
+  SmallVector<char, 128> contents;
+};
+
+// Add bindings for symbols that need weak or non-lazy bindings.
+void addNonLazyBindingEntries(const Symbol *, SectionPointerUnion,
+                              uint64_t offset, int64_t addend = 0);
+
 // The following sections implement lazy symbol binding -- very similar to the
 // PLT mechanism in ELF.
 //
 // ELF's .plt section is broken up into two sections in Mach-O: StubsSection and
 // StubHelperSection. Calls to functions in dylibs will end up calling into
 // StubsSection, which contains indirect jumps to addresses stored in the
 // LazyPointerSection (the counterpart to ELF's .plt.got).
 //

 private:
   StringTableSection &stringTableSection;
   std::vector<SymtabEntry> symbols;
 };
 
 struct InStruct {
   MachHeaderSection *header = nullptr;
   BindingSection *binding = nullptr;
+  WeakBindingSection *weakBinding = nullptr;
   GotSection *got = nullptr;
   TlvPointerSection *tlvPointers = nullptr;
   LazyPointerSection *lazyPointers = nullptr;
   StubsSection *stubs = nullptr;
   StubHelperSection *stubHelper = nullptr;
   ImageLoaderCacheSection *imageLoaderCache = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SyntheticSections.cpp

NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
                                                      const char *name)
     : SyntheticSection(segname, name) {
   align = 8;
   flags = MachO::S_NON_LAZY_SYMBOL_POINTERS;
 }
 
 void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
   if (entries.insert(sym)) {
-    assert(sym->gotIndex == UINT32_MAX);
+    assert(!sym->isInGot());
     sym->gotIndex = entries.size() - 1;
 
-    if (auto *dysym = dyn_cast<DylibSymbol>(sym))
-      in.binding->addEntry(dysym, this, sym->gotIndex * WordSize);
+    addNonLazyBindingEntries(sym, this, sym->gotIndex * WordSize);
   }
 }
 
 void NonLazyPointerSectionBase::writeTo(uint8_t *buf) const {
   for (size_t i = 0, n = entries.size(); i < n; ++i)
     if (auto *defined = dyn_cast<Defined>(entries[i]))
       write64le(&buf[i * WordSize], defined->getVA());
 }
 
 BindingSection::BindingSection()
     : LinkEditSection(segment_names::linkEdit, section_names::binding) {}
 
 namespace {
 struct Binding {
   OutputSegment *segment = nullptr;
   uint64_t offset = 0;
   int64_t addend = 0;
   uint8_t ordinal = 0;
 };
 } // namespace
 
-// Encode a sequence of opcodes that tell dyld to write the address of dysym +
+// Encode a sequence of opcodes that tell dyld to write the address of symbol +
 // addend at osec->addr + outSecOff.
 //
 // The bind opcode "interpreter" remembers the values of each binding field, so
 // we only need to encode the differences between bindings. Hence the use of
 // lastBinding.
-static void encodeBinding(const DylibSymbol *dysym, const OutputSection *osec,
+static void encodeBinding(const Symbol *sym, const OutputSection *osec,
                           uint64_t outSecOff, int64_t addend,
                           Binding &lastBinding, raw_svector_ostream &os) {
   using namespace llvm::MachO;
   OutputSegment *seg = osec->parent;
   uint64_t offset = osec->getSegmentOffset() + outSecOff;
   if (lastBinding.segment != seg) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                                seg->index);
     encodeULEB128(offset, os);
     lastBinding.segment = seg;
     lastBinding.offset = offset;
   } else if (lastBinding.offset != offset) {
     os << static_cast<uint8_t>(BIND_OPCODE_ADD_ADDR_ULEB);
     encodeULEB128(offset - lastBinding.offset, os);
     lastBinding.offset = offset;
   }
 
-  if (lastBinding.ordinal != dysym->file->ordinal) {
-    if (dysym->file->ordinal <= BIND_IMMEDIATE_MASK) {
-      os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM |
-                                 dysym->file->ordinal);
-    } else {
-      os << static_cast<uint8_t>(MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
-      encodeULEB128(dysym->file->ordinal, os);
-    }
-    lastBinding.ordinal = dysym->file->ordinal;
-  }
-
   if (lastBinding.addend != addend) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_ADDEND_SLEB);
     encodeSLEB128(addend, os);
     lastBinding.addend = addend;
   }
 
   os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
-     << dysym->getName() << '\0'
+     << sym->getName() << '\0'
      << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER)
      << static_cast<uint8_t>(BIND_OPCODE_DO_BIND);
   // DO_BIND causes dyld to both perform the binding and increment the offset
   lastBinding.offset += WordSize;
 }
 
-uint64_t BindingEntry::getVA() const {
+// Non-weak bindings need to have their dylib ordinal encoded as well.
+static void encodeDylibOrdinal(const DylibSymbol *dysym, Binding &lastBinding,
+                               raw_svector_ostream &os) {
+  using namespace llvm::MachO;
+  if (lastBinding.ordinal != dysym->file->ordinal) {
+    if (dysym->file->ordinal <= BIND_IMMEDIATE_MASK) {
+      os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM |
+                                 dysym->file->ordinal);
+    } else {
+      os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
+      encodeULEB128(dysym->file->ordinal, os);
+    }
+    lastBinding.ordinal = dysym->file->ordinal;
+  }
+}
+
+uint64_t BindingTarget::getVA() const {
   if (auto *isec = section.dyn_cast<const InputSection *>())
     return isec->getVA() + offset;
-  auto *osec = section.get<const OutputSection *>();
-  return osec->addr + offset;
+  return section.get<const OutputSection *>()->addr + offset;
 }
 
 // Emit bind opcodes, which are a stream of byte-sized opcodes that dyld
 // interprets to update a record with the following fields:
 //  * segment index (of the segment to write the symbol addresses to, typically
 //    the __DATA_CONST segment which contains the GOT)
 //  * offset within the segment, indicating the next location to write a binding
 //  * symbol type
 //  * symbol library ordinal (the index of its library's LC_LOAD_DYLIB command)
 //  * symbol name
 //  * addend
 // When dyld sees BIND_OPCODE_DO_BIND, it uses the current record state to bind
 // a symbol in the GOT, and increments the segment offset to point to the next
 // entry. It does *not* clear the record state after doing the bind, so
 // subsequent opcodes only need to encode the differences between bindings.
 void BindingSection::finalizeContents() {
   raw_svector_ostream os{contents};
   Binding lastBinding;
 
   // Since bindings are delta-encoded, sorting them allows for a more compact
   // result. Note that sorting by address alone ensures that bindings for the
   // same segment / section are located together.
   llvm::sort(bindings, [](const BindingEntry &a, const BindingEntry &b) {
-    return a.getVA() < b.getVA();
+    return a.target.getVA() < b.target.getVA();
   });
   for (const BindingEntry &b : bindings) {
-    if (auto *isec = b.section.dyn_cast<const InputSection *>()) {
-      encodeBinding(b.dysym, isec->parent, isec->outSecOff + b.offset, b.addend,
-                    lastBinding, os);
+    encodeDylibOrdinal(b.dysym, lastBinding, os);
+    if (auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
+      encodeBinding(b.dysym, isec->parent, isec->outSecOff + b.target.offset,
+                    b.target.addend, lastBinding, os);
     } else {
-      auto *osec = b.section.get<const OutputSection *>();
-      encodeBinding(b.dysym, osec, b.offset, b.addend, lastBinding, os);
+      auto *osec = b.target.section.get<const OutputSection *>();
+      encodeBinding(b.dysym, osec, b.target.offset, b.target.addend,
+                    lastBinding, os);
     }
   }
   if (!bindings.empty())
     os << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
 }
 
 void BindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
+WeakBindingSection::WeakBindingSection()
+    : LinkEditSection(segment_names::linkEdit, section_names::weakBinding) {}
+
+void WeakBindingSection::finalizeContents() {
+  raw_svector_ostream os{contents};
+  Binding lastBinding;
+
+  // Since bindings are delta-encoded, sorting them allows for a more compact
+  // result.
+  llvm::sort(bindings,
+             [](const WeakBindingEntry &a, const WeakBindingEntry &b) {
+               return a.target.getVA() < b.target.getVA();
+             });
+  for (const WeakBindingEntry &b : bindings) {
+    if (auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
+      encodeBinding(b.symbol, isec->parent, isec->outSecOff + b.target.offset,
+                    b.target.addend, lastBinding, os);
+    } else {
+      auto *osec = b.target.section.get<const OutputSection *>();
+      encodeBinding(b.symbol, osec, b.target.offset, b.target.addend,
+                    lastBinding, os);
+    }
+  }
+  if (!bindings.empty())
+    os << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
+}
+
+void WeakBindingSection::writeTo(uint8_t *buf) const {
+  memcpy(buf, contents.data(), contents.size());
+}
+
+void macho::addNonLazyBindingEntries(const Symbol *sym,
+                                     SectionPointerUnion section,
+                                     uint64_t offset, int64_t addend) {
+  if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
+    in.binding->addEntry(dysym, section, offset, addend);
+    if (dysym->isWeakDef())
+      in.weakBinding->addEntry(sym, section, offset, addend);
+  } else if (auto *defined = dyn_cast<Defined>(sym)) {
+    if (defined->isWeakDef() && defined->isExternal())
+      in.weakBinding->addEntry(sym, section, offset, addend);
+  } else if (isa<DSOHandle>(sym)) {
+    error("cannot bind to " + DSOHandle::name);
+  } else {
+    // Undefined symbols are filtered out in scanRelocations(); we should never
+    // get here
+    llvm_unreachable("cannot bind to an undefined symbol");
+  }
+}
+
 StubsSection::StubsSection()
     : SyntheticSection(segment_names::text, "__stubs") {}
 
 uint64_t StubsSection::getSize() const {
   return entries.size() * target->stubSize;
 }
 
 void StubsSection::writeTo(uint8_t *buf) const {

lld/MachO/Writer.cpp

public:
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
 class LCDyldInfo : public LoadCommand {
 public:
   LCDyldInfo(BindingSection *bindingSection,
+             WeakBindingSection *weakBindingSection,
              LazyBindingSection *lazyBindingSection,
              ExportSection *exportSection)
-      : bindingSection(bindingSection), lazyBindingSection(lazyBindingSection),
-        exportSection(exportSection) {}
+      : bindingSection(bindingSection), weakBindingSection(weakBindingSection),
+        lazyBindingSection(lazyBindingSection), exportSection(exportSection) {}
 
   uint32_t getSize() const override { return sizeof(dyld_info_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dyld_info_command *>(buf);
     c->cmd = LC_DYLD_INFO_ONLY;
     c->cmdsize = getSize();
     if (bindingSection->isNeeded()) {
       c->bind_off = bindingSection->fileOff;
       c->bind_size = bindingSection->getFileSize();
     }
+    if (weakBindingSection->isNeeded()) {
+      c->weak_bind_off = weakBindingSection->fileOff;
+      c->weak_bind_size = weakBindingSection->getFileSize();
+    }
     if (lazyBindingSection->isNeeded()) {
       c->lazy_bind_off = lazyBindingSection->fileOff;
       c->lazy_bind_size = lazyBindingSection->getFileSize();
     }
     if (exportSection->isNeeded()) {
       c->export_off = exportSection->fileOff;
       c->export_size = exportSection->getFileSize();
     }
   }
 
   BindingSection *bindingSection;
+  WeakBindingSection *weakBindingSection;
   LazyBindingSection *lazyBindingSection;
   ExportSection *exportSection;
 };
 
 class LCDysymtab : public LoadCommand {
 public:
   uint32_t getSize() const override { return sizeof(dysymtab_command); }
 
for (Reloc &r : isec->relocs) {
         else
           target->prepareSymbolRelocation(s, isec, r);
       }
     }
   }
 }
 
 void Writer::createLoadCommands() {
-  in.header->addLoadCommand(
-      make<LCDyldInfo>(in.binding, lazyBindingSection, exportSection));
+  in.header->addLoadCommand(make<LCDyldInfo>(
+      in.binding, in.weakBinding, lazyBindingSection, exportSection));
   in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
   in.header->addLoadCommand(make<LCDysymtab>());
   for (StringRef path : config->runtimePaths)
     in.header->addLoadCommand(make<LCRPath>(path));
 
   switch (config->outputType) {
   case MH_EXECUTE:
     in.header->addLoadCommand(make<LCMain>());

 static int sectionOrder(OutputSection *osec) {
   StringRef segname = osec->parent->name;
   // Sections are uniquely identified by their segment + section name.
   if (segname == segment_names::text) {
     if (osec->name == section_names::header)
       return -1;
   } else if (segname == segment_names::linkEdit) {
     return StringSwitch<int>(osec->name)
-        .Case(section_names::binding, -5)
+        .Case(section_names::binding, -6)
+        .Case(section_names::weakBinding, -5)
         .Case(section_names::lazyBinding, -4)
         .Case(section_names::export_, -3)
         .Case(section_names::symbolTable, -2)
         .Case(section_names::stringTable, -1)
         .Default(0);
   }
   // ZeroFill sections must always be the at the end of their segments,
   // otherwise subsequent sections may get overwritten with zeroes at runtime.
void Writer::run() {
   // determine addresses of other segments/sections before generating its
   // contents.
   for (OutputSegment *seg : outputSegments)
     if (seg != linkEditSegment)
       assignAddresses(seg);
 
   // Fill __LINKEDIT contents.
   in.binding->finalizeContents();
+  in.weakBinding->finalizeContents();
   lazyBindingSection->finalizeContents();
   exportSection->finalizeContents();
   symtabSection->finalizeContents();
 
   // Now that __LINKEDIT is filled out, do a proper calculation of its
   // addresses and offsets.
   assignAddresses(linkEditSegment);
 
   openFile();
   if (errorCount())
     return;
 
   writeSections();
 
   if (auto e = buffer->commit())
     error("failed to write to the output file: " + toString(std::move(e)));
 }
 
 void macho::writeResult() { Writer().run(); }
 
 void macho::createSyntheticSections() {
   in.header = make<MachHeaderSection>();
   in.binding = make<BindingSection>();
+  in.weakBinding = make<WeakBindingSection>();
   in.got = make<GotSection>();
   in.tlvPointers = make<TlvPointerSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.imageLoaderCache = make<ImageLoaderCacheSection>();
 }

lld/test/MachO/weak-binding.s

+# REQUIRES: x86
+# RUN: split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
+# RUN: lld -flavor darwinnew -syslibroot %S/Inputs/MacOSX.sdk -dylib %t/libfoo.o -o %t/libfoo.dylib
+# RUN: lld -flavor darwinnew -syslibroot %S/Inputs/MacOSX.sdk %t/test.o -L%t -lfoo -o %t/test -lSystem
+# RUN: llvm-objdump -d --no-show-raw-insn --bind --weak-bind --full-contents %t/test | \
+# RUN:   FileCheck %s
+
+# CHECK:      Contents of section __got:
+## Check that this section contains a nonzero pointer. It should point to
+## _weak_external_for_gotpcrel, but we don't have a good way of testing the exact
+## value as the bytes here are in little-endian order.
+# CHECK-NEXT: {{[0-9a-f]+}} {{[0-9a-f ]*[1-9a-f]+[0-9a-f ]*}}
+
+# CHECK:      <_main>:
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_DY_GOT_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_EXT_GOT_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_TLV_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_DY_TLV_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  # [[#%X,WEAK_INT_TLV_ADDR:]]
+
+# CHECK-LABEL: Bind table:
+# CHECK-DAG:   __DATA        __data        0x[[#%x,WEAK_DY:]]      pointer 0 libfoo    _weak_dysym
+# CHECK-DAG:   __DATA        __thread_vars 0x{{[0-9a-f]*}}         pointer 0 libSystem __tlv_bootstrap
+# CHECK-DAG:   __DATA        __thread_ptrs 0x[[#WEAK_DY_TLV_ADDR]] pointer 0 libfoo    _weak_dysym_tlv
+# CHECK-DAG:   __DATA_CONST  __got         0x[[#WEAK_DY_GOT_ADDR]] pointer 0 libfoo    _weak_dysym_for_gotpcrel
+## Check that we don't have any other bindings
+# CHECK-NOT:   pointer
+
+# CHECK-LABEL: Weak bind table:
+# CHECK-DAG:   __DATA_CONST __got         0x[[#WEAK_DY_GOT_ADDR]]   pointer 0 _weak_dysym_for_gotpcrel
+# CHECK-DAG:   __DATA_CONST __got         0x[[#WEAK_EXT_GOT_ADDR]]  pointer 0 _weak_external_for_gotpcrel
+# CHECK-DAG:   __DATA       __data        0x[[#WEAK_DY]]            pointer 0 _weak_dysym
+# CHECK-DAG:   __DATA       __thread_ptrs 0x[[#WEAK_TLV_ADDR]]      pointer 0 _weak_tlv
+# CHECK-DAG:   __DATA       __thread_ptrs 0x[[#WEAK_DY_TLV_ADDR]]   pointer 0 _weak_dysym_tlv
+# CHECK-DAG:   __DATA       __data        0x{{[0-9a-f]*}}           pointer 2 _weak_external
+## Check that we don't have any other bindings
+# CHECK-NOT:   pointer
+
+## Weak internal symbols don't get bindings
+# RUN: llvm-objdump --macho --bind --weak-bind %t/test | FileCheck %s --check-prefix=WEAK-INTERNAL
+# WEAK-INTERNAL-NOT: _weak_internal
+# WEAK-INTERNAL-NOT: _weak_internal_tlv
+
+#--- libfoo.s
+
+.globl _weak_dysym
+.weak_definition _weak_dysym
+_weak_dysym:
+  .quad 0x1234
+
+.globl _weak_dysym_for_gotpcrel
+.weak_definition _weak_dysym_for_gotpcrel
+_weak_dysym_for_gotpcrel:
+  .quad 0x1234
+
+.section __DATA,__thread_vars,thread_local_variables
+
+.globl _weak_dysym_tlv
+.weak_definition _weak_dysym_tlv
+_weak_dysym_tlv:
+  .quad 0x1234
+
+#--- test.s
+
+.globl _main, _weak_external, _weak_external_for_gotpcrel
+.weak_definition _weak_external, _weak_external_for_gotpcrel, _weak_internal
+
+_main:
+  mov _weak_dysym_for_gotpcrel@GOTPCREL(%rip), %rax
+  mov _weak_external_for_gotpcrel@GOTPCREL(%rip), %rax
+  mov _weak_tlv@TLVP(%rip), %rax
+  mov _weak_dysym_tlv@TLVP(%rip), %rax
+  mov _weak_internal_tlv@TLVP(%rip), %rax
+  mov $0, %rax
+  ret
+
+_weak_external:
+  .quad 0x1234
+
+_weak_external_for_gotpcrel:
+  .quad 0x1234
+
+_weak_internal:
+  .quad 0x1234
+
+.data
+  .quad _weak_dysym
+  .quad _weak_external + 2
+  .quad _weak_internal
+
+.tbss _weak_tlv$tlv$init, 4, 2
+.tbss _weak_internal_tlv$tlv$init, 4, 2
+
+.section __DATA,__thread_vars,thread_local_variables
+.globl _weak_tlv
+.weak_definition  _weak_tlv, _weak_internal_tlv
+
+_weak_tlv:
+  .quad __tlv_bootstrap
+  .quad 0
+  .quad _weak_tlv$tlv$init
+
+_weak_internal_tlv:
+  .quad __tlv_bootstrap
+  .quad 0
+  .quad _weak_internal_tlv$tlv$init