[lld/mac] Write every weak symbol only once in the output

[thakis]

Summary

Before this, if an inline function was defined in several input files,
lld would write each copy of the inline function the output. With this
patch, it only writes one copy.

Reduces the size of Chromium Framework from 378MB to 345MB (compared
to 290MB linked with ld64, which also does dead-stripping, which we
don't do yet), and makes linking it faster:

    N           Min           Max        Median           Avg        Stddev
x  10     3.9957051     4.3496981     4.1411121      4.156837    0.10092097
+  10      3.908154      4.169318     3.9712729     3.9846753   0.075773012
Difference at 95.0% confidence
        -0.172162 +/- 0.083847
        -4.14165% +/- 2.01709%
        (Student's t, pooled s = 0.0892373)

Implementation-wise, when merging two weak symbols, this sets a
"canOmitFromOutput" on the InputSection belonging to the weak symbol not put in
the symbol table. We then don't write InputSections that have this set, as long
as they are not referenced from other symbols. (This happens e.g. for object
files that don't set .subsections_via_symbols or that use .alt_entry.)

Some restrictions:

• not yet done for bitcode inputs
• no "comdat" handling (kindNoneGroupSubordinate* in ld64) -- Frame Descriptor Entries (FDEs), Language Specific Data Areas (LSDAs) (that is, catch block unwind information) and Personality Routines associated with weak functions still not stripped. This is wasteful, but harmless.
• However, this does strip weaks from __unwind_info (which is needed for correctness and not just for size)
• This nopes out on InputSections that are referenced form more than one symbol (eg from .alt_entry) for now

Things that work based on symbols Just Work:

• map files (change in MapFile.cpp is no-op and not needed; I just found it a bit more explicit)
• exports

Things that work with inputSections need to explicitly check if
an inputSection is written (e.g. unwind info).

This patch is useful in itself, but it's also likely also a useful foundation
for dead_strip.

I used to have a "canoncialRepresentative" pointer on InputSection instead of
just the bool, which would be handy for ICF too. But I ended up not needing it
for this patch, so I removed that again for now.

[gkm]

LGTM

lld/MachO/InputFiles.cpp

614–615

These are already specified as initial values in the class declaration.

lld/MachO/UnwindInfoSection.cpp

218–219

... or omit entirely.

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

50

[thakis]

Thanks!

lld/MachO/InputFiles.cpp

614–615

This is actually a bit subtle: the creation 3 lines up uses the copy ctor, so we do need to reset to the default here. (This is covered by the test.)

lld/MachO/InputFiles.cpp

for (size_t j = 0; j < symbolIndices.size(); ++j) {
       uint64_t symbolOffset = sym.n_value - subsecAddr;
       uint64_t symbolSize =
           j + 1 < symbolIndices.size()
               ? nList[symbolIndices[j + 1]].n_value - sym.n_value
               : isec->data.size() - symbolOffset;
       // There are 3 cases where we do not need to create a new subsection:
       //   1. If the input file does not use subsections-via-symbols.
       //   2. Multiple symbols at the same address only induce one subsection.
+      //      (The symbolOffset == 0 check covers both this case as well as
+      //      the first loop iteration.)
       //   3. Alternative entry points do not induce new subsections.
       if (!subsectionsViaSymbols || symbolOffset == 0 ||
           sym.n_desc & N_ALT_ENTRY) {
         symbols[symIndex] =
             createDefined(sym, name, isec, symbolOffset, symbolSize);
         continue;
       }
 
       auto *nextIsec = make<InputSection>(*isec);
       nextIsec->data = isec->data.slice(symbolOffset);
+      nextIsec->numRefs = 0;
+      nextIsec->canOmitFromOutput = false;
       isec->data = isec->data.slice(0, symbolOffset);
 
       // By construction, the symbol will be at offset zero in the new
       // subsection.
       symbols[symIndex] =
           createDefined(sym, name, nextIsec, /*value=*/0, symbolSize);
       // TODO: ld64 appears to preserve the original alignment as well as each
       // subsection's offset from the last aligned address. We should consider

lld/MachO/InputSection.h

 #include "llvm/BinaryFormat/MachO.h"
 
 namespace lld {
 namespace macho {
 
 class InputFile;
 class InputSection;
 class OutputSection;
-class Symbol;
-class Defined;
 
 class InputSection {
 public:
   virtual ~InputSection() = default;
   virtual uint64_t getSize() const { return data.size(); }
   virtual uint64_t getFileSize() const;
   uint64_t getFileOffset() const;
   uint64_t getVA() const;
 
   virtual void writeTo(uint8_t *buf);
 
   InputFile *file = nullptr;
   StringRef name;
   StringRef segname;
 
   OutputSection *parent = nullptr;
   uint64_t outSecOff = 0;
   uint64_t outSecFileOff = 0;
 
   uint32_t align = 1;
   uint32_t flags = 0;
 
+  // How many symbols refer to this InputSection.
+  uint32_t numRefs = 0;
+
+  // True if this InputSection could not be written to the output file.
+  // With subsections_via_symbols, most symbol have its own InputSection,
+  // and for weak symbols (e.g. from inline functions), only the
+  // InputSection from one translation unit will make it to the output,
+  // while all copies in other translation units are coalesced into the
+  // first and not copied to the output.
+  bool canOmitFromOutput = false;
+
+  bool shouldOmitFromOutput() const {
+    return canOmitFromOutput && numRefs == 0;
+  }
+
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
 };
 
 inline uint8_t sectionType(uint32_t flags) {
   return flags & llvm::MachO::SECTION_TYPE;
 }
 

lld/MachO/InputSection.cpp

if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
     if (sym.isInGot())
       return in.tlvPointers->addr + sym.gotIndex * target->wordSize;
     assert(isa<Defined>(&sym));
   }
   return sym.getVA();
 }
 
 void InputSection::writeTo(uint8_t *buf) {
+  assert(!shouldOmitFromOutput());
+
   if (getFileSize() == 0)
     return;
 
   memcpy(buf, data.data(), data.size());
 
   for (size_t i = 0; i < relocs.size(); i++) {
     const Reloc &r = relocs[i];
     uint8_t *loc = buf + r.offset;
     uint64_t referentVA = 0;
     if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
       const Symbol *fromSym = r.referent.get<Symbol *>();
       const Reloc &minuend = relocs[++i];
       uint64_t minuendVA;
       if (const Symbol *toSym = minuend.referent.dyn_cast<Symbol *>())
         minuendVA = toSym->getVA();
-      else
-        minuendVA = minuend.referent.get<InputSection *>()->getVA();
+      else {
+        auto *referentIsec = minuend.referent.get<InputSection *>();
+        assert(!referentIsec->shouldOmitFromOutput());
+        minuendVA = referentIsec->getVA();
+      }
       referentVA = minuendVA - fromSym->getVA() + minuend.addend;
     } else if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
       if (target->hasAttr(r.type, RelocAttrBits::LOAD) &&
           !referentSym->isInGot())
         target->relaxGotLoad(loc, r.type);
       referentVA = resolveSymbolVA(loc, *referentSym, r.type);
 
       if (isThreadLocalVariables(flags)) {
         // References from thread-local variable sections are treated as offsets
         // relative to the start of the thread-local data memory area, which
         // is initialized via copying all the TLV data sections (which are all
         // contiguous).
         if (isa<Defined>(referentSym))
           referentVA -= firstTLVDataSection->addr;
       }
     } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
+      assert(!referentIsec->shouldOmitFromOutput());
       referentVA = referentIsec->getVA();
     }
     target->relocateOne(loc, r, referentVA + r.addend, getVA() + r.offset);
   }
 }
 
 bool macho::isCodeSection(InputSection *isec) {
   uint32_t type = isec->flags & SECTION_TYPE;

lld/MachO/MapFile.cpp

 static std::vector<Defined *> getSymbols() {
   std::vector<Defined *> v;
   for (InputFile *file : inputFiles)
     if (isa<ObjFile>(file))
       for (Symbol *sym : file->symbols) {
         if (sym == nullptr)
           continue;
         if (auto *d = dyn_cast<Defined>(sym))
-          if (d->isec && d->getFile() == file)
+          if (d->isec && d->getFile() == file) {
+            assert(!d->isec->shouldOmitFromOutput() &&
+                   "file->symbols should store resolved symbols");
             v.push_back(d);
           }
+      }
   return v;
 }
 
 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
 static DenseMap<Symbol *, std::string>
 getSymbolStrings(ArrayRef<Defined *> syms) {
for (OutputSection *osec : seg->getSections()) {
       os << format("0x%08llX\t0x%08llX\t%s\t%s\n", osec->addr, osec->getSize(),
                    seg->name.str().c_str(), osec->name.str().c_str());
     }
 
   // Dump table of symbols
   os << "# Symbols:\n";
   os << "# Address\t    File  Name\n";
   for (InputSection *isec : inputSections) {
-    for (Symbol *sym : sectionSyms[isec]) {
+    auto symsIt = sectionSyms.find(isec);
+    assert(!isec->shouldOmitFromOutput() || (symsIt == sectionSyms.end()));
+    if (symsIt == sectionSyms.end())
+      continue;
+    for (Symbol *sym : symsIt->second) {
       os << format("0x%08llX\t[%3u] %s\n", sym->getVA(),
                    readerToFileOrdinal[sym->getFile()], symStr[sym].c_str());
     }
   }
 
   // TODO: when we implement -dead_strip, we should dump dead stripped symbols
 }

lld/MachO/SymbolTable.cpp

Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
                                  InputSection *isec, uint64_t value,
                                  uint64_t size, bool isWeakDef,
                                  bool isPrivateExtern, bool isThumb) {
   Symbol *s;
   bool wasInserted;
   bool overridesWeakDef = false;
   std::tie(s, wasInserted) = insert(name, file);
 
+  assert(!isWeakDef || (isa<BitcodeFile>(file) && !isec) ||
+         (isa<ObjFile>(file) && file == isec->file));
+
   if (!wasInserted) {
     if (auto *defined = dyn_cast<Defined>(s)) {
       if (isWeakDef) {
         // Both old and new symbol weak (e.g. inline function in two TUs):
         // If one of them isn't private extern, the merged symbol isn't.
-        if (defined->isWeakDef())
+        if (defined->isWeakDef()) {
           defined->privateExtern &= isPrivateExtern;
+
+          // FIXME: Handle this for bitcode files.
+          // FIXME: We currently only do this if both symbols are weak.
+          //        We could do this if either is weak (but getting the
+          //        case where !isWeakDef && defined->isWeakDef() right
+          //        requires some care and testing).
+          if (isec)
+            isec->canOmitFromOutput = true;
+        }
+
         return defined;
       }
       if (!defined->isWeakDef())
         error("duplicate symbol: " + name + "\n>>> defined in " +
               toString(defined->getFile()) + "\n>>> defined in " +
               toString(file));
     } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
       overridesWeakDef = !isWeakDef && dysym->isWeakDef();

lld/MachO/Symbols.h

 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputFile *file, InputSection *isec, uint64_t value,
           uint64_t size, bool isWeakDef, bool isExternal, bool isPrivateExtern,
           bool isThumb)
       : Symbol(DefinedKind, name, file), isec(isec), value(value), size(size),
         overridesWeakDef(false), privateExtern(isPrivateExtern),
         includeInSymtab(true), thumb(isThumb), weakDef(isWeakDef),
-        external(isExternal) {}
+        external(isExternal) {
+    if (isec)
+      isec->numRefs++;
+  }
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
   }
   bool isTlv() const override {
     return !isAbsolute() && isThreadLocalVariables(isec->flags);
   }

lld/MachO/UnwindInfoSection.cpp

 // separate code path from regular relocations. First, we do not wish to add
 // rebase opcodes for __LD,__compact_unwind, because that section doesn't
 // actually end up in the final binary. Second, personality pointers always
 // reside in the GOT and must be treated specially.
 template <class Ptr>
 void UnwindInfoSectionImpl<Ptr>::prepareRelocations(InputSection *isec) {
   assert(isec->segname == segment_names::ld &&
          isec->name == section_names::compactUnwind);
+  assert(!isec->shouldOmitFromOutput() &&
+         "__compact_unwind section should not be omitted");
 
   for (Reloc &r : isec->relocs) {
     assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
     if (r.offset % sizeof(CompactUnwindEntry<Ptr>) !=
         offsetof(CompactUnwindEntry<Ptr>, personality))
       continue;
 
     if (auto *s = r.referent.dyn_cast<Symbol *>()) {
if (auto *s = r.referent.dyn_cast<Symbol *>()) {
         continue;
       }
       assert(isa<DylibSymbol>(s));
       in.got->addEntry(s);
       continue;
     }
 
     if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
+      assert(!referentIsec->shouldOmitFromOutput());
+
       // Personality functions can be referenced via section relocations
       // if they live in the same object file. Create placeholder synthetic
       // symbols for them in the GOT.
       Symbol *&s = personalityTable[{referentIsec, r.addend}];
       if (s == nullptr) {
         s = make<Defined>("<internal>", /*file=*/nullptr, referentIsec,
                           r.addend, /*size=*/0, /*isWeakDef=*/false,
                           /*isExternal=*/false, /*isPrivateExtern=*/false,

 // before converting it to post-link form. There should only be absolute
 // relocations here: since we are not emitting the pre-link CU section, there
 // is no source address to make a relative location meaningful.
 template <class Ptr>
 static void
 relocateCompactUnwind(MergedOutputSection *compactUnwindSection,
                       std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
   for (const InputSection *isec : compactUnwindSection->inputs) {
+    assert(isec->parent == compactUnwindSection);
+
     uint8_t *buf =
         reinterpret_cast<uint8_t *>(cuVector.data()) + isec->outSecFileOff;
     memcpy(buf, isec->data.data(), isec->data.size());
 
     for (const Reloc &r : isec->relocs) {
       uint64_t referentVA = 0;
       if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
         if (!isa<Undefined>(referentSym)) {
           assert(referentSym->isInGot());
           if (auto *defined = dyn_cast<Defined>(referentSym))
             checkTextSegment(defined->isec);
           // At this point in the link, we may not yet know the final address of
           // the GOT, so we just encode the index. We make it a 1-based index so
           // that we can distinguish the null pointer case.
           referentVA = referentSym->gotIndex + 1;
         }
       } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
         checkTextSegment(referentIsec);
+        if (referentIsec->shouldOmitFromOutput())
+          referentVA = UINT64_MAX; // Tombstone value
+        else
           referentVA = referentIsec->getVA() + r.addend;
       }
 
       writeAddress(buf + r.offset, referentVA, r.length);
     }
   }
 }
 
 // There should only be a handful of unique personality pointers, so we can
template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
   cuPtrVector.reserve(cuCount);
   for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
     cuPtrVector.emplace_back(&cuEntry);
   llvm::sort(cuPtrVector, [](const CompactUnwindEntry<Ptr> *a,
                              const CompactUnwindEntry<Ptr> *b) {
     return a->functionAddress < b->functionAddress;
   });
 
+  // Dead-stripped functions get a functionAddress of UINT64_MAX in
+  // relocateCompactUnwind(). Filter them out here.
+  CompactUnwindEntry<Ptr> tombstone;
+  tombstone.functionAddress = static_cast<Ptr>(UINT64_MAX);
+  cuPtrVector.erase(
+      std::lower_bound(cuPtrVector.begin(), cuPtrVector.end(), &tombstone,
+                       [](const CompactUnwindEntry<Ptr> *a,
+                          const CompactUnwindEntry<Ptr> *b) {
+                         return a->functionAddress < b->functionAddress;
+                       }),
+      cuPtrVector.end());
+
   // Fold adjacent entries with matching encoding+personality+lsda
   // We use three iterators on the same cuPtrVector to fold in-situ:
   // (1) `foldBegin` is the first of a potential sequence of matching entries
   // (2) `foldEnd` is the first non-matching entry after `foldBegin`.
   // The semi-open interval [ foldBegin .. foldEnd ) contains a range
   // entries that can be folded into a single entry and written to ...
   // (3) `foldWrite`
   auto foldWrite = cuPtrVector.begin();

lld/MachO/Writer.cpp

if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
     if (!(isThreadLocalVariables(isec->flags) && isa<Defined>(sym)))
       addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
   }
 }
 
 void Writer::scanRelocations() {
   TimeTraceScope timeScope("Scan relocations");
   for (InputSection *isec : inputSections) {
+    if (isec->shouldOmitFromOutput())
+      continue;
+
     if (isec->segname == segment_names::ld) {
       in.unwindInfo->prepareRelocations(isec);
       continue;
     }
 
     for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
       Reloc &r = *it;
       if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
         // Skip over the following UNSIGNED relocation -- it's just there as the
         // minuend, and doesn't have the usual UNSIGNED semantics. We don't want
         // to emit rebase opcodes for it.
-        it = std::next(it);
+        it++;
         continue;
       }
       if (auto *sym = r.referent.dyn_cast<Symbol *>()) {
         if (auto *undefined = dyn_cast<Undefined>(sym))
           treatUndefinedSymbol(*undefined);
         // treatUndefinedSymbol() can replace sym with a DylibSymbol; re-check.
         if (!isa<Undefined>(sym) && validateSymbolRelocation(sym, isec, r))
           prepareSymbolRelocation(sym, isec, r);
       } else {
         assert(r.referent.is<InputSection *>());
+        assert(!r.referent.get<InputSection *>()->shouldOmitFromOutput());
         if (!r.pcrel)
           in.rebase->addEntry(isec, r.offset);
       }
     }
   }
 }
 
 void Writer::scanSymbols() {
case MH_BUNDLE:
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
   // Then merge input sections into output sections.
   MapVector<NamePair, MergedOutputSection *> mergedOutputSections;
   for (InputSection *isec : inputSections) {
+    if (isec->shouldOmitFromOutput())
+      continue;
     NamePair names = maybeRenameSection({isec->segname, isec->name});
     MergedOutputSection *&osec = mergedOutputSections[names];
     if (osec == nullptr)
       osec = make<MergedOutputSection>(names.second);
     osec->mergeInput(isec);
   }
 
   for (const auto &it : mergedOutputSections) {

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

+# REQUIRES: x86
+# RUN: rm -rf %t; split-file %s %t
+
+## This tests that if two input files define the same weak symbol, we only
+## write it to the output once (...assuming both input files use
+## .subsections_via_symbols).
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/weak-sub.s -o %t/weak-sub.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/weak-nosub.s -o %t/weak-nosub.o
+
+## Test that weak symbols are emitted just once with .subsections_via_symbols
+# RUN: %lld -dylib -o %t/out.dylib %t/weak-sub.o %t/weak-sub.o
+# RUN: llvm-otool -jtV %t/out.dylib | FileCheck --check-prefix=SUB %s
+# RUN: %lld -dylib -o %t/out.dylib %t/weak-nosub.o %t/weak-sub.o
+# RUN: llvm-otool -jtV %t/out.dylib | FileCheck --check-prefix=SUB %s
+# RUN: %lld -dylib -o %t/out.dylib %t/weak-sub.o %t/weak-nosub.o
+# RUN: llvm-otool -jtV %t/out.dylib | FileCheck --check-prefix=SUB %s
+# SUB:      _foo
+# SUB-NEXT: retq
+# SUB-NOT:  retq
+# SUB:      _bar
+# SUB-NEXT: retq
+# SUB-NOT:  retq
+
+## We can even strip weak symbols without subsections_via_symbols as long
+## as none of the weak symbols in a section are needed.
+# RUN: %lld -dylib -o %t/out.dylib %t/weak-nosub.o %t/weak-nosub.o
+# RUN: llvm-otool -jtV %t/out.dylib | FileCheck --check-prefix=SUB %s
+
+## Test that omitted weak symbols don't add entries to the compact unwind table.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/weak-sub-lsda.s -o %t/weak-sub-lsda.o
+# RUN: %lld -dylib -lc++ -o %t/out.dylib %t/weak-sub-lsda.o %t/weak-sub-lsda.o
+# RUN: llvm-objdump --macho --unwind-info --syms %t/out.dylib | FileCheck %s --check-prefix=UNWIND -D#%x,BASE=0
+
+# UNWIND:      SYMBOL TABLE:
+# UNWIND-DAG:  [[#%x,FOO:]]       w  F __TEXT,__text _foo
+# UNWIND-NOT:                          __TEXT,__text _foo
+
+# UNWIND:      Contents of __unwind_info section:
+# UNWIND:        LSDA descriptors:
+# UNWIND:           [0]: function offset=0x[[#%.8x,FOO-BASE]]
+# UNWIND-NOT:       [1]:
+# UNWIND:        Second level indices:
+# UNWIND-DAG:      [0]: function offset=0x[[#%.8x,FOO-BASE]]
+# UNWIND-NOT:      [1]:
+
+## Test interaction with .alt_entry
+## FIXME: ld64 manages to strip both one copy of _foo and _bar each.
+##        We only manage this if we're lucky and the object files are in
+##        the right order. We're happy to not crash at link time for now.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/weak-sub-alt.s -o %t/weak-sub-alt.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/weak-sub-alt2.s -o %t/weak-sub-alt2.o
+# RUN: %lld -dylib -o %t/out.dylib %t/weak-sub-alt.o %t/weak-sub-alt2.o
+# RUN: %lld -dylib -o %t/out.dylib %t/weak-sub-alt2.o %t/weak-sub-alt.o
+
+#--- weak-sub.s
+.globl _foo, _bar
+.weak_definition _foo, _bar
+_foo:
+  retq
+_bar:
+  retq
+.subsections_via_symbols
+
+#--- weak-nosub.s
+.globl _foo, _bar
+.weak_definition _foo, _bar
+_foo:
+  retq
+_bar:
+  retq
+
+#--- weak-sub-lsda.s
+.section __TEXT,__text,regular,pure_instructions
+
+.globl _foo
+.weak_definition _foo
+_foo:
+  .cfi_startproc
+  .cfi_personality 155, ___gxx_personality_v0
+  .cfi_lsda 16, Lexception
+  pushq %rbp
+  .cfi_def_cfa_offset 128
+  .cfi_offset %rbp, 48
+  movq %rsp, %rbp
+  .cfi_def_cfa_register %rbp
+  popq %rbp
+  retq
+  .cfi_endproc
+
+.section __TEXT,__gcc_except_tab
+Lexception:
+    .space 0x10
+
+.subsections_via_symbols
+
+#--- weak-sub-alt.s
+.globl _foo, _bar
+.weak_definition _foo
+_foo:
+  retq
+
+# Alternative entry point to _foo (strong)
+.alt_entry _bar
+_bar:
+  retq
+
+.globl _main, _ref
+_main:
+  callq _ref
+  callq _bar
+
+.subsections_via_symbols
+
+#--- weak-sub-alt2.s
+.globl _foo, _bar
+.weak_definition _foo
+_foo:
+  retq
+
+# Alternative entry point to _foo (weak)
+.weak_definition _bar
+.alt_entry _bar
+_bar:
+  retq
+
+.globl _ref
+_ref:
+  callq _bar
+
+.subsections_via_symbols