[lld-macho] Add support for weak references

[int3]

Summary

Weak references need not necessarily be satisfied at runtime (but they must
still be satisfied at link time). So symbol resolution still works as per usual,
but we now pass around a flag -- ultimately emitting it in the bind table -- to
indicate if a given dylib symbol is a weak reference.

ld64's behavior for symbols that have both weak and strong references is
a bit bizarre. For non-function symbols, it will emit a weak import. For
function symbols (those referenced by BRANCH relocs), it will emit a
regular import. I'm not sure what value there is in that behavior, and
since emulating it will make our implementation more complex, I've
decided to treat regular weakrefs like function symbol ones for now.

Fixes PR48511.

[thakis]

Nice! I fumbled around a bit with this yesterday and wrote almost exactly the same change, except I didn't have the critical bind opcode bits (just the symbol table) since I don't know that part well yet. And in my local diff I made it so that a single non-weak ref makes the whole symbol non-weak while here a single weak ref makes the whole symbol weak (see first comment below). But in any case, this is great progress and definitely going in the right direction :)

lld/MachO/SymbolTable.cpp

77

Is that how it works? One weak ref makes all refs weak? I would've expected that one non-weak ref makes the whole symbol non-weak, but I haven't checked. Semantically it kind of makes sense: If your program has a single non-weak call to a symbol, there can't be a need for the symbol to be weak. Maybe that's what explains the ld64 behavior for functions?

118

Maybe combine these two nested ifs using the spiffy && operator? :)

lld/test/MachO/symtab.s

61–62

(a bit weird that llvm-readobj output doesn't include weakness)

[int3]

lld/MachO/SymbolTable.cpp

77

I would've expected that one non-weak ref makes the whole symbol non-weak

I expected this too, but ld64 doesn't do this for non-function symbols. I can't see a good reason for the inconsistency between functions and non-functions, so I guess we have to make a choice. Making weakness take priority has the advantage of being more permissive -- if ld64 succeeds in linking a given binary, so should we. But there's a good argument for not implementing dubious behavior until we have a concrete use case.

tl;dr I'll switch to having non-weak take priority

lld/test/MachO/symtab.s

61–62

it does -- these particular symbols are just not weak references. I modified this test case because we're now marking all dylib symbols as extern, which I believe is the right behavior. And that was done because nm doesn't interpret the weakref flag correctly if extern isn't set.

[int3]

Re bind opcodes: I found http://www.m4b.io/reverse/engineering/mach/binaries/2015/03/29/mach-binaries.html to be a good resource when I was starting out. Particularly the "Mach Import Bind FSA" section.

[int3]

make non-weakness take priority

[thakis]

lld/MachO/SymbolTable.cpp

124

Can it happen that a dylib symbol is added before the first undefined? If so, then the initial dylib has isWeakRef set to false, and it can then never become true. If I read Driver.cpp, this can happen if a dylib is passed before the .o referring to it is passed. (In my local patch I gave DylibSymbol an

+  enum WeakState { Unknown, SawWeakRefOnly, SawStrongRef,  };
+  WeakState weakRefState;

and a

+  void sawUndefined(bool weakRef) {
+    switch (weakRefState) {
+    case Unknown:
+      weakRefState = weakRef ? SawWeakRefOnly : SawStrongRef;
+      break;
+    case SawWeakRefOnly:
+      if (!weakRef)
+        weakRefState = SawStrongRef;
+      break;
+    case SawStrongRef:
+      break;
+    }
+  }

and made DylibSymbol start with Unknown and then in addUndefined did

+  else if (auto *dylib = dyn_cast<DylibSymbol>(s))
+    dylib->sawUndefined(isWeakRef);

I only sketched it locally and hadn't written tests yet so maybe this is overkill, but my read of Driver is that this is necessary. (It's noticeably more annoying to write than making one weak ref turn the whole symbol weak.)

[int3]

lld/MachO/SymbolTable.cpp

124

oh yes. I thought I was missing something this morning in my implementation but couldn't put my finger on it... thanks!

[int3]

use enum for weakref state

[int3]

lld/MachO/SymbolTable.cpp

124

Okay, so I think the enum approach is the right one, though the reasons are a bit more complicated. I think handling the "dylib symbol before undefined symbol" case by itself could have been handled by initializing DylibSymbols with weakRef = true. However, there are two other cases for which having an "unreferenced" state is valuable:

1. Determining which symbols to emit in LC_SYMTAB. The current implementation emits DylibSymbols if they are in the GOT/PLT, but that misses out symbols which aren't in either (e.g. referenced by .quad sym). I'm addressing that in this diff since it is naturally covered within the weak-references.s test.
2. We should emit LC_LOAD_WEAK_DYLIB for libraries whose symbols are only referenced weakly. But dylibs whose symbols are not used at all should still be loaded strongly. I'm addressing that in D93435: [lld-macho] Use LC_LOAD_WEAK_DYLIB for dylibs with only weakrefs.

[int3]

made quite a few changes, so please have another look :)

[thakis]

Nice!

lld/MachO/Symbols.h

126

s/refState::Unreferenced/RefState::Unreferenced/

[int3]

unbreak debug build

[thakis]

FYI: I saw that ld64 has the flag -weak_reference_mismatches to kind of configure its behavior around this. (I don't need that flag and no action necessary, just happened to see it in the man page and figured I'd mention it.)

lld/MachO/Driver.cpp

if (config->allLoad || forceLoadArchive) {
           printArchiveMemberLoad(
               (forceLoadArchive ? "-force_load" : "-all_load"),
               inputFiles.back());
         }
       }
     } else if (config->forceLoadObjC) {
       for (const object::Archive::Symbol &sym : file->symbols())
         if (sym.getName().startswith(objc::klass))
-          symtab->addUndefined(sym.getName());
+          symtab->addUndefined(sym.getName(), /*isWeakRef=*/false);
 
       // TODO: no need to look for ObjC sections for a given archive member if
       // we already found that it contains an ObjC symbol. We should also
       // consider creating a LazyObjFile class in order to avoid double-loading
       // these files here and below (as part of the ArchiveFile).
       if (Optional<MemoryBufferRef> buffer = readFile(path)) {
         for (const ArchiveMember &member : getArchiveMembers(*buffer)) {
           if (hasObjCSection(member.mbref)) {
if (errOrWriter) {
       error("--reproduce: " + toString(errOrWriter.takeError()));
     }
   }
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
   target = createTargetInfo(args);
 
-  config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"));
+  config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
+                                       /*isWeakRef=*/false);
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->installName =
       args.getLastArgValue(OPT_install_name, config->outputFile);
   config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
   config->headerPadMaxInstallNames =
       args.hasArg(OPT_headerpad_max_install_names);
   config->printEachFile = args.hasArg(OPT_t);
   config->printWhyLoad = args.hasArg(OPT_why_load);

lld/MachO/InputFiles.cpp

 }
 
 macho::Symbol *ObjFile::parseNonSectionSymbol(const structs::nlist_64 &sym,
                                               StringRef name) {
   uint8_t type = sym.n_type & N_TYPE;
   switch (type) {
   case N_UNDF:
     return sym.n_value == 0
-               ? symtab->addUndefined(name)
+               ? symtab->addUndefined(name, sym.n_desc & N_WEAK_REF)
                : symtab->addCommon(name, this, sym.n_value,
                                    1 << GET_COMM_ALIGN(sym.n_desc));
   case N_ABS:
     return createAbsolute(sym, name);
   case N_PBUD:
   case N_INDR:
     error("TODO: support symbols of type " + std::to_string(type));
     return nullptr;

lld/MachO/SymbolTable.h

  * new`. Therefore, there is no need to update any relocations that hold
  * pointers the "old" Symbol -- they will automatically point to the new one.
  */
 class SymbolTable {
 public:
   Symbol *addDefined(StringRef name, InputSection *isec, uint32_t value,
                      bool isWeakDef);
 
-  Symbol *addUndefined(StringRef name);
+  Symbol *addUndefined(StringRef name, bool isWeakRef);
 
   Symbol *addCommon(StringRef name, InputFile *, uint64_t size, uint32_t align);
 
   Symbol *addDylib(StringRef name, DylibFile *file, bool isWeakDef, bool isTlv);
 
   Symbol *addLazy(StringRef name, ArchiveFile *file,
                   const llvm::object::Archive::Symbol &sym);
 

lld/MachO/SymbolTable.cpp

Symbol *SymbolTable::addDefined(StringRef name, InputSection *isec,
   }
 
   Defined *defined = replaceSymbol<Defined>(s, name, isec, value, isWeakDef,
                                             /*isExternal=*/true);
   defined->overridesWeakDef = overridesWeakDef;
   return s;
 }
 
-Symbol *SymbolTable::addUndefined(StringRef name) {
+Symbol *SymbolTable::addUndefined(StringRef name, bool isWeakRef) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
 
+  auto refState = isWeakRef ? RefState::Weak : RefState::Strong;
+
   if (wasInserted)
-    replaceSymbol<Undefined>(s, name);
-  else if (LazySymbol *lazy = dyn_cast<LazySymbol>(s))
+    replaceSymbol<Undefined>(s, name, refState);
+  else if (auto *lazy = dyn_cast<LazySymbol>(s))
     lazy->fetchArchiveMember();
+  else if (auto *dynsym = dyn_cast<DylibSymbol>(s))
+    dynsym->refState = std::max(dynsym->refState, refState);
+  else if (auto *undefined = dyn_cast<Undefined>(s))
+    undefined->refState = std::max(undefined->refState, refState);
   return s;
 }
 
 Symbol *SymbolTable::addCommon(StringRef name, InputFile *file, uint64_t size,
                                uint32_t align) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);

 }
 
 Symbol *SymbolTable::addDylib(StringRef name, DylibFile *file, bool isWeakDef,
                               bool isTlv) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name);
 
-  if (!wasInserted && isWeakDef)
-    if (auto *defined = dyn_cast<Defined>(s))
-      if (!defined->isWeakDef())
+  auto refState = RefState::Unreferenced;
+  if (!wasInserted) {
+    if (auto *defined = dyn_cast<Defined>(s)) {
+      if (isWeakDef && !defined->isWeakDef())
         defined->overridesWeakDef = true;
+    } else if (auto *undefined = dyn_cast<Undefined>(s)) {
+      refState = undefined->refState;
+    } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
+      refState = dysym->refState;
+    }
+  }
 
   if (wasInserted || isa<Undefined>(s) ||
       (isa<DylibSymbol>(s) && !isWeakDef && s->isWeakDef()))
-    replaceSymbol<DylibSymbol>(s, file, name, isWeakDef, isTlv);
+    replaceSymbol<DylibSymbol>(s, file, name, isWeakDef, refState, isTlv);
 
   return s;
 }
 
 Symbol *SymbolTable::addLazy(StringRef name, ArchiveFile *file,
                              const llvm::object::Archive::Symbol &sym) {
   Symbol *s;
   bool wasInserted;

lld/MachO/Symbols.h

public:
   StringRef getName() const { return {name.data, name.size}; }
 
   virtual uint64_t getVA() const { return 0; }
 
   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 isWeakDef() const { llvm_unreachable("cannot be weak def"); }
+
+  // Only undefined or dylib symbols can be weak references. A weak reference
+  // need not be satisfied at runtime, e.g. due to the symbol not being
+  // available on a given target platform.
+  virtual bool isWeakRef() const { llvm_unreachable("cannot be a weak ref"); }
 
   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; }
public:
 
   bool overridesWeakDef : 1;
 
 private:
   const bool weakDef : 1;
   const bool external : 1;
 };
 
+// Indicates whether & how a dylib symbol is referenced.
+enum class RefState : uint8_t { Unreferenced = 0, Weak = 1, Strong = 2 };
+
 class Undefined : public Symbol {
 public:
-  Undefined(StringRefZ name) : Symbol(UndefinedKind, name) {}
+  Undefined(StringRefZ name, RefState refState)
+      : Symbol(UndefinedKind, name), refState(refState) {
+    assert(refState != RefState::Unreferenced);
+  }
+
+  bool isWeakRef() const override { return refState == RefState::Weak; }
 
   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
+
+  RefState refState : 2;
 };
 
 // On Unix, it is traditionally allowed to write variable definitions without
 // initialization expressions (such as "int foo;") to header files. These are
 // called tentative definitions.
 //
 // Using tentative definitions is usually considered a bad practice; you should
 // write only declarations (such as "extern int foo;") to header files.
public:
 
   InputFile *const file;
   const uint64_t size;
   const uint32_t align;
 };
 
 class DylibSymbol : public Symbol {
 public:
-  DylibSymbol(DylibFile *file, StringRefZ name, bool isWeakDef, bool isTlv)
-      : Symbol(DylibKind, name), file(file), weakDef(isWeakDef), tlv(isTlv) {}
+  DylibSymbol(DylibFile *file, StringRefZ name, bool isWeakDef,
+              RefState refState, bool isTlv)
+      : Symbol(DylibKind, name), file(file), refState(refState),
+        weakDef(isWeakDef), tlv(isTlv) {}
 
   bool isWeakDef() const override { return weakDef; }
+  bool isWeakRef() const override { return refState == RefState::Weak; }
+  bool isReferenced() const { return refState != RefState::Unreferenced; }
   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 stubsHelperIndex = UINT32_MAX;
   uint32_t lazyBindOffset = UINT32_MAX;
 
+  RefState refState : 2;
+
 private:
-  const bool weakDef;
-  const bool tlv;
+  const bool weakDef : 1;
+  const bool tlv : 1;
 };
 
 class LazySymbol : public Symbol {
 public:
   LazySymbol(ArchiveFile *file, const llvm::object::Archive::Symbol &sym)
       : Symbol(LazyKind, sym.getName()), file(file), sym(sym) {}
 
   static bool classof(const Symbol *s) { return s->kind() == LazyKind; }

lld/MachO/SyntheticSections.cpp

 // 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 Symbol *sym, const OutputSection *osec,
                           uint64_t outSecOff, int64_t addend,
-                          Binding &lastBinding, raw_svector_ostream &os) {
+                          bool isWeakBinding, 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.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)
-     << sym->getName() << '\0'
+  uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
+  if (!isWeakBinding && sym->isWeakRef())
+    flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
+
+  os << flags << 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;
 }
 
 // Non-weak bindings need to have their dylib ordinal encoded as well.
 static void encodeDylibOrdinal(const DylibSymbol *dysym, Binding &lastBinding,
void BindingSection::finalizeContents() {
   // same segment / section are located together.
   llvm::sort(bindings, [](const BindingEntry &a, const BindingEntry &b) {
     return a.target.getVA() < b.target.getVA();
   });
   for (const BindingEntry &b : bindings) {
     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.addend, lastBinding, os);
+                    b.addend, /*isWeakBinding=*/false, lastBinding, os);
     } else {
       auto *osec = b.target.section.get<const OutputSection *>();
-      encodeBinding(b.dysym, osec, b.target.offset, b.addend, lastBinding, os);
+      encodeBinding(b.dysym, osec, b.target.offset, b.addend,
+                    /*isWeakBinding=*/false, 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());
void WeakBindingSection::finalizeContents() {
   // 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.addend, lastBinding, os);
+                    b.addend, /*isWeakBinding=*/true, lastBinding, os);
     } else {
       auto *osec = b.target.section.get<const OutputSection *>();
-      encodeBinding(b.symbol, osec, b.target.offset, b.addend, lastBinding, os);
+      encodeBinding(b.symbol, osec, b.target.offset, b.addend,
+                    /*isWeakBinding=*/true, lastBinding, os);
     }
   }
   if (!bindings.empty() || !definitions.empty())
     os << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
 }
 
 void WeakBindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());

 
 void StubHelperSection::setup() {
   stubBinder = dyn_cast_or_null<DylibSymbol>(symtab->find("dyld_stub_binder"));
   if (stubBinder == nullptr) {
     error("symbol dyld_stub_binder not found (normally in libSystem.dylib). "
           "Needed to perform lazy binding.");
     return;
   }
+  stubBinder->refState = RefState::Strong;
   in.got->addEntry(stubBinder);
 
   inputSections.push_back(in.imageLoaderCache);
   symtab->addDefined("__dyld_private", in.imageLoaderCache, 0,
                      /*isWeakDef=*/false);
 }
 
 ImageLoaderCacheSection::ImageLoaderCacheSection() {
uint32_t LazyBindingSection::encode(const DylibSymbol &sym) {
   if (sym.file->ordinal <= MachO::BIND_IMMEDIATE_MASK) {
     os << static_cast<uint8_t>(MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM |
                                sym.file->ordinal);
   } else {
     os << static_cast<uint8_t>(MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
     encodeULEB128(sym.file->ordinal, os);
   }
 
-  os << static_cast<uint8_t>(MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
-     << sym.getName() << '\0'
+  uint8_t flags = MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
+  if (sym.isWeakRef())
+    flags |= MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT;
+
+  os << flags << sym.getName() << '\0'
      << static_cast<uint8_t>(MachO::BIND_OPCODE_DO_BIND)
      << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
   return opstreamOffset;
 }
 
 void macho::prepareBranchTarget(Symbol *sym) {
   if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     if (in.stubs->addEntry(dysym)) {
for (InputFile *file : inputFiles) {
     }
   }
 
   for (Symbol *sym : symtab->getSymbols()) {
     uint32_t strx = stringTableSection.addString(sym->getName());
     if (auto *defined = dyn_cast<Defined>(sym)) {
       assert(defined->isExternal());
       externalSymbols.push_back({sym, strx});
-    } else if (sym->isInGot() || sym->isInStubs()) {
+    } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
+      if (dysym->isReferenced())
         undefinedSymbols.push_back({sym, strx});
     }
   }
 
   emitStabs();
   uint32_t symtabIndex = stabs.size();
   for (const SymtabEntry &entry :
        concat<SymtabEntry>(localSymbols, externalSymbols, undefinedSymbols)) {
     entry.sym->symtabIndex = symtabIndex++;
if (auto *defined = dyn_cast<Defined>(entry.sym)) {
         nList->n_sect = defined->isec->parent->index;
         // For the N_SECT symbol type, n_value is the address of the symbol
         nList->n_value = defined->getVA();
       }
       nList->n_desc |= defined->isWeakDef() ? MachO::N_WEAK_DEF : 0;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
       uint16_t n_desc = nList->n_desc;
       MachO::SET_LIBRARY_ORDINAL(n_desc, dysym->file->ordinal);
+      nList->n_type = MachO::N_EXT;
+      n_desc |= dysym->isWeakRef() ? MachO::N_WEAK_REF : 0;
       nList->n_desc = n_desc;
     }
     ++nList;
   }
 }
 
 IndirectSymtabSection::IndirectSymtabSection()
     : LinkEditSection(segment_names::linkEdit,

lld/test/MachO/symtab.s

 # CHECK-NEXT:     Type: Section (0xE)
 # CHECK-NEXT:     Section: __data (0x4)
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x1{{[0-9a-f]*}}
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: dyld_stub_binder (15)
+# CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Undef (0x0)
 # CHECK-NEXT:     Section:  (0x0)
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x100)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: _dynamic (80)
+# CHECK-NEXT:     Extern
 # CHECK-NEXT:     Type: Undef (0x0)
 # CHECK-NEXT:     Section:  (0x0)
 # CHECK-NEXT:     RefType: UndefinedNonLazy (0x0)
 # CHECK-NEXT:     Flags [ (0x200)
 # CHECK-NEXT:       AltEntry (0x200)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:   }

lld/test/MachO/weak-reference.s

+# REQUIRES: x86
+# RUN: rm -rf %t; split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/libfoo.s -o %t/libfoo.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/strongref.s -o %t/strongref.o
+# 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/invalid.s -o %t/invalid.o
+# RUN: %lld -lSystem -dylib %t/libfoo.o -o %t/libfoo.dylib
+
+# RUN: %lld -lSystem %t/test.o %t/libfoo.dylib -o %t/test
+# RUN: llvm-objdump --macho --syms --bind %t/test | FileCheck %s --check-prefixes=SYMS,BIND
+## llvm-objdump doesn't print out all the flags info for lazy & weak bindings,
+## so we use obj2yaml instead to test them.
+# RUN: obj2yaml %t/test | FileCheck %s --check-prefix=YAML
+
+# RUN: %lld -lSystem %t/libfoo.dylib %t/test.o -o %t/test
+# RUN: llvm-objdump --macho --syms --bind %t/test | FileCheck %s --check-prefixes=SYMS,BIND
+# RUN: obj2yaml %t/test | FileCheck %s --check-prefix=YAML
+
+# SYMS:     SYMBOL TABLE:
+# SYMS-DAG: 0000000000000000  w  *UND* _foo
+# SYMS-DAG: 0000000000000000  w  *UND* _foo_fn
+# SYMS-DAG: 0000000000000000  w  *UND* _foo_tlv
+# SYMS-DAG: 0000000000000000  w  *UND* _weak_foo
+# SYMS-DAG: 0000000000000000  w  *UND* _weak_foo_fn
+
+# BIND:      Bind table:
+# BIND-NEXT: segment       section          address         type     addend dylib   symbol
+# BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer       0 libfoo  _foo (weak_import)
+# BIND-DAG:  __DATA_CONST  __got            0x{{[0-9a-f]+}} pointer       0 libfoo  _foo (weak_import)
+# BIND-DAG:  __DATA        __thread_ptrs    0x{{[0-9a-f]+}} pointer       0 libfoo  _foo_tlv (weak_import)
+# BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer       0 libfoo  _weak_foo (weak_import)
+# BIND-DAG:  __DATA        __la_symbol_ptr  0x{{[0-9a-f]+}} pointer       0 libfoo  _weak_foo_fn (weak_import)
+
+# YAML-LABEL: WeakBindOpcodes:
+# YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# YAML-NEXT:     Imm:             0
+# YAML-NEXT:     Symbol:          _weak_foo
+# YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# YAML-NEXT:     Imm:             0
+# YAML-NEXT:     Symbol:          _weak_foo_fn
+# YAML-LABEL: LazyBindOpcodes:
+# YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# YAML-NEXT:     Imm:             1
+# YAML-NEXT:     Symbol:          _foo_fn
+
+## Check that if both strong & weak references are present in inputs, the weak
+## reference takes priority. NOTE: ld64 actually emits a strong reference if
+## the reference is to a function symbol or a TLV. I'm not sure if there's a
+## good reason for that, so I'm deviating here for a simpler implementation.
+# RUN: %lld -lSystem %t/test.o %t/strongref.o %t/libfoo.dylib -o %t/with-strong
+# RUN: llvm-objdump --macho --bind %t/with-strong | FileCheck %s --check-prefix=STRONG-BIND
+# RUN: obj2yaml %t/with-strong | FileCheck %s --check-prefix=STRONG-YAML
+# RUN: %lld -lSystem %t/strongref.o %t/test.o %t/libfoo.dylib -o %t/with-strong
+# RUN: llvm-objdump --macho --bind %t/with-strong | FileCheck %s --check-prefix=STRONG-BIND
+# RUN: obj2yaml %t/with-strong | FileCheck %s --check-prefix=STRONG-YAML
+# RUN: %lld -lSystem %t/libfoo.dylib %t/strongref.o %t/test.o -o %t/with-strong
+# RUN: llvm-objdump --macho --bind %t/with-strong | FileCheck %s --check-prefix=STRONG-BIND
+# RUN: obj2yaml %t/with-strong | FileCheck %s --check-prefix=STRONG-YAML
+# RUN: %lld -lSystem %t/libfoo.dylib %t/test.o %t/strongref.o -o %t/with-strong
+# RUN: llvm-objdump --macho --bind %t/with-strong | FileCheck %s --check-prefix=STRONG-BIND
+# RUN: obj2yaml %t/with-strong | FileCheck %s --check-prefix=STRONG-YAML
+# RUN: %lld -lSystem %t/test.o %t/libfoo.dylib %t/strongref.o -o %t/with-strong
+# RUN: llvm-objdump --macho --bind %t/with-strong | FileCheck %s --check-prefix=STRONG-BIND
+# RUN: obj2yaml %t/with-strong | FileCheck %s --check-prefix=STRONG-YAML
+# RUN: %lld -lSystem %t/strongref.o %t/libfoo.dylib %t/test.o -o %t/with-strong
+# RUN: llvm-objdump --macho --bind %t/with-strong | FileCheck %s --check-prefix=STRONG-BIND
+# RUN: obj2yaml %t/with-strong | FileCheck %s --check-prefix=STRONG-YAML
+
+# STRONG-BIND:      Bind table:
+# STRONG-BIND-NEXT: segment       section          address         type       addend dylib   symbol
+# STRONG-BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer         0 libfoo  _foo{{$}}
+# STRONG-BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer         0 libfoo  _foo{{$}}
+# STRONG-BIND-DAG:  __DATA_CONST  __got            0x{{[0-9a-f]+}} pointer         0 libfoo  _foo{{$}}
+# STRONG-BIND-DAG:  __DATA        __thread_ptrs    0x{{[0-9a-f]+}} pointer         0 libfoo  _foo_tlv{{$}}
+# STRONG-BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer         0 libfoo  _weak_foo{{$}}
+# STRONG-BIND-DAG:  __DATA        __data           0x{{[0-9a-f]+}} pointer         0 libfoo  _weak_foo{{$}}
+# STRONG-BIND-DAG:  __DATA        __la_symbol_ptr  0x{{[0-9a-f]+}} pointer         0 libfoo  _weak_foo_fn{{$}}
+
+# STRONG-YAML-LABEL: WeakBindOpcodes:
+# STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# STRONG-YAML-NEXT:     Imm:             0
+# STRONG-YAML-NEXT:     Symbol:          _weak_foo
+# STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# STRONG-YAML-NEXT:     Imm:             0
+# STRONG-YAML-NEXT:     Symbol:          _weak_foo
+# STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# STRONG-YAML-NEXT:     Imm:             0
+# STRONG-YAML-NEXT:     Symbol:          _weak_foo_fn
+# STRONG-YAML-LABEL: LazyBindOpcodes:
+# STRONG-YAML:        - Opcode:          BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM
+# STRONG-YAML-NEXT:     Imm:             0
+# STRONG-YAML-NEXT:     Symbol:          _foo_fn
+
+## Weak references must still be satisfied at link time.
+# RUN: not %lld -lSystem %t/invalid.o -o /dev/null 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=INVALID -DDIR=%t
+# INVALID: error: undefined symbol _missing, referenced from [[DIR]]/invalid.o
+
+#--- libfoo.s
+.globl _foo, _foo_fn, _weak_foo, _weak_foo_fn
+.weak_definition _weak_foo, _weak_foo_fn
+_foo:
+_foo_fn:
+_weak_foo:
+_weak_foo_fn:
+
+.section  __DATA,__thread_vars,thread_local_variables
+.globl _foo_tlv
+_foo_tlv:
+
+#--- test.s
+.globl _main
+.weak_reference _foo_fn, _foo, _weak_foo, _weak_foo_fn, _foo_tlv
+
+_main:
+  mov _foo@GOTPCREL(%rip), %rax
+  mov _foo_tlv@TLVP(%rip), %rax
+  callq _foo_fn
+  callq _weak_foo_fn
+  ret
+
+.data
+  .quad _foo
+  .quad _weak_foo
+
+#--- strongref.s
+.globl _strongref
+_strongref:
+  mov _foo@GOTPCREL(%rip), %rax
+  mov _foo_tlv@TLVP(%rip), %rax
+  callq _foo_fn
+  callq _weak_foo_fn
+  ret
+
+.data
+  .quad _foo
+  .quad _weak_foo
+
+#--- invalid.s
+.globl _main
+.weak_reference _missing
+_main:
+  callq _missing
+  ret