[lld/mac] Implement the missing bits of -undefined

[thakis]

Summary

This adds support for -undefined dynamic_lookup, and for
-undefined warning and -undefined suppress with -flat_namespace.

We just replace undefined symbols with a DynamicLookup when we hit them.

With this, check-llvm passes when using ld64.lld.darwinnew as host linker.

[int3]

With this, check-llvm passes when using ld64.lld.darwinnew as host linker.

Awesome!

lld/MachO/SymbolTable.cpp

if (!wasInserted) {
     if (isa<Defined>(s))
       error("found defined symbol with illegal name " + DSOHandle::name);
   }
   replaceSymbol<DSOHandle>(s, header);
   return s;
 }
 
 void lld::macho::treatUndefinedSymbol(const Undefined &sym) {
+  auto message = [](const Undefined &sym) {
     std::string message = "undefined symbol: " + toString(sym);
     std::string fileName = toString(sym.getFile());
-
     if (!fileName.empty())
       message += "\n>>> referenced by " + fileName;
+    return message;
+  };
   switch (config->undefinedSymbolTreatment) {
-  case UndefinedSymbolTreatment::suppress:
-    error("-undefined suppress unimplemented");
-    break;
   case UndefinedSymbolTreatment::error:
-    error(message);
+    error(message(sym));
     break;
   case UndefinedSymbolTreatment::warning:
-    warn(message);
-    error("-undefined warning unimplemented");
-    break;
+    warn(message(sym));
+    LLVM_FALLTHROUGH;
   case UndefinedSymbolTreatment::dynamic_lookup:
-    error("dynamic_lookup unimplemented for " + message);
+  case UndefinedSymbolTreatment::suppress:
+    symtab->addDynamicLookup(sym.getName());
     break;
   case UndefinedSymbolTreatment::unknown:
     llvm_unreachable("unknown -undefined TREATMENT");
   }
 }
 
 SymbolTable *macho::symtab;

lld/MachO/UnwindInfoSection.cpp

for (Reloc &r : isec->relocs) {
     assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
     if (r.offset % sizeof(CompactUnwindEntry64) !=
         offsetof(struct CompactUnwindEntry64, personality))
       continue;
 
     if (auto *s = r.referent.dyn_cast<lld::macho::Symbol *>()) {
       if (auto *undefined = dyn_cast<Undefined>(s)) {
         treatUndefinedSymbol(*undefined);
+        // treatUndefinedSymbol() can replace s with a DylibSymbol, re-check.
+        if (isa<Undefined>(s))
           continue;
       }
       if (auto *defined = dyn_cast<Defined>(s)) {
         // Check if we have created a synthetic symbol at the same address.
         macho::Symbol *&personality =
             personalityTable[{defined->isec, defined->value}];
         if (personality == nullptr) {
           personality = defined;
           in.got->addEntry(defined);

lld/MachO/Writer.cpp

for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
         // to emit rebase opcodes for it.
         it = std::next(it);
         assert(isa<Defined>(it->referent.dyn_cast<lld::macho::Symbol *>()));
         continue;
       }
       if (auto *sym = r.referent.dyn_cast<lld::macho::Symbol *>()) {
         if (auto *undefined = dyn_cast<Undefined>(sym))
           treatUndefinedSymbol(*undefined);
-        else if (target->validateSymbolRelocation(sym, isec, r))
+        // treatUndefinedSymbol() can replace sym with a DylibSymbol, re-check.
+        if (!isa<Undefined>(sym) &&
+            target->validateSymbolRelocation(sym, isec, r))
           prepareSymbolRelocation(sym, isec, r);
       } else {
         assert(r.referent.is<InputSection *>());
         if (!r.pcrel)
           in.rebase->addEntry(isec, r.offset);
       }
     }
   }

lld/test/MachO/treat-undef-sym.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos %s -o %t.o
 # RUN: not %lld -undefined bogus -o /dev/null %t.o 2>&1 | \
 # RUN:     FileCheck %s -check-prefix=UNKNOWN
 # RUN: not %lld -undefined error -o /dev/null %t.o 2>&1 | \
 # RUN:     FileCheck %s -check-prefix=ERROR
 
 # RUN: not %lld -undefined warning -o /dev/null %t.o 2>&1 | \
 # RUN:     FileCheck %s -check-prefix=INVAL-WARNING
 # RUN: not %lld -undefined suppress -o /dev/null %t.o 2>&1 | \
 # RUN:     FileCheck %s -check-prefix=INVAL-SUPPRESS
-
-# FIXME: Enable these -undefined checks once -flat_namespace is implemented.
-# RN: %no_fatal_warnings_lld -flat_namespace -undefined warning \
-# RN:     -o /dev/null %t.o 2>&1 | \
-# RN:     FileCheck %s -check-prefix=WARNING
-# RN: %lld -flat_namespace -undefined suppress -o /dev/null %t.o 2>&1 | \
-# RN:     FileCheck %s -check-prefix=SUPPRESS --allow-empty
+# RUN: %lld -undefined dynamic_lookup -lSystem -o %t.out %t.o 2>&1 | \
+# RUN:     FileCheck %s -check-prefix=SUPPRESS --allow-empty
+# RUN: llvm-objdump --macho --lazy-bind %t.out \
+# RUN:     | FileCheck --check-prefix=BIND %s
+
+# RUN: %no_fatal_warnings_lld -lSystem -flat_namespace -undefined warning \
+# RUN:     -o %t.out %t.o 2>&1 | \
+# RUN:     FileCheck %s -check-prefix=WARNING
+# RUN: llvm-objdump --macho --lazy-bind %t.out \
+# RUN:     | FileCheck --check-prefix=BIND %s
+# RUN: %lld -flat_namespace -lSystem -undefined suppress -o %t.out %t.o 2>&1 | \
+# RUN:     FileCheck %s -check-prefix=SUPPRESS --allow-empty
+# RUN: llvm-objdump --macho --lazy-bind %t.out \
+# RUN:     | FileCheck --check-prefix=BIND %s
+# RUN: %lld -flat_namespace -lSystem -undefined dynamic_lookup -o %t.out %t.o 2>&1 | \
+# RUN:     FileCheck %s -check-prefix=SUPPRESS --allow-empty
+# RUN: llvm-objdump --macho --lazy-bind %t.out \
+# RUN:     | FileCheck --check-prefix=BIND %s
 
 # ERROR: error: undefined symbol: _bar
 # ERROR-NEXT: >>> referenced by
 
 # INVAL-WARNING: error: '-undefined warning' only valid with '-flat_namespace'
 # INVAL-WARNING-NEXT: error: undefined symbol: _bar
 
 # INVAL-SUPPRESS: error: '-undefined suppress' only valid with '-flat_namespace'
 # INVAL-SUPPRESS-NEXT: error: undefined symbol: _bar
 
-
 # WARNING: warning: undefined symbol: _bar
 # WARNING-NEXT: >>> referenced by
 
 # SUPPRESS-NOT: undefined symbol: _bar
 
 # UNKNOWN: unknown -undefined TREATMENT 'bogus'
 # UNKNOWN-NEXT: error: undefined symbol: _bar
 # UNKNOWN-NEXT: >>> referenced by
 
+# BIND: Lazy bind table:
+# BIND: __DATA   __la_symbol_ptr    0x{{[0-9a-f]*}} flat-namespace   _bar
+
 .globl _main
 _main:
   callq _bar
   ret