[lld-macho] Implement --icf=fbsafe that is more similar to ld64's -deduplicate_safe

[int3]

Summary

--icf=safe gives us results that are way too conservative. Ideally
we'd like to fix that, but it's probably non-trivial, and would affect
ELF targets too (since the logic to mark things as address-significant
in MC isn't arch-specific).

As such, this diff implements an approach that is very similar to what
is currently available in ld64.

Test Plan:

lld/MachO/Config.h

enum class UndefinedSymbolTreatment {
   suppress,
   dynamic_lookup,
 };
 
 enum class ICFLevel {
   unknown,
   none,
   safe,
+#if defined(__FACEBOOK__)
+  fbsafe,
+#endif
   all,
 };
 
 enum class ObjCStubsMode {
   fast,
   small,
 };
 

lld/MachO/Driver.cpp

getUndefinedSymbolTreatment(const ArgList &args) {
   return treatment;
 }
 
 static ICFLevel getICFLevel(const ArgList &args) {
   StringRef icfLevelStr = args.getLastArgValue(OPT_icf_eq);
   auto icfLevel = StringSwitch<ICFLevel>(icfLevelStr)
                       .Cases("none", "", ICFLevel::none)
                       .Case("safe", ICFLevel::safe)
+#if defined(__FACEBOOK__)
+                      .Case("fbsafe", ICFLevel::fbsafe)
+#endif
                       .Case("all", ICFLevel::all)
                       .Default(ICFLevel::unknown);
   if (icfLevel == ICFLevel::unknown) {
     warn(Twine("unknown --icf=OPTION `") + icfLevelStr +
          "', defaulting to `none'");
     icfLevel = ICFLevel::none;
   }
   return icfLevel;
if (config->deadStrip)
       markLive();
 
     // ICF assumes that all literals have been folded already, so we must run
     // foldIdenticalLiterals before foldIdenticalSections.
     foldIdenticalLiterals();
     if (config->icfLevel != ICFLevel::none) {
       if (config->icfLevel == ICFLevel::safe)
         markAddrSigSymbols();
+#if defined(__FACEBOOK__)
+      else if (config->icfLevel == ICFLevel::fbsafe)
+        markAddrSigSymbolsViaRelocations();
+#endif
       foldIdenticalSections(/*onlyCfStrings=*/false);
     } else if (config->dedupLiterals) {
       foldIdenticalSections(/*onlyCfStrings=*/true);
     }
 
     // Write to an output file.
     if (target->wordSize == 8)
       writeResult<LP64>();

lld/MachO/ICF.h

 
 namespace lld::macho {
 class Symbol;
 
 void markAddrSigSymbols();
 void markSymAsAddrSig(Symbol *s);
 void foldIdenticalSections(bool onlyCfStrings);
 
+#if defined(__FACEBOOK__)
+// This marks symbols as addrsig not by using `__llvm_addrsig` contents, but by
+// looking for relocations that suggest a given function's address is being
+// taken. This is the approach ld64 takes, and its results are far less
+// conservative than what `-faddrsig` emits. Ideally, we'd like to make
+// `-faddrsig` less conservative and use that, but this is a good temporary
+// solution.
+// NOTE: Only implemented for arm64 targets right now.
+void markAddrSigSymbolsViaRelocations();
+#endif
+
 } // namespace lld::macho
 
 #endif

lld/MachO/ICF.cpp

for (const Reloc &r : isec->relocs) {
       if (auto *sym = r.referent.dyn_cast<Symbol *>())
         markSymAsAddrSig(sym);
       else
         error(toString(isec) + ": unexpected section relocation");
     }
   }
 }
 
+#if defined(__FACEBOOK__)
+void macho::markAddrSigSymbolsViaRelocations() {
+  TimeTraceScope timeScope("Mark addrsig symbols via relocations");
+  assert(target->cpuType == MachO::CPU_TYPE_ARM64);
+  for (ConcatInputSection *isec : inputSections) {
+    for (const Reloc &r : isec->relocs) {
+      if (r.type != MachO::ARM64_RELOC_PAGEOFF12)
+        continue;
+      if (auto *sym = r.referent.dyn_cast<Symbol *>())
+        if (auto *d = dyn_cast<Defined>(sym))
+          if (d->isec && isCodeSection(d->isec) && !d->weakDefCanBeHidden)
+            markSymAsAddrSig(sym);
+    }
+  }
+}
+#endif
+
 void macho::foldIdenticalSections(bool onlyCfStrings) {
   TimeTraceScope timeScope("Fold Identical Code Sections");
   // The ICF equivalence-class segregation algorithm relies on pre-computed
   // hashes of InputSection::data for the ConcatOutputSection::inputs and all
   // sections referenced by their relocs. We could recursively traverse the
   // relocs to find every referenced InputSection, but that precludes easy
   // parallelization. Therefore, we hash every InputSection here where we have
   // them all accessible as simple vectors.

lld/test/FBMachO/icf-fbsafe.s

+# REQUIRES: aarch64
+# RUN: rm -rf %t; split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %t/test.s -o %t/test.o
+# RUN: %lld -lSystem -dylib -arch arm64 %t/test.o -o %t/test --icf=fbsafe
+# RUN: llvm-objdump --macho --syms %t/test | FileCheck %s
+
+# CHECK-DAG: [[#%.16x,NOT_ADDRSIG:]] l     F __TEXT,__text _not_addrsig
+# CHECK-DAG: [[#NOT_ADDRSIG]]        l     F __TEXT,__text _autohide_addrsig
+# CHECK-DAG: [[#NOT_ADDRSIG-4]]      l     F __TEXT,__text _addrsig
+
+#--- test.s
+
+_address_taker:
+  ldr x1, [x1, _addrsig@PAGEOFF]
+  ldr x1, [x1, _autohide_addrsig@PAGEOFF]
+
+_caller:
+  bl _not_addrsig
+
+_addrsig:
+  nop
+
+.globl _autohide_addrsig
+.weak_def_can_be_hidden _autohide_addrsig
+_autohide_addrsig:
+  nop
+
+_not_addrsig:
+  nop
+
+.subsections_via_symbols