[lld/mac] Make binaries written by lld strippable

[thakis]

Summary

Be less clever when writing the indirect symbols in LC_DYSYMTAB:
lld used to make point stubs and la_symbol_ptr point at the
same bytes in the indirect symbol table in the LINKEDIT segment.
That confused strip, so write the same bytes twice and make
stubs and __la_symbol_ptr point at one copy each, so that they
don't share data. This unconfuses strip, and seems to be what ld64
does too, so hopefully tools are generally more used to this.

This makes the output binaries a bit larger, but not much: 4 bytes
for roughly each called function from a dylib and each weak function.
Chromium Framewoork grows by 6536 bytes, clang-format by a few hundred.

With this, strip -x Chromium\ Framework works (244 MB before stripping
to 171 MB after stripping, compared to 236 MB=>164 MB with ld64). Running
strip without -x produces the same error message now for lld-linked
Chromium Framework as for when using ld64 as a linker.

strip clang-format also works now but didn't previously.

Fixes PR50393 (and PR50657).

[int3]

Thanks for the fix!

lld/MachO/SyntheticSections.cpp

 }
 
 IndirectSymtabSection::IndirectSymtabSection()
     : LinkEditSection(segment_names::linkEdit,
                       section_names::indirectSymbolTable) {}
 
 uint32_t IndirectSymtabSection::getNumSymbols() const {
   return in.got->getEntries().size() + in.tlvPointers->getEntries().size() +
-         in.stubs->getEntries().size();
+         2 * in.stubs->getEntries().size();
 }
 
 bool IndirectSymtabSection::isNeeded() const {
   return in.got->isNeeded() || in.tlvPointers->isNeeded() ||
          in.stubs->isNeeded();
 }
 
 void IndirectSymtabSection::finalizeContents() {
   uint32_t off = 0;
   in.got->reserved1 = off;
   off += in.got->getEntries().size();
   in.tlvPointers->reserved1 = off;
   off += in.tlvPointers->getEntries().size();
-  // There is a 1:1 correspondence between stubs and LazyPointerSection
-  // entries, so they can share the same sub-array in the table.
-  in.stubs->reserved1 = in.lazyPointers->reserved1 = off;
+  in.stubs->reserved1 = off;
+  off += in.stubs->getEntries().size();
+  in.lazyPointers->reserved1 = off;
 }
 
 static uint32_t indirectValue(const Symbol *sym) {
   return sym->symtabIndex != UINT32_MAX ? sym->symtabIndex
                                         : INDIRECT_SYMBOL_LOCAL;
 }
 
 void IndirectSymtabSection::writeTo(uint8_t *buf) const {
   uint32_t off = 0;
   for (const Symbol *sym : in.got->getEntries()) {
     write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
     ++off;
   }
   for (const Symbol *sym : in.tlvPointers->getEntries()) {
     write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
     ++off;
   }
   for (const Symbol *sym : in.stubs->getEntries()) {
     write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
     ++off;
   }
+  // There is a 1:1 correspondence between stubs and LazyPointerSection
+  // entries. But giving __stubs and __la_symbol_ptr the same reserved1
+  // (the offset into the indirect symbol table) so that they both refer
+  // to the same range of offsets confuses `strip`, so write the stubs
+  // symbol table offsets a second time.
+  for (const Symbol *sym : in.stubs->getEntries()) {
+    write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
+    ++off;
+  }
 }
 
 StringTableSection::StringTableSection()
     : LinkEditSection(segment_names::linkEdit, section_names::stringTable) {}
 
 uint32_t StringTableSection::addString(StringRef str) {
   uint32_t strx = size;
   strings.push_back(str); // TODO: consider deduplicating strings

lld/test/MachO/indirect-symtab.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/test.s -o %t/test.o
 # RUN: %lld -dylib %t/libfoo.o -o %t/libfoo.dylib -lSystem
 # RUN: %lld %t/test.o %t/libfoo.dylib -o %t/test -lSystem
 # RUN: llvm-objdump --macho -d --no-show-raw-insn --indirect-symbols %t/test | FileCheck %s
+# RUN: llvm-otool -l %t/test | FileCheck --check-prefix=DYSYMTAB %s
 
 # CHECK:      (__TEXT,__text) section
 # CHECK-NEXT: _main:
 # CHECK-NEXT: movq  {{.*}}(%rip), %rax ## literal pool symbol address: _foo
 # CHECK-NEXT: movq  {{.*}}(%rip), %rax ## literal pool symbol address: _bar
 # CHECK-NEXT: movq  {{.*}}(%rip), %rax ## literal pool symbol address: _foo_tlv
 # CHECK-NEXT: movq  {{.*}}(%rip), %rax ## literal pool symbol address: _bar_tlv
 # CHECK-NEXT: callq {{.*}} ## symbol stub for: _foo_fn

 # CHECK-NEXT: address            index name
 # CHECK-NEXT: _bar_fn
 # CHECK-NEXT: _foo_fn
 # CHECK-NEXT: Indirect symbols for (__DATA,__thread_ptrs) 2 entries
 # CHECK-NEXT: address            index name
 # CHECK-NEXT: _bar_tlv
 # CHECK-NEXT: _foo_tlv
 
+# DYSYMTAB: nindirectsyms 9
+
 #--- libfoo.s
 
 .globl _foo, _foo_fn, _bar, _bar_fn
 _foo:
 _foo_fn:
 _bar:
 _bar_fn: