[lld-macho] Implement weak binding for branch relocations

[int3]

Summary

Since there is no "weak lazy" lookup, function calls to weak symbols are
always non-lazily bound. We emit both regular non-lazy bindings as well
as weak bindings, in order that the weak bindings may overwrite the
non-lazy bindings if an appropriate symbol is found at runtime. However,
the bound addresses will still be written (non-lazily) into the
LazyPointerSection.

[int3]

rebase

[smeenai]

LGTM

lld/MachO/Arch/X86_64.cpp

32

Out of curiosity, what makes us need the explicit macho:: qualifier here?

lld/MachO/Symbols.h

70

Nit: add a newline before this, to separate it from the block of gotIndex and its comment.

lld/test/MachO/weak-binding.s

109

If I'm understanding the code correctly, a weak non-external function would behave the same as a weak external function (i.e. it would get a weak binding entry), which is different from non-external data. Is that intended, and either way, could you add a test?

lld/test/MachO/weak-definition-order.s

28–30

Do we also wanna check the weak bind entries?

[int3]

lld/MachO/Arch/X86_64.cpp

32

it appears to be conflicting with llvm::object::Archive::Symbol. I didn't look into why it started conflicting in this diff and not before...

lld/test/MachO/weak-binding.s

109

nope... weak non-externals cannot be coalesced at runtime. I'm not sure the weak flag does anything meaningful to internal symbols actually...

will add the test

lld/test/MachO/weak-definition-order.s

28–30

the weak bind info doesn't include the dylib name, so it won't tell us which symbol got priority here

[int3]

lld/test/MachO/weak-binding.s

109

oh, yeah, I see what you're saying now -- my code doesn't actually implement that properly 😅

[int3]

address comments

[smeenai]

LGTM

lld/test/MachO/weak-definition-order.s

28–30

Ah, right.

lld/MachO/Arch/X86_64.cpp

 
 struct X86_64 : TargetInfo {
   X86_64();
 
   uint64_t getImplicitAddend(MemoryBufferRef, const section_64 &,
                              const relocation_info &) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t val) const override;
 
-  void writeStub(uint8_t *buf, const DylibSymbol &) const override;
+  void writeStub(uint8_t *buf, const macho::Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;
 
   void prepareSymbolRelocation(lld::macho::Symbol *, const InputSection *,
                                const Reloc &) override;
   uint64_t resolveSymbolVA(uint8_t *buf, const lld::macho::Symbol &,
                            uint8_t type) const override;
static void writeRipRelative(uint8_t *buf, uint64_t bufAddr, uint64_t bufOff,
   // stored in the last 4 bytes of the instruction.
   write32le(buf + bufOff - 4, destAddr - rip);
 }
 
 static constexpr uint8_t stub[] = {
     0xff, 0x25, 0, 0, 0, 0, // jmpq *__la_symbol_ptr(%rip)
 };
 
-void X86_64::writeStub(uint8_t *buf, const DylibSymbol &sym) const {
+void X86_64::writeStub(uint8_t *buf, const macho::Symbol &sym) const {
   memcpy(buf, stub, 2); // just copy the two nonzero bytes
   uint64_t stubAddr = in.stubs->addr + sym.stubsIndex * sizeof(stub);
   writeRipRelative(buf, stubAddr, sizeof(stub),
                    in.lazyPointers->addr + sym.stubsIndex * WordSize);
 }
 
 static constexpr uint8_t stubHelperHeader[] = {
     0x4c, 0x8d, 0x1d, 0, 0, 0, 0, // 0x0: leaq ImageLoaderCache(%rip), %r11
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);
+    if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
+      if (in.stubs->addEntry(dysym)) {
+        if (sym->isWeakDef()) {
+          in.binding->addEntry(dysym, in.lazyPointers,
+                               sym->stubsIndex * WordSize);
+          in.weakBinding->addEntry(sym, in.lazyPointers,
+                                   sym->stubsIndex * WordSize);
+        } else {
+          in.lazyBinding->addEntry(dysym);
+        }
+      }
+    } else if (auto *defined = dyn_cast<Defined>(sym)) {
+      if (defined->isWeakDef() && defined->isExternal())
+        if (in.stubs->addEntry(sym))
+          in.weakBinding->addEntry(sym, in.lazyPointers,
+                                   sym->stubsIndex * WordSize);
+    }
     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;

 }
 
 uint64_t X86_64::resolveSymbolVA(uint8_t *buf, const lld::macho::Symbol &sym,
                                  uint8_t type) const {
   switch (type) {
   case X86_64_RELOC_GOT_LOAD:
   case X86_64_RELOC_GOT:
     return in.got->addr + sym.gotIndex * WordSize;
-  case X86_64_RELOC_BRANCH:
-    if (auto *dysym = dyn_cast<DylibSymbol>(&sym))
-      return in.stubs->addr + dysym->stubsIndex * sizeof(stub);
+  case X86_64_RELOC_BRANCH: {
+    if (sym.isInStubs())
+      return in.stubs->addr + sym.stubsIndex * sizeof(stub);
     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 (sym.isInGot())

lld/MachO/Symbols.h

public:
 
   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; }
 
+  // Whether this symbol is in the StubsSection.
+  bool isInStubs() const { return stubsIndex != 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;
 
+  uint32_t stubsIndex = UINT32_MAX;
+
 protected:
   Symbol(Kind k, StringRefZ name) : symbolKind(k), name(name) {}
 
   Kind symbolKind;
   StringRefZ name;
 };
 
 class Defined : public Symbol {

 };
 
 class DylibSymbol : public Symbol {
 public:
   DylibSymbol(DylibFile *file, StringRefZ name, bool isWeakDef, bool isTlv)
       : Symbol(DylibKind, name), file(file), weakDef(isWeakDef), tlv(isTlv) {}
 
   bool isWeakDef() const override { return weakDef; }
-
   bool isTlv() const override { return tlv; }
+  bool hasStubsHelper() const { return stubsHelperIndex != UINT32_MAX; }
 
   static bool classof(const Symbol *s) { return s->kind() == DylibKind; }
 
   DylibFile *file;
-  uint32_t stubsIndex = UINT32_MAX;
+  uint32_t stubsHelperIndex = UINT32_MAX;
   uint32_t lazyBindOffset = UINT32_MAX;
 
 private:
   const bool weakDef;
   const bool tlv;
 };
 
 class LazySymbol : public Symbol {

lld/MachO/SyntheticSections.h

 
 // 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
+// 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).
 //
-// Initially, the LazyPointerSection contains addresses that point into one of
-// the entry points in the middle of the StubHelperSection. The code in
+// We will first describe how non-weak symbols are handled.
+//
+// At program start, the LazyPointerSection contains addresses that point into
+// one of the entry points in the middle of the StubHelperSection. The code in
 // StubHelperSection will push on the stack an offset into the
 // LazyBindingSection. The push is followed by a jump to the beginning of the
 // StubHelperSection (similar to PLT0), which then calls into dyld_stub_binder.
 // dyld_stub_binder is a non-lazily-bound symbol, so this call looks it up in
 // the GOT.
 //
 // The stub binder will look up the bind opcodes in the LazyBindingSection at
-// the given offset. The bind opcodes will tell the binder to update the address
-// in the LazyPointerSection to point to the symbol, so that subsequent calls
-// don't have to redo the symbol resolution. The binder will then jump to the
-// resolved symbol.
+// the given offset. The bind opcodes will tell the binder to update the
+// address in the LazyPointerSection to point to the symbol, so that subsequent
+// calls don't have to redo the symbol resolution. The binder will then jump to
+// the resolved symbol.
+//
+// With weak symbols, the situation is slightly different. Since there is no
+// "weak lazy" lookup, function calls to weak symbols are always non-lazily
+// bound. We emit both regular non-lazy bindings as well as weak bindings, in
+// order that the weak bindings may overwrite the non-lazy bindings if an
+// appropriate symbol is found at runtime. However, the bound addresses will
+// still be written (non-lazily) into the LazyPointerSection.
 
 class StubsSection : public SyntheticSection {
 public:
   StubsSection();
   uint64_t getSize() const override;
   bool isNeeded() const override { return !entries.empty(); }
   void writeTo(uint8_t *buf) const override;
-
-  const llvm::SetVector<DylibSymbol *> &getEntries() const { return entries; }
-
-  void addEntry(DylibSymbol *sym);
+  const llvm::SetVector<Symbol *> &getEntries() const { return entries; }
+  // Returns whether the symbol was added. Note that every stubs entry will
+  // have a corresponding entry in the LazyPointerSection.
+  bool addEntry(Symbol *);
 
 private:
-  llvm::SetVector<DylibSymbol *> entries;
+  llvm::SetVector<Symbol *> entries;
 };
 
 class StubHelperSection : public SyntheticSection {
 public:
   StubHelperSection();
   uint64_t getSize() const override;
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 
   void setup();
 
   DylibSymbol *stubBinder = nullptr;
 };
 
 // This section contains space for just a single word, and will be used by dyld
 // to cache an address to the image loader it uses. Note that unlike the other
 // synthetic sections, which are OutputSections, the ImageLoaderCacheSection is
 // an InputSection that gets merged into the __data OutputSection.
 class ImageLoaderCacheSection : public InputSection {
 public:
   ImageLoaderCacheSection();
   uint64_t getSize() const override { return WordSize; }
 };
 
+// Note that this section may also be targeted by non-lazy bindings. In
+// particular, this happens when branch relocations target weak symbols.
 class LazyPointerSection : public SyntheticSection {
 public:
   LazyPointerSection();
   uint64_t getSize() const override;
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 };
 
 class LazyBindingSection : public LinkEditSection {
 public:
   LazyBindingSection();
   void finalizeContents();
   uint64_t getRawSize() const override { return contents.size(); }
-  uint32_t encode(const DylibSymbol &);
   // Like other sections in __LINKEDIT, the lazy 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;
+  bool isNeeded() const override { return !entries.empty(); }
   void writeTo(uint8_t *buf) const override;
+  // Note that every entry here will by referenced by a corresponding entry in
+  // the StubHelperSection.
+  void addEntry(DylibSymbol *dysym);
+  const llvm::SetVector<DylibSymbol *> &getEntries() const { return entries; }
 
 private:
+  uint32_t encode(const DylibSymbol &);
+
+  llvm::SetVector<DylibSymbol *> entries;
   SmallVector<char, 128> contents;
   llvm::raw_svector_ostream os{contents};
 };
 
 // Stores a trie that describes the set of exported symbols.
 class ExportSection : public LinkEditSection {
 public:
   ExportSection();
private:
   StringTableSection &stringTableSection;
   std::vector<SymtabEntry> symbols;
 };
 
 struct InStruct {
   MachHeaderSection *header = nullptr;
   BindingSection *binding = nullptr;
   WeakBindingSection *weakBinding = nullptr;
+  LazyBindingSection *lazyBinding = 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

StubsSection::StubsSection()
     : SyntheticSection(segment_names::text, "__stubs") {}
 
 uint64_t StubsSection::getSize() const {
   return entries.size() * target->stubSize;
 }
 
 void StubsSection::writeTo(uint8_t *buf) const {
   size_t off = 0;
-  for (const DylibSymbol *sym : in.stubs->getEntries()) {
+  for (const Symbol *sym : entries) {
     target->writeStub(buf + off, *sym);
     off += target->stubSize;
   }
 }
 
-void StubsSection::addEntry(DylibSymbol *sym) {
-  if (entries.insert(sym))
+bool StubsSection::addEntry(Symbol *sym) {
+  bool inserted = entries.insert(sym);
+  if (inserted)
     sym->stubsIndex = entries.size() - 1;
+  return inserted;
 }
 
 StubHelperSection::StubHelperSection()
     : SyntheticSection(segment_names::text, "__stub_helper") {}
 
 uint64_t StubHelperSection::getSize() const {
   return target->stubHelperHeaderSize +
-         in.stubs->getEntries().size() * target->stubHelperEntrySize;
+         in.lazyBinding->getEntries().size() * target->stubHelperEntrySize;
 }
 
-bool StubHelperSection::isNeeded() const {
-  return !in.stubs->getEntries().empty();
-}
+bool StubHelperSection::isNeeded() const { return in.lazyBinding->isNeeded(); }
 
 void StubHelperSection::writeTo(uint8_t *buf) const {
   target->writeStubHelperHeader(buf);
   size_t off = target->stubHelperHeaderSize;
-  for (const DylibSymbol *sym : in.stubs->getEntries()) {
+  for (const DylibSymbol *sym : in.lazyBinding->getEntries()) {
     target->writeStubHelperEntry(buf + off, *sym, addr + off);
     off += target->stubHelperEntrySize;
   }
 }
 
 void StubHelperSection::setup() {
   stubBinder = dyn_cast_or_null<DylibSymbol>(symtab->find("dyld_stub_binder"));
   if (stubBinder == nullptr) {

 }
 
 bool LazyPointerSection::isNeeded() const {
   return !in.stubs->getEntries().empty();
 }
 
 void LazyPointerSection::writeTo(uint8_t *buf) const {
   size_t off = 0;
-  for (const DylibSymbol *sym : in.stubs->getEntries()) {
-    uint64_t stubHelperOffset = target->stubHelperHeaderSize +
-                                sym->stubsIndex * target->stubHelperEntrySize;
+  for (const Symbol *sym : in.stubs->getEntries()) {
+    if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
+      if (dysym->hasStubsHelper()) {
+        uint64_t stubHelperOffset =
+            target->stubHelperHeaderSize +
+            dysym->stubsHelperIndex * target->stubHelperEntrySize;
         write64le(buf + off, in.stubHelper->addr + stubHelperOffset);
+      }
+    } else {
+      write64le(buf + off, sym->getVA());
+    }
     off += WordSize;
   }
 }
 
 LazyBindingSection::LazyBindingSection()
     : LinkEditSection(segment_names::linkEdit, section_names::lazyBinding) {}
 
-bool LazyBindingSection::isNeeded() const { return in.stubs->isNeeded(); }
-
 void LazyBindingSection::finalizeContents() {
   // TODO: Just precompute output size here instead of writing to a temporary
   // buffer
-  for (DylibSymbol *sym : in.stubs->getEntries())
+  for (DylibSymbol *sym : entries)
     sym->lazyBindOffset = encode(*sym);
 }
 
 void LazyBindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
+void LazyBindingSection::addEntry(DylibSymbol *dysym) {
+  if (entries.insert(dysym))
+    dysym->stubsHelperIndex = entries.size() - 1;
+}
+
 // Unlike the non-lazy binding section, the bind opcodes in this section aren't
 // interpreted all at once. Rather, dyld will start interpreting opcodes at a
 // given offset, typically only binding a single symbol before it finds a
 // BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
 // we cannot encode just the differences between symbols; we have to emit the
 // complete bind information for each symbol.
 uint32_t LazyBindingSection::encode(const DylibSymbol &sym) {
   uint32_t opstreamOffset = contents.size();

lld/MachO/Target.h

public:
   // Validate the relocation structure and get its addend.
   virtual uint64_t
   getImplicitAddend(llvm::MemoryBufferRef, const llvm::MachO::section_64 &,
                     const llvm::MachO::relocation_info &) const = 0;
   virtual void relocateOne(uint8_t *loc, const Reloc &, uint64_t val) const = 0;
 
   // Write code for lazy binding. See the comments on StubsSection for more
   // details.
-  virtual void writeStub(uint8_t *buf, const DylibSymbol &) const = 0;
+  virtual void writeStub(uint8_t *buf, const Symbol &) const = 0;
   virtual void writeStubHelperHeader(uint8_t *buf) const = 0;
   virtual void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                                     uint64_t entryAddr) const = 0;
 
   // Symbols may be referenced via either the GOT or the stubs section,
   // depending on the relocation type. prepareSymbolRelocation() will set up the
   // GOT/stubs entries, and resolveSymbolVA() will return the addresses of those
   // entries. resolveSymbolVA() may also relax the target instructions to save

lld/MachO/Writer.cpp

public:
   void writeSections();
 
   void run();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   MachHeaderSection *header = nullptr;
-  LazyBindingSection *lazyBindingSection = nullptr;
   ExportSection *exportSection = nullptr;
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
 class LCDyldInfo : public LoadCommand {
 public:
for (Reloc &r : isec->relocs) {
         else
           target->prepareSymbolRelocation(s, isec, r);
       }
     }
   }
 }
 
 void Writer::createLoadCommands() {
-  in.header->addLoadCommand(make<LCDyldInfo>(
-      in.binding, in.weakBinding, lazyBindingSection, exportSection));
+  in.header->addLoadCommand(make<LCDyldInfo>(in.binding, in.weakBinding,
+                                             in.lazyBinding, 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>());
for (auto *osec : seg->getSections()) {
         }
       }
     }
   }
 }
 
 void Writer::createOutputSections() {
   // First, create hidden sections
-  lazyBindingSection = make<LazyBindingSection>();
   stringTableSection = make<StringTableSection>();
   symtabSection = make<SymtabSection>(*stringTableSection);
   exportSection = make<ExportSection>();
 
   switch (config->outputType) {
   case MH_EXECUTE:
     make<PageZeroSection>();
     break;
void Writer::run() {
   // contents.
   for (OutputSegment *seg : outputSegments)
     if (seg != linkEditSegment)
       assignAddresses(seg);
 
   // Fill __LINKEDIT contents.
   in.binding->finalizeContents();
   in.weakBinding->finalizeContents();
-  lazyBindingSection->finalizeContents();
+  in.lazyBinding->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.lazyBinding = make<LazyBindingSection>();
   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: llvm-objdump -d --no-show-raw-insn --bind --lazy-bind --weak-bind --full-contents %t/test | \
 # RUN:   FileCheck %s
 
+# CHECK:      Contents of section __la_symbol_ptr:
+## Check that this section contains a nonzero pointer. It should point to
+## _weak_external_fn, 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:      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.
+## _weak_external_for_gotpcrel.
 # 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-NEXT: callq 0x{{[0-9a-f]*}}
+# CHECK-NEXT: callq 0x{{[0-9a-f]*}}
+# CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 
 # 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-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-DAG:   __DATA        __la_symbol_ptr 0x[[#%x,WEAK_DY_FN:]]   pointer 0 libfoo    _weak_dysym_fn
 ## Check that we don't have any other bindings
 # CHECK-NOT:   pointer
 
+# CHECK-LABEL: Lazy bind table:
+## Verify that we have no lazy 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-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-DAG:   __DATA       __la_symbol_ptr 0x[[#WEAK_DY_FN]]         pointer 0 _weak_dysym_fn
+# CHECK-DAG:   __DATA       __la_symbol_ptr 0x{{[0-9a-f]*}}           pointer 0 _weak_external_fn
 ## 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
+# RUN: llvm-objdump --macho --bind --lazy-bind --weak-bind %t/test | FileCheck %s --check-prefix=WEAK-INTERNAL
 # WEAK-INTERNAL-NOT: _weak_internal
+# WEAK-INTERNAL-NOT: _weak_internal_fn
 # 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
 
+.globl _weak_dysym_fn
+.weak_definition _weak_dysym_fn
+_weak_dysym_fn:
+  ret
+
 .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
+.globl _main, _weak_external, _weak_external_for_gotpcrel, _weak_external_fn
+.weak_definition _weak_external, _weak_external_for_gotpcrel, _weak_external_fn, _weak_internal, _weak_internal_fn
 
 _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
+  callq _weak_dysym_fn
+  callq _weak_external_fn
+  callq _weak_internal_fn
   mov $0, %rax
   ret
 
 _weak_external:
   .quad 0x1234
 
 _weak_external_for_gotpcrel:
   .quad 0x1234
 
+_weak_external_fn:
+  ret
+
 _weak_internal:
   .quad 0x1234
 
+_weak_internal_fn:
+  ret
+
 .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
 

lld/test/MachO/weak-definition-order.s

 # WEAK2: O __TEXT,weak2 _foo
 
 # RUN: lld -flavor darwinnew -dylib -install_name \
 # RUN:   @executable_path/libweak1.dylib %t/weak1.o -o %t/libweak1.dylib
 # RUN: lld -flavor darwinnew -dylib -install_name \
 # RUN:   @executable_path/libweak2.dylib %t/weak2.o -o %t/libweak2.dylib
 
 # RUN: lld -flavor darwinnew -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -o %t/dylib12 -Z -L%t -lweak1 -lweak2 %t/test.o
-# RUN: llvm-objdump --macho --lazy-bind %t/dylib12 | FileCheck %s --check-prefix=DYLIB1
+# RUN: llvm-objdump --macho --bind %t/dylib12 | FileCheck %s --check-prefix=DYLIB1
 # RUN: lld -flavor darwinnew -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -o %t/dylib21 -Z -L%t -lweak2 -lweak1 %t/test.o
-# RUN: llvm-objdump --macho --lazy-bind %t/dylib21 | FileCheck %s --check-prefix=DYLIB2
-## TODO: these should really be in the weak binding section, not the lazy binding section
-# DYLIB1: __DATA   __la_symbol_ptr    0x{{[0-9a-f]*}} libweak1         _foo
-# DYLIB2: __DATA   __la_symbol_ptr    0x{{[0-9a-f]*}} libweak2         _foo
+# RUN: llvm-objdump --macho --bind %t/dylib21 | FileCheck %s --check-prefix=DYLIB2
+# DYLIB1: __DATA   __la_symbol_ptr    0x{{[0-9a-f]*}} pointer 0 libweak1         _foo
+# DYLIB2: __DATA   __la_symbol_ptr    0x{{[0-9a-f]*}} pointer 0 libweak2         _foo
 
 .globl _main
 _main:
   callq _foo
   ret