[lld-macho] Associate compact unwind entries with function symbols

[int3]

Summary

Compact unwind entries (CUEs) contain pointers to their respective
function symbols. However, during the link process, it's far more useful
to have pointers from the function symbol to the CUE than vice versa.
This diff adds that pointer in the form of Defined::compactUnwind.

In particular, when doing dead-stripping, we want to mark CUEs live when
their function symbol is live; and when doing ICF, we want to dedup
sections iff the symbols in that section have identical CUEs. In both
cases, we want to be able to locate the symbols within a given section,
as well as locate the CUEs belonging to those symbols. So this diff also
adds InputSection::symbols.

The ultimate goal of this refactor is to have ICF support dedup'ing
functions with unwind info, but that will be handled in subsequent
diffs. This diff focuses on simplifying -dead_strip --
findFunctionsWithUnwindInfo is no longer necessary, and
Defined::isLive() is now a lot simpler. Moreover, UnwindInfoSection no
longer has to check for dead CUEs -- we simply avoid adding them in the
first place.

Additionally, we now support stripping of dead LSDAs, which follows
quite naturally since markLive() can now reach them via the CUEs.

[int3]

edit comment

[gkm]

LGTM! Thank you for this. It makes __eh_frame handling much nicer too.
Please fix test failure for MachO/compact-unwind-both-local-and-dylib-personality.s.

lld/MachO/InputSection.cpp

104–107

Nit: According to LLVM Coding Standards, if one body of an if/else chain has braces, then all should have them.

lld/MachO/Writer.cpp

690–695

Nit: LLVM Coding Standards wants braces when nested statements are more than 2 deep, though there is no clear guidance about where to put them here. My suggestion is around the for bodies.

[int3]

fix test + style

[int3]

@oontvoo want to have a look at the changes to compact-unwind-both-local-and-dylib-personality.s before I land it?

lld/test/MachO/compact-unwind-both-local-and-dylib-personality.s

42–45

It seems that in the case of b.out, we don't emit this extra local binding. I haven't dug into why but I think it should be safe since that binding wasn't being used anyway

42–46

I removed the -DAG part here because it seems we are actually relying on the local symbols matching in exactly that order

[oontvoo]

lld/MachO/Writer.cpp

693

Why is dyn_cast used in 691 but dyn_cast_or_null here? (seems like the same use case to me )

lld/test/MachO/compact-unwind-both-local-and-dylib-personality.s

42–45

This is probably fine.
(See also https://reviews.llvm.org/D111852#inline-1066410)

42–46

Any guarantee that the LOCALs will get printed after non-locals?

While it's true that we rely on the partial order (ie., amongst the LOCALs and amongst the __gxx_personaliys ) but I wasn't sure we could rely on the ordering overall being deterministic

[oontvoo]

lld/MachO/InputSection.cpp

119

do you want to assert the two compactUnwind's are actually the same first?

[int3]

lld/MachO/InputSection.cpp

119

in general the compactUnwinds won't have pointer equality, and doing a recursive comparison here seems like too much work

lld/MachO/Writer.cpp

693

because sym can be null here. See ObjFile::parseSymbols -- not even index in the symbols array gets initialized.

lld/test/MachO/compact-unwind-both-local-and-dylib-personality.s

42–46

No guarantee per se -- i.e. it *could* change -- that's just how it's currently implemented. But yes the behavior should be deterministic (and if not it's a bug).

lld/MachO/ConcatOutputSection.cpp

for (Reloc &r : reverse(relocs)) {
 
       StringRef thunkName = saver.save(funcSym->getName() + ".thunk." +
                                        std::to_string(thunkInfo.sequence++));
       r.referent = thunkInfo.sym = symtab->addDefined(
           thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0,
           /*size=*/thunkSize, /*isWeakDef=*/false, /*isPrivateExtern=*/true,
           /*isThumb=*/false, /*isReferencedDynamically=*/false,
           /*noDeadStrip=*/false);
+      thunkInfo.sym->used = true;
       target->populateThunk(thunkInfo.isec, funcSym);
       finalizeOne(thunkInfo.isec);
       thunks.push_back(thunkInfo.isec);
       ++thunkCount;
     }
   }
   size = isecAddr - addr;
   fileSize = isecFileOff - fileOff;

lld/MachO/Driver.cpp

for (const InputFile *file : inputFiles) {
     for (const SubsectionMap &map : file->subsections) {
       ConcatOutputSection *osec = nullptr;
       for (const SubsectionEntry &entry : map) {
         if (auto *isec = dyn_cast<ConcatInputSection>(entry.isec)) {
           if (isec->isCoalescedWeak())
             continue;
           if (isec->getSegName() == segment_names::ld) {
             assert(isec->getName() == section_names::compactUnwind);
-            in.unwindInfo->addInput(isec);
             continue;
           }
           isec->outSecOff = inputOrder++;
           if (!osec)
             osec = ConcatOutputSection::getOrCreateForInput(isec);
           isec->parent = osec;
           inputSections.push_back(isec);
         } else if (auto *isec = dyn_cast<CStringInputSection>(entry.isec)) {

lld/MachO/ICF.cpp

while (begin < end) {
     // If we created a group, we need to iterate the main loop again.
     if (mid != end)
       icfRepeat = true;
 
     begin = mid;
   }
 }
 
-template <class Ptr>
-DenseSet<const InputSection *> findFunctionsWithUnwindInfo() {
-  DenseSet<const InputSection *> result;
-  for (ConcatInputSection *isec : in.unwindInfo->getInputs()) {
-    for (size_t i = 0; i < isec->relocs.size(); ++i) {
-      Reloc &r = isec->relocs[i];
-      assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
-      if (r.offset % sizeof(CompactUnwindEntry<Ptr>) !=
-          offsetof(CompactUnwindEntry<Ptr>, functionAddress))
-        continue;
-      result.insert(r.referent.get<InputSection *>());
-    }
-  }
-  return result;
-}
-
 void macho::foldIdenticalSections() {
   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.
 
-  // ICF can't fold functions with unwind info
-  DenseSet<const InputSection *> functionsWithUnwindInfo =
-      target->wordSize == 8 ? findFunctionsWithUnwindInfo<uint64_t>()
-                            : findFunctionsWithUnwindInfo<uint32_t>();
-
   // If an InputSection is ineligible for ICF, we give it a unique ID to force
   // it into an unfoldable singleton equivalence class.  Begin the unique-ID
   // space at inputSections.size(), so that it will never intersect with
   // equivalence-class IDs which begin at 0. Since hashes & unique IDs never
   // coexist with equivalence-class IDs, this is not necessary, but might help
   // someone keep the numbers straight in case we ever need to debug the
   // ICF::segregate()
   std::vector<ConcatInputSection *> hashable;
   uint64_t icfUniqueID = inputSections.size();
   for (ConcatInputSection *isec : inputSections) {
     // FIXME: consider non-code __text sections as hashable?
     bool isHashable = (isCodeSection(isec) || isCfStringSection(isec)) &&
-                      !isec->shouldOmitFromOutput() &&
-                      !functionsWithUnwindInfo.contains(isec) &&
-                      isec->isHashableForICF();
+                      !isec->shouldOmitFromOutput() && isec->isHashableForICF();
+    // ICF can't fold functions with unwind info
+    if (isHashable)
+      for (Defined *d : isec->symbols)
+        if (d->compactUnwind) {
+          isHashable = false;
+          break;
+        }
+
     if (isHashable)
       hashable.push_back(isec);
     else
       isec->icfEqClass[0] = ++icfUniqueID;
   }
   parallelForEach(hashable,
                   [](ConcatInputSection *isec) { isec->hashForICF(); });
   // Now that every input section is either hashed or marked as unique, run the
   // segregation algorithm to detect foldable subsections.
   ICF(hashable).run();
 }

lld/MachO/InputFiles.h

void parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                     bool subsectionsViaSymbols);
   template <class NList>
   Symbol *parseNonSectionSymbol(const NList &sym, StringRef name);
   template <class Section>
   void parseRelocations(ArrayRef<Section> sectionHeaders, const Section &,
                         SubsectionMap &);
   void parseDebugInfo();
   void parseDataInCode();
+  void registerCompactUnwind();
 };
 
 // command-line -sectcreate file
 class OpaqueFile final : public InputFile {
 public:
   OpaqueFile(MemoryBufferRef mb, StringRef segName, StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };

lld/MachO/InputFiles.cpp

 // Some sections comprise of fixed-size records, so instead of splitting them at
 // symbol boundaries, we split them based on size. Records are distinct from
 // literals in that they may contain references to other sections, instead of
 // being leaf nodes in the InputSection graph.
 //
 // Note that "record" is a term I came up with. In contrast, "literal" is a term
 // used by the Mach-O format.
 static Optional<size_t> getRecordSize(StringRef segname, StringRef name) {
-  if (name == section_names::cfString)
+  if (name == section_names::cfString) {
     if (config->icfLevel != ICFLevel::none && segname == segment_names::data)
       return target->wordSize == 8 ? 32 : 16;
+  } else if (name == section_names::compactUnwind) {
+    if (segname == segment_names::ld)
+      return target->wordSize == 8 ? 32 : 20;
+  }
   return {};
 }
 
 template <class Section>
 void ObjFile::parseSections(ArrayRef<Section> sections) {
   subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
if (sym.n_type & N_EXT) {
     if (isWeakDefCanBeHidden)
       isPrivateExtern = true;
 
     return symtab->addDefined(
         name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
         isPrivateExtern, sym.n_desc & N_ARM_THUMB_DEF,
         sym.n_desc & REFERENCED_DYNAMICALLY, sym.n_desc & N_NO_DEAD_STRIP);
   }
-
   assert(!isWeakDefCanBeHidden &&
          "weak_def_can_be_hidden on already-hidden symbol?");
   return make<Defined>(
       name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
       /*isExternal=*/false, /*isPrivateExtern=*/false,
       sym.n_desc & N_ARM_THUMB_DEF, sym.n_desc & REFERENCED_DYNAMICALLY,
       sym.n_desc & N_NO_DEAD_STRIP);
 }
for (size_t i = 0; i < subsections.size(); ++i) {
     SubsectionMap &subsecMap = subsections[i];
     if (subsecMap.empty())
       continue;
 
     std::vector<uint32_t> &symbolIndices = symbolsBySection[i];
     uint64_t sectionAddr = sectionHeaders[i].addr;
     uint32_t sectionAlign = 1u << sectionHeaders[i].align;
 
-    InputSection *isec = subsecMap.back().isec;
-    // __cfstring has already been split into subsections during
+    InputSection *lastIsec = subsecMap.back().isec;
+    // Record-based sections have already been split into subsections during
     // parseSections(), so we simply need to match Symbols to the corresponding
     // subsection here.
-    if (config->icfLevel != ICFLevel::none && isCfStringSection(isec)) {
+    if (getRecordSize(lastIsec->getSegName(), lastIsec->getName())) {
       for (size_t j = 0; j < symbolIndices.size(); ++j) {
         uint32_t symIndex = symbolIndices[j];
         const NList &sym = nList[symIndex];
         StringRef name = strtab + sym.n_strx;
         uint64_t symbolOffset = sym.n_value - sectionAddr;
         InputSection *isec = findContainingSubsection(subsecMap, &symbolOffset);
         if (symbolOffset != 0) {
-          error(toString(this) + ": __cfstring contains symbol " + name +
+          error(toString(lastIsec) + ":  symbol " + name +
                 " at misaligned offset");
           continue;
         }
         symbols[symIndex] = createDefined(sym, name, isec, 0, isec->getSize());
       }
       continue;
     }
 
for (size_t j = 0; j < symbolIndices.size(); ++j) {
           sym.n_desc & N_ALT_ENTRY || !isa<ConcatInputSection>(isec)) {
         symbols[symIndex] =
             createDefined(sym, name, isec, symbolOffset, symbolSize);
         continue;
       }
       auto *concatIsec = cast<ConcatInputSection>(isec);
 
       auto *nextIsec = make<ConcatInputSection>(*concatIsec);
-      nextIsec->numRefs = 0;
       nextIsec->wasCoalesced = false;
       if (isZeroFill(isec->getFlags())) {
         // Zero-fill sections have NULL data.data() non-zero data.size()
         nextIsec->data = {nullptr, isec->data.size() - symbolOffset};
         isec->data = {nullptr, symbolOffset};
       } else {
         nextIsec->data = isec->data.slice(symbolOffset);
         isec->data = isec->data.slice(0, symbolOffset);
template <class LP> void ObjFile::parse() {
   // parsed all the symbols.
   for (size_t i = 0, n = subsections.size(); i < n; ++i)
     if (!subsections[i].empty())
       parseRelocations(sectionHeaders, sectionHeaders[i], subsections[i]);
 
   parseDebugInfo();
   if (config->emitDataInCodeInfo)
     parseDataInCode();
+  registerCompactUnwind();
 }
 
 void ObjFile::parseDebugInfo() {
   std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
   if (!dObj)
     return;
 
   auto *ctx = make<DWARFContext>(
dataInCodeEntries = {
       reinterpret_cast<const data_in_code_entry *>(buf + c->dataoff),
       c->datasize / sizeof(data_in_code_entry)};
   assert(is_sorted(dataInCodeEntries, [](const data_in_code_entry &lhs,
                                          const data_in_code_entry &rhs) {
     return lhs.offset < rhs.offset;
   }));
 }
 
+// Create pointers from symbols to their associated compact unwind entries.
+void ObjFile::registerCompactUnwind() {
+  // First, locate the __compact_unwind section.
+  SubsectionMap *cuSubsecMap = nullptr;
+  for (SubsectionMap &map : subsections) {
+    if (map.empty())
+      continue;
+    if (map[0].isec->getSegName() != segment_names::ld)
+      continue;
+    cuSubsecMap = &map;
+    break;
+  }
+  if (!cuSubsecMap)
+    return;
+
+  for (SubsectionEntry &entry : *cuSubsecMap) {
+    ConcatInputSection *isec = cast<ConcatInputSection>(entry.isec);
+    ConcatInputSection *referentIsec;
+    for (const Reloc &r : isec->relocs) {
+      if (r.offset != 0)
+        continue;
+      uint64_t add = r.addend;
+      if (auto *sym = cast_or_null<Defined>(r.referent.dyn_cast<Symbol *>())) {
+        add += sym->value;
+        referentIsec = cast<ConcatInputSection>(sym->isec);
+      } else {
+        referentIsec =
+            cast<ConcatInputSection>(r.referent.dyn_cast<InputSection *>());
+      }
+      // The functionAddress relocations are typically section relocations.
+      // However, unwind info operates on a per-symbol basis, so we search for
+      // the function symbol here.
+      auto it = llvm::lower_bound(
+          referentIsec->symbols, add,
+          [](Defined *d, uint64_t add) { return d->value < add; });
+      // The relocation should point at the exact address of a symbol (with no
+      // addend).
+      if (it == referentIsec->symbols.end() || (*it)->value != add) {
+        assert(referentIsec->wasCoalesced);
+        continue;
+      }
+      (*it)->compactUnwind = isec;
+    }
+  }
+}
+
 // The path can point to either a dylib or a .tbd file.
 static DylibFile *loadDylib(StringRef path, DylibFile *umbrella) {
   Optional<MemoryBufferRef> mbref = readFile(path);
   if (!mbref) {
     error("could not read dylib file at " + path);
     return nullptr;
   }
   return loadDylib(*mbref, umbrella);

lld/MachO/InputSection.h

 //===- InputSection.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_INPUT_SECTION_H
 #define LLD_MACHO_INPUT_SECTION_H
 
 #include "Config.h"
 #include "Relocations.h"
+#include "Symbols.h"
 
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/CachedHashString.h"
+#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/BinaryFormat/MachO.h"
 
 namespace lld {
 namespace macho {
 
 class InputFile;
 class OutputSection;
-class Defined;
 
 class InputSection {
 public:
   enum Kind {
     ConcatKind,
     CStringLiteralKind,
     WordLiteralKind,
   };
public:
 
   uint32_t align = 1;
   uint32_t callSiteCount : 31;
   // is address assigned?
   uint32_t isFinal : 1;
 
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
+  // The symbols that belong to this InputSection, sorted by value. With
+  // .subsections_via_symbols, there is typically only one element here.
+  llvm::TinyPtrVector<Defined *> symbols;
 
 protected:
   // The fields in this struct are immutable. Since we create a lot of
   // InputSections with identical values for them (due to
   // .subsections_via_symbols), factoring them out into a shared struct reduces
   // memory consumption and makes copying cheaper.
   struct Shared {
     InputFile *file;
     StringRef name;
     StringRef segname;
     uint32_t flags;
     Kind sectionKind;
     Shared(InputFile *file, StringRef name, StringRef segname, uint32_t flags,
            Kind kind)
         : file(file), name(name), segname(segname), flags(flags),
           sectionKind(kind) {}
   };
 
   InputSection(Kind kind, StringRef segname, StringRef name, InputFile *file,
                ArrayRef<uint8_t> data, uint32_t align, uint32_t flags)
       : align(align), callSiteCount(0), isFinal(false), data(data),
         shared(make<Shared>(file, name, segname, flags, kind)) {}
 
+  InputSection(const InputSection &rhs)
+      : align(rhs.align), callSiteCount(0), isFinal(false), data(rhs.data),
+        shared(rhs.shared) {}
+
   const Shared *const shared;
 };
 
 // ConcatInputSections are combined into (Concat)OutputSections through simple
 // concatenation, in contrast with literal sections which may have their
 // contents merged before output.
 class ConcatInputSection final : public InputSection {
 public:
   ConcatInputSection(StringRef segname, StringRef name, InputFile *file,
                      ArrayRef<uint8_t> data, uint32_t align = 1,
                      uint32_t flags = 0)
       : InputSection(ConcatKind, segname, name, file, data, align, flags) {}
 
   ConcatInputSection(StringRef segname, StringRef name)
       : ConcatInputSection(segname, name, /*file=*/nullptr,
                            /*data=*/{},
                            /*align=*/1, /*flags=*/0) {}
 
   uint64_t getOffset(uint64_t off) const override { return outSecOff + off; }
   uint64_t getVA() const { return InputSection::getVA(0); }
   // ConcatInputSections are entirely live or dead, so the offset is irrelevant.
   bool isLive(uint64_t off) const override { return live; }
   void markLive(uint64_t off) override { live = true; }
-  bool isCoalescedWeak() const { return wasCoalesced && numRefs == 0; }
+  bool isCoalescedWeak() const { return wasCoalesced && symbols.size() == 0; }
   bool shouldOmitFromOutput() const { return !live || isCoalescedWeak(); }
   bool isHashableForICF() const;
   void hashForICF();
   void writeTo(uint8_t *buf);
 
   void foldIdentical(ConcatInputSection *redundant);
   InputSection *canonical() override {
     return replacement ? replacement : this;
public:
 
   // With subsections_via_symbols, most symbols have their 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 wasCoalesced = false;
   bool live = !config->deadStrip;
-  // How many symbols refer to this InputSection.
-  uint32_t numRefs = 0;
   // This variable has two usages. Initially, it represents the input order.
   // After assignAddresses is called, it represents the offset from the
   // beginning of the output section this section was assigned to.
   uint64_t outSecOff = 0;
 };
 
 // Verify ConcatInputSection's size on 64-bit builds.
 static_assert(sizeof(int) != 8 || sizeof(ConcatInputSection) == 112,

lld/MachO/InputSection.cpp

void ConcatInputSection::hashForICF() {
   // with the small-integer unique IDs for ICF-ineligible sections
   icfEqClass[0] = xxHash64(data) | (1ull << 63);
 }
 
 void ConcatInputSection::foldIdentical(ConcatInputSection *copy) {
   align = std::max(align, copy->align);
   copy->live = false;
   copy->wasCoalesced = true;
-  numRefs += copy->numRefs;
-  copy->numRefs = 0;
   copy->replacement = this;
+
+  // Merge the sorted vectors of symbols together.
+  auto it = symbols.begin();
+  for (auto copyIt = copy->symbols.begin(); copyIt != copy->symbols.end();) {
+    if (it == symbols.end()) {
+      symbols.push_back(*copyIt++);
+      it = symbols.end();
+    } else if ((*it)->value > (*copyIt)->value) {
+      std::swap(*it++, *copyIt);
+    } else {
+      ++it;
+    }
+  }
+  copy->symbols.clear();
+
+  // Remove duplicate compact unwind info for symbols at the same address.
+  if (symbols.size() == 0)
+    return;
+  it = symbols.begin();
+  uint64_t v = (*it)->value;
+  for (++it; it != symbols.end(); ++it) {
+    if ((*it)->value == v)
+      (*it)->compactUnwind = nullptr;
+    else
+      v = (*it)->value;
+  }
 }
 
 void ConcatInputSection::writeTo(uint8_t *buf) {
   assert(!shouldOmitFromOutput());
 
   if (getFileSize() == 0)
     return;
 

lld/MachO/MarkLive.cpp

auto enqueue = [&](InputSection *isec, uint64_t off) {
     isec->markLive(off);
     if (auto s = dyn_cast<ConcatInputSection>(isec)) {
       assert(!s->isCoalescedWeak());
       worklist.push_back(s);
     }
   };
 
   auto addSym = [&](Symbol *s) {
+    if (s->used)
+      return;
     s->used = true;
-    if (auto *d = dyn_cast<Defined>(s))
+    if (auto *d = dyn_cast<Defined>(s)) {
       if (d->isec)
         enqueue(d->isec, d->value);
+      if (d->compactUnwind)
+        enqueue(d->compactUnwind, 0);
+    }
   };
 
   // Add GC roots.
   if (config->entry)
     addSym(config->entry);
   for (Symbol *sym : symtab->getSymbols()) {
     if (auto *defined = dyn_cast<Defined>(sym)) {
       // -exported_symbol(s_list)
for (ConcatInputSection *isec : inputSections) {
     // mod_init_funcs, mod_term_funcs sections
     if (sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS ||
         sectionType(isec->getFlags()) == S_MOD_TERM_FUNC_POINTERS) {
       enqueue(isec, 0);
       continue;
     }
   }
 
-  // Dead strip runs before UnwindInfoSection handling so we need to keep
-  // __LD,__compact_unwind alive here.
-  // But that section contains absolute references to __TEXT,__text and
-  // keeps most code alive due to that. So we can't just enqueue() the
-  // section: We must skip the relocations for the functionAddress
-  // in each CompactUnwindEntry.
-  // See also scanEhFrameSection() in lld/ELF/MarkLive.cpp.
-  for (ConcatInputSection *isec : in.unwindInfo->getInputs()) {
-    isec->live = true;
-    const int compactUnwindEntrySize =
-        target->wordSize == 8 ? sizeof(CompactUnwindEntry<uint64_t>)
-                              : sizeof(CompactUnwindEntry<uint32_t>);
-    for (const Reloc &r : isec->relocs) {
-      // This is the relocation for the address of the function itself.
-      // Ignore it, else these would keep everything alive.
-      if (r.offset % compactUnwindEntrySize == 0)
-        continue;
-
-      if (auto *s = r.referent.dyn_cast<Symbol *>())
-        addSym(s);
-      else
-        enqueue(r.referent.get<InputSection *>(), r.addend);
-    }
-  }
-
   do {
     // Mark things reachable from GC roots as live.
     while (!worklist.empty()) {
       ConcatInputSection *s = worklist.pop_back_val();
       assert(s->live && "We mark as live when pushing onto the worklist!");
 
       // Mark all symbols listed in the relocation table for this section.
       for (const Reloc &r : s->relocs) {
         if (auto *s = r.referent.dyn_cast<Symbol *>())
           addSym(s);
         else
           enqueue(r.referent.get<InputSection *>(), r.addend);
       }
+      for (Defined *d : s->symbols)
+        addSym(d);
     }
 
     // S_ATTR_LIVE_SUPPORT sections are live if they point _to_ a live section.
     // Process them in a second pass.
     for (ConcatInputSection *isec : inputSections) {
       // FIXME: Check if copying all S_ATTR_LIVE_SUPPORT sections into a
       // separate vector and only walking that here is faster.
       if (!(isec->getFlags() & S_ATTR_LIVE_SUPPORT) || isec->live)

lld/MachO/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "ConcatOutputSection.h"
 #include "Config.h"
 #include "InputFiles.h"
+#include "InputSection.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;

lld/MachO/Symbols.h

 //===- Symbols.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_SYMBOLS_H
 #define LLD_MACHO_SYMBOLS_H
 
+#include "Config.h"
 #include "InputFiles.h"
-#include "InputSection.h"
 #include "Target.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MathExtras.h"
 
 namespace lld {
 namespace macho {
 
-class InputSection;
 class MachHeaderSection;
 
 struct StringRefZ {
   StringRefZ(const char *s) : data(s), size(-1) {}
   StringRefZ(StringRef s) : data(s.data()), size(s.size()) {}
 
   const char *data;
   const uint32_t size;
public:
   Kind kind() const { return symbolKind; }
 
   StringRef getName() const {
     if (nameSize == (uint32_t)-1)
       nameSize = strlen(nameData);
     return {nameData, nameSize};
   }
 
-  bool isLive() const;
+  bool isLive() const { return used; }
 
   virtual uint64_t getVA() const { return 0; }
 
   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.
public:
   // True if an undefined or dylib symbol is used from a live section.
   bool used : 1;
 };
 
 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, bool isReferencedDynamically, bool noDeadStrip)
-      : Symbol(DefinedKind, name, file), isec(isec), value(value), size(size),
-        overridesWeakDef(false), privateExtern(isPrivateExtern),
-        includeInSymtab(true), thumb(isThumb),
-        referencedDynamically(isReferencedDynamically),
-        noDeadStrip(noDeadStrip), weakDef(isWeakDef), external(isExternal) {
-    if (auto concatIsec = dyn_cast_or_null<ConcatInputSection>(isec))
-      concatIsec->numRefs++;
-  }
+          bool isThumb, bool isReferencedDynamically, bool noDeadStrip);
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
   }
-  bool isTlv() const override {
-    return !isAbsolute() && isThreadLocalVariables(isec->getFlags());
-  }
+  bool isTlv() const override;
 
   bool isExternal() const { return external; }
   bool isAbsolute() const { return isec == nullptr; }
 
   uint64_t getVA() const override;
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedKind; }
 
   InputSection *isec;
   // Contains the offset from the containing subsection. Note that this is
   // different from nlist::n_value, which is the absolute address of the symbol.
   uint64_t value;
   // size is only calculated for regular (non-bitcode) symbols.
   uint64_t size;
+  ConcatInputSection *compactUnwind = nullptr;
 
   bool overridesWeakDef : 1;
   // Whether this symbol should appear in the output binary's export trie.
   bool privateExtern : 1;
   // Whether this symbol should appear in the output symbol table.
   bool includeInSymtab : 1;
   // Only relevant when compiling for Thumb-supporting arm32 archs.
   bool thumb : 1;

lld/MachO/Symbols.cpp

 std::string lld::toMachOString(const object::Archive::Symbol &b) {
   return demangle(b.getName());
 }
 
 uint64_t Symbol::getStubVA() const { return in.stubs->getVA(stubsIndex); }
 uint64_t Symbol::getGotVA() const { return in.got->getVA(gotIndex); }
 uint64_t Symbol::getTlvVA() const { return in.tlvPointers->getVA(gotIndex); }
 
-bool Symbol::isLive() const {
-  if (isa<DylibSymbol>(this) || isa<Undefined>(this))
-    return used;
-
-  if (auto *d = dyn_cast<Defined>(this)) {
-    // Non-absolute symbols might be alive because their section is
-    // no_dead_strip or live_support. In that case, the section will know
-    // that it's live but `used` might be false. Non-absolute symbols always
-    // have to use the section's `live` bit as source of truth.
-    if (d->isAbsolute())
-      return used;
-    return d->isec->canonical()->isLive(d->value);
-  }
-
-  assert(!isa<CommonSymbol>(this) &&
-         "replaceCommonSymbols() runs before dead code stripping, and isLive() "
-         "should only be called after dead code stripping");
+Defined::Defined(StringRefZ name, InputFile *file, InputSection *isec,
+                 uint64_t value, uint64_t size, bool isWeakDef, bool isExternal,
+                 bool isPrivateExtern, bool isThumb,
+                 bool isReferencedDynamically, bool noDeadStrip)
+    : Symbol(DefinedKind, name, file), isec(isec), value(value), size(size),
+      overridesWeakDef(false), privateExtern(isPrivateExtern),
+      includeInSymtab(true), thumb(isThumb),
+      referencedDynamically(isReferencedDynamically), noDeadStrip(noDeadStrip),
+      weakDef(isWeakDef), external(isExternal) {
+  if (isec) {
+    isec->symbols.push_back(this);
+    // Maintain sorted order.
+    for (auto it = isec->symbols.rbegin(), rend = isec->symbols.rend();
+         it != rend; ++it) {
+      auto next = std::next(it);
+      if (next == rend)
+        break;
+      if ((*it)->value < (*next)->value)
+        std::swap(*next, *it);
+      else
+        break;
+    }
+  }
+}
 
-  // Assume any other kind of symbol is live.
-  return true;
+bool Defined::isTlv() const {
+  return !isAbsolute() && isThreadLocalVariables(isec->getFlags());
 }
 
 uint64_t Defined::getVA() const {
   assert(isLive() && "this should only be called for live symbols");
 
   if (isAbsolute())
     return value;
 

lld/MachO/SyntheticSections.cpp

if (stubBinder == nullptr)
     return;
 
   in.got->addEntry(stubBinder);
 
   in.imageLoaderCache->parent =
       ConcatOutputSection::getOrCreateForInput(in.imageLoaderCache);
   inputSections.push_back(in.imageLoaderCache);
   // Since this isn't in the symbol table or in any input file, the noDeadStrip
-  // argument doesn't matter. It's kept alive by ImageLoaderCacheSection()
-  // setting `live` to true on the backing InputSection.
+  // argument doesn't matter.
   dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false,
                     /*isThumb=*/false, /*isReferencedDynamically=*/false,
                     /*noDeadStrip=*/false);
+  dyldPrivate->used = true;
 }
 
 LazyPointerSection::LazyPointerSection()
     : SyntheticSection(segment_names::data, section_names::lazySymbolPtr) {
   align = target->wordSize;
   flags = S_LAZY_SYMBOL_POINTERS;
 }
 

lld/MachO/UnwindInfoSection.h

 };
 
 class UnwindInfoSection : public SyntheticSection {
 public:
   bool isNeeded() const override {
     return !compactUnwindSection->inputs.empty() && !allEntriesAreOmitted;
   }
   uint64_t getSize() const override { return unwindInfoSize; }
-  virtual void addInput(ConcatInputSection *) = 0;
+  virtual void addSymbol(const Defined *) = 0;
   std::vector<ConcatInputSection *> getInputs() {
     return compactUnwindSection->inputs;
   }
   void prepareRelocations();
 
 protected:
   UnwindInfoSection();
   virtual void prepareRelocations(ConcatInputSection *) = 0;

lld/MachO/UnwindInfoSection.cpp

struct SecondLevelPage {
   std::vector<compact_unwind_encoding_t> localEncodings;
   EncodingMap localEncodingIndexes;
 };
 
 template <class Ptr>
 class UnwindInfoSectionImpl final : public UnwindInfoSection {
 public:
   void prepareRelocations(ConcatInputSection *) override;
-  void addInput(ConcatInputSection *) override;
+  void addSymbol(const Defined *) override;
   void finalize() override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   std::vector<std::pair<compact_unwind_encoding_t, size_t>> commonEncodings;
   EncodingMap commonEncodingIndexes;
   // Indices of personality functions within the GOT.
   std::vector<Ptr> personalities;

 }
 
 void UnwindInfoSection::prepareRelocations() {
   for (ConcatInputSection *isec : compactUnwindSection->inputs)
     prepareRelocations(isec);
 }
 
 template <class Ptr>
-void UnwindInfoSectionImpl<Ptr>::addInput(ConcatInputSection *isec) {
-  assert(isec->getSegName() == segment_names::ld &&
-         isec->getName() == section_names::compactUnwind);
-  isec->parent = compactUnwindSection;
-  compactUnwindSection->addInput(isec);
+void UnwindInfoSectionImpl<Ptr>::addSymbol(const Defined *d) {
+  if (d->compactUnwind) {
+    d->compactUnwind->parent = compactUnwindSection;
+    compactUnwindSection->addInput(d->compactUnwind);
+  }
 }
 
 // Compact unwind relocations have different semantics, so we handle them in a
 // 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>

 static ConcatInputSection *checkTextSegment(InputSection *isec) {
   if (isec->getSegName() != segment_names::text)
     error("compact unwind references address in " + toString(isec) +
           " which is not in segment __TEXT");
   // __text should always be a ConcatInputSection.
   return cast<ConcatInputSection>(isec);
 }
 
-template <class Ptr>
-constexpr Ptr TombstoneValue = std::numeric_limits<Ptr>::max();
-
 // We need to apply the relocations to the pre-link compact unwind section
 // 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(ConcatOutputSection *compactUnwindSection,
                       std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
   for (const ConcatInputSection *isec : compactUnwindSection->inputs) {
     assert(isec->parent == compactUnwindSection);
 
     uint8_t *buf =
         reinterpret_cast<uint8_t *>(cuVector.data()) + isec->outSecOff;
     memcpy(buf, isec->data.data(), isec->data.size());
 
     for (const Reloc &r : isec->relocs) {
-      uint64_t referentVA = TombstoneValue<Ptr>;
+      uint64_t referentVA = 0;
       if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
         if (!isa<Undefined>(referentSym)) {
           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;

 // unwind info need explicit "no unwind info" unwind entries -- else the
 // unwinder would think they have the unwind info of the closest function
 // with unwind info right before in the image.
 template <class Ptr>
 static void addEntriesForFunctionsWithoutUnwindInfo(
     std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
   DenseSet<Ptr> hasUnwindInfo;
   for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
-    if (cuEntry.functionAddress != TombstoneValue<Ptr>)
-      hasUnwindInfo.insert(cuEntry.functionAddress);
 
   // Add explicit "has no unwind info" entries for all global and local symbols
   // without unwind info.
   auto markNoUnwindInfo = [&cuVector, &hasUnwindInfo](const Defined *d) {
     if (d->isLive() && d->isec && isCodeSection(d->isec)) {
       Ptr ptr = d->getVA();
       if (!hasUnwindInfo.count(ptr))
         cuVector.push_back({ptr, 0, 0, 0, 0});
template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
   cuPtrVector.reserve(cuVector.size());
   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 TombstoneValue in
-  // relocateCompactUnwind(). Filter them out here.
-  // FIXME: This doesn't yet collect associated data like LSDAs kept
-  // alive only by a now-removed CompactUnwindEntry or other comdat-like
-  // data (`kindNoneGroupSubordinate*` in ld64).
-  CompactUnwindEntry<Ptr> tombstone;
-  tombstone.functionAddress = TombstoneValue<Ptr>;
-  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());
-
-  // If there are no entries left after adding explicit "no unwind info"
-  // entries and removing entries for dead-stripped functions, don't write
-  // an __unwind_info section at all.
-  assert(allEntriesAreOmitted == cuPtrVector.empty());
-  if (cuPtrVector.empty())
-    return;
-
   // 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();
for (const SecondLevelPage &page : secondLevelPages) {
     iep->lsdaIndexArraySectionOffset =
         lsdaOffset + functionToLsdaIndex.lookup(iep->functionOffset) *
                          sizeof(unwind_info_section_header_lsda_index_entry);
     iep++;
     l2PagesOffset += SECOND_LEVEL_PAGE_BYTES;
   }
   // Level-1 sentinel
   const CompactUnwindEntry<Ptr> &cuEnd = *cuPtrVector.back();
-  assert(cuEnd.functionAddress != TombstoneValue<Ptr>);
   iep->functionOffset =
       cuEnd.functionAddress - in.header->addr + cuEnd.functionLength;
   iep->secondLevelPagesSectionOffset = 0;
   iep->lsdaIndexArraySectionOffset =
       lsdaOffset +
       lsdaEntries.size() * sizeof(unwind_info_section_header_lsda_index_entry);
   iep++;
 

lld/MachO/Writer.cpp

void Writer::scanRelocations() {
 
   in.unwindInfo->prepareRelocations();
 }
 
 void Writer::scanSymbols() {
   TimeTraceScope timeScope("Scan symbols");
   for (const Symbol *sym : symtab->getSymbols()) {
     if (const auto *defined = dyn_cast<Defined>(sym)) {
-      if (defined->overridesWeakDef && defined->isLive())
+      if (!defined->isLive())
+        continue;
+      if (defined->overridesWeakDef)
         in.weakBinding->addNonWeakDefinition(defined);
+      in.unwindInfo->addSymbol(defined);
     } else if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       // This branch intentionally doesn't check isLive().
       if (dysym->isDynamicLookup())
         continue;
       dysym->getFile()->refState =
           std::max(dysym->getFile()->refState, dysym->getRefState());
     }
   }
+
+  for (const InputFile *file : inputFiles) {
+    if (auto *objFile = dyn_cast<ObjFile>(file))
+      for (Symbol *sym : objFile->symbols) {
+        if (auto *defined = dyn_cast_or_null<Defined>(sym))
+          if (!defined->isExternal() && defined->isLive())
+            in.unwindInfo->addSymbol(defined);
+      }
+  }
 }
 
 // TODO: ld64 enforces the old load commands in a few other cases.
 static bool useLCBuildVersion(const PlatformInfo &platformInfo) {
   static const std::vector<std::pair<PlatformKind, VersionTuple>> minVersion = {
       {PlatformKind::macOS, VersionTuple(10, 14)},
       {PlatformKind::iOS, VersionTuple(12, 0)},
       {PlatformKind::iOSSimulator, VersionTuple(13, 0)},
void Writer::writeOutputFile() {
   if (auto e = buffer->commit())
     error("failed to write to the output file: " + toString(std::move(e)));
 }
 
 template <class LP> void Writer::run() {
   treatSpecialUndefineds();
   if (config->entry && !isa<Undefined>(config->entry))
     prepareBranchTarget(config->entry);
+  scanSymbols();
   scanRelocations();
 
   // Do not proceed if there was an undefined symbol.
   if (errorCount())
     return;
 
   if (in.stubHelper->isNeeded())
     in.stubHelper->setup();
-  scanSymbols();
   createOutputSections<LP>();
 
   // After this point, we create no new segments; HOWEVER, we might
   // yet create branch-range extension thunks for architectures whose
   // hardware call instructions have limited range, e.g., ARM(64).
   // The thunks are created as InputSections interspersed among
   // the ordinary __TEXT,_text InputSections.
   sortSegmentsAndSections();

lld/test/MachO/compact-unwind-both-local-and-dylib-personality.s

 
 ## Postlink checks.
 # RUN: llvm-nm %t/a.out | FileCheck %s --check-prefix=POSTCHECK
 # POSTCHECK: {{.*}} U ___gxx_personality_v0
 # POSTCHECK: {{.*}} t ___gxx_personality_v0 
 
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/a.out | FileCheck %s --check-prefixes=A,CHECK -D#%x,OFF=0x100000000
 # RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/b.out | FileCheck %s --check-prefixes=BC,CHECK -D#%x,OFF=0x100000000
-# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/c.out | FileCheck %s --check-prefixes=BC,CHECK -D#%x,OFF=0
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --bind %t/c.out | FileCheck %s --check-prefixes=BC,C,CHECK -D#%x,OFF=0
 
 # A:      Indirect symbols for (__DATA_CONST,__got)
 # A-NEXT: address                    index name
-# A-DAG:  0x[[#%x,GXX_PERSONALITY_LO:]] [[#]] ___gxx_personality_v0
-# A-DAG:  0x[[#%x,GXX_PERSONALITY_HI:]] [[#]] ___gxx_personality_v0
-# A-DAG:  0x[[#%x,PERSONALITY_1:]]  LOCAL
-# A-DAG:  0x[[#%x,PERSONALITY_2:]]  LOCAL
+# A:      0x[[#%x,GXX_PERSONALITY_LO:]] [[#]] ___gxx_personality_v0
+# A:      0x[[#%x,GXX_PERSONALITY_HI:]] [[#]] ___gxx_personality_v0
+# A:      0x[[#%x,PERSONALITY_1:]]  LOCAL
+# A:      0x[[#%x,PERSONALITY_2:]]  LOCAL
 
 # BC:      Indirect symbols for (__DATA_CONST,__got)
 # BC-NEXT: address                    index name
-# BC-DAG:  0x[[#%x,GXX_PERSONALITY_HI:]] LOCAL
-# BC-DAG:  0x[[#%x,GXX_PERSONALITY_LO:]] LOCAL
-# BC-DAG:  0x[[#%x,PERSONALITY_1:]]  LOCAL
-# BC-DAG:  0x[[#%x,PERSONALITY_2:]]  LOCAL
+# C:       0x[[#%x,GXX_PERSONALITY_HI:]] LOCAL
+# BC:      0x[[#%x,GXX_PERSONALITY_LO:]] LOCAL
+# BC:      0x[[#%x,PERSONALITY_1:]]      LOCAL
+# BC:      0x[[#%x,PERSONALITY_2:]]      LOCAL
 
 # CHECK:        Personality functions: (count = 3)
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#GXX_PERSONALITY_LO-OFF]]
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#PERSONALITY_1-OFF]]
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#PERSONALITY_2-OFF]]
 
 # A: Bind table
 # A-NEXT: segment  section          address      type       addend dylib            symbol
 # A-NEXT: __DATA_CONST __got        0x[[#GXX_PERSONALITY_LO-0]] pointer         0 libc++abi        ___gxx_personality_v0

lld/test/MachO/dead-strip.s

 # UNWIND-NEXT:   g F __TEXT,__text __mh_execute_header
 # UNWIND-NEXT:   *UND* ___cxa_allocate_exception
 # UNWIND-NEXT:   *UND* ___cxa_end_catch
 # UNWIND-NEXT:   *UND* __ZTIi
 # UNWIND-NEXT:   *UND* ___cxa_throw
 # UNWIND-NEXT:   *UND* ___gxx_personality_v0
 # UNWIND-NEXT:   *UND* ___cxa_begin_catch
 # UNWIND-NEXT:   *UND* dyld_stub_binder
+# UNWIND-NOT:    GCC_except_table0
 
 ## If a dead stripped function has a strong ref to a dylib symbol but
 ## a live function only a weak ref, the dylib is still not a WEAK_DYLIB.
 ## This matches ld64.
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
 # RUN:     %t/weak-ref.s -o %t/weak-ref.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
 # RUN:     %t/strong-dead-ref.s -o %t/strong-dead-ref.o

 _baz_refd:
   retq
 
 .subsections_via_symbols
 
 #--- unwind.s
 ## This is the output of `clang -O2 -S throw.cc` where throw.cc
 ## looks like this:
-##     void unref() {}
+##     int unref() {
+##       try {
+##         throw 0;
+##       } catch (int i) {
+##         return i + 1;
+##       }
+##     }
 ##     int main() {
 ##       try {
 ##         throw 0;
 ##       } catch (int i) {
 ##         return i;
 ##       }
 ##     }
 .section __TEXT,__text,regular,pure_instructions
-
-.globl __Z5unrefv
+.globl __Z5unrefv                      ## -- Begin function _Z5unrefv
 .p2align 4, 0x90
-__Z5unrefv:
+__Z5unrefv:                             ## @_Z5unrefv
+Lfunc_begin0:
   .cfi_startproc
-  pushq %rbp
+  .cfi_personality 155, ___gxx_personality_v0
+  .cfi_lsda 16, Lexception0
+## %bb.0:
+  pushq  %rbp
   .cfi_def_cfa_offset 16
   .cfi_offset %rbp, -16
-  movq %rsp, %rbp
+  movq  %rsp, %rbp
   .cfi_def_cfa_register %rbp
-  popq %rbp
+  subq  $16, %rsp
+  movl  $4, %edi
+  callq  ___cxa_allocate_exception
+  movl  $0, (%rax)
+Ltmp0:
+  movq  __ZTIi@GOTPCREL(%rip), %rsi
+  movq  %rax, %rdi
+  xorl  %edx, %edx
+  callq  ___cxa_throw
+Ltmp1:
+## %bb.1:
+  ud2
+LBB0_2:
+Ltmp2:
+  leaq  -4(%rbp), %rcx
+  movq  %rax, %rdi
+  movl  %edx, %esi
+  movq  %rcx, %rdx
+  callq  __Z5unrefv.cold.1
+  movl  -4(%rbp), %eax
+  addq  $16, %rsp
+  popq  %rbp
   retq
+Lfunc_end0:
   .cfi_endproc
-
-.globl _main
+  .section  __TEXT,__gcc_except_tab
+  .p2align 2
+GCC_except_table0:
+Lexception0:
+  .byte 255                             ## @LPStart Encoding = omit
+  .byte 155                             ## @TType Encoding = indirect pcrel sdata4
+  .uleb128 Lttbase0-Lttbaseref0
+Lttbaseref0:
+  .byte 1                               ## Call site Encoding = uleb128
+  .uleb128 Lcst_end0-Lcst_begin0
+Lcst_begin0:
+  .uleb128 Lfunc_begin0-Lfunc_begin0    ## >> Call Site 1 <<
+  .uleb128 Ltmp0-Lfunc_begin0           ##   Call between Lfunc_begin0 and Ltmp0
+  .byte 0                               ##     has no landing pad
+  .byte 0                               ##   On action: cleanup
+  .uleb128 Ltmp0-Lfunc_begin0           ## >> Call Site 2 <<
+  .uleb128 Ltmp1-Ltmp0                  ##   Call between Ltmp0 and Ltmp1
+  .uleb128 Ltmp2-Lfunc_begin0           ##     jumps to Ltmp2
+  .byte 1                               ##   On action: 1
+  .uleb128 Ltmp1-Lfunc_begin0           ## >> Call Site 3 <<
+  .uleb128 Lfunc_end0-Ltmp1             ##   Call between Ltmp1 and Lfunc_end0
+  .byte 0                               ##     has no landing pad
+  .byte 0                               ##   On action: cleanup
+Lcst_end0:
+  .byte 1                               ## >> Action Record 1 <<
+                                        ##   Catch TypeInfo 1
+  .byte 0                               ##   No further actions
+  .p2align 2
+                                        ## >> Catch TypeInfos <<
+  .long  __ZTIi@GOTPCREL+4              ## TypeInfo 1
+Lttbase0:
+  .p2align 2
+                                        ## -- End function
+  .section  __TEXT,__text,regular,pure_instructions
+  .globl  _main                         ## -- Begin function main
   .p2align 4, 0x90
-_main:
-Lfunc_begin0:
+_main:                                  ## @main
+Lfunc_begin1:
   .cfi_startproc
   .cfi_personality 155, ___gxx_personality_v0
-  .cfi_lsda 16, Lexception0
-  pushq %rbp
+  .cfi_lsda 16, Lexception1
+## %bb.0:
+  pushq  %rbp
   .cfi_def_cfa_offset 16
   .cfi_offset %rbp, -16
-  movq %rsp, %rbp
+  movq  %rsp, %rbp
   .cfi_def_cfa_register %rbp
-  pushq %rbx
-  pushq %rax
+  pushq  %rbx
+  pushq  %rax
   .cfi_offset %rbx, -24
-  movl $4, %edi
-  callq ___cxa_allocate_exception
-  movl $0, (%rax)
-Ltmp0:
-  movq __ZTIi@GOTPCREL(%rip), %rsi
-  movq %rax, %rdi
-  xorl %edx, %edx
+  movl  $4, %edi
+  callq  ___cxa_allocate_exception
+  movl  $0, (%rax)
+Ltmp3:
+  movq  __ZTIi@GOTPCREL(%rip), %rsi
+  movq  %rax, %rdi
+  xorl  %edx, %edx
   callq ___cxa_throw
-Ltmp1:
+Ltmp4:
+## %bb.1:
   ud2
 LBB1_2:
-Ltmp2:
-  movq %rax, %rdi
+Ltmp5:
+  movq  %rax, %rdi
   callq ___cxa_begin_catch
-  movl (%rax), %ebx
+  movl  (%rax), %ebx
   callq ___cxa_end_catch
-  movl %ebx, %eax
-  addq $8, %rsp
-  popq %rbx
-  popq %rbp
+  movl  %ebx, %eax
+  addq  $8, %rsp
+  popq  %rbx
+  popq  %rbp
   retq
-Lfunc_end0:
+Lfunc_end1:
   .cfi_endproc
-
-.section __TEXT,__gcc_except_tab
-.p2align 2
+  .section  __TEXT,__gcc_except_tab
+  .p2align  2
 GCC_except_table1:
-Lexception0:
-  .byte 255                     ## @LPStart Encoding = omit
-  .byte 155                     ## @TType Encoding = indirect pcrel sdata4
-  .uleb128 Lttbase0-Lttbaseref0
-Lttbaseref0:
-  .byte 1                       ## Call site Encoding = uleb128
-  .uleb128 Lcst_end0-Lcst_begin0
-Lcst_begin0:
-  .uleb128 Lfunc_begin0-Lfunc_begin0 ## >> Call Site 1 <<
-  .uleb128 Ltmp0-Lfunc_begin0   ##   Call between Lfunc_begin0 and Ltmp0
-  .byte 0                       ##     has no landing pad
-  .byte 0                       ##   On action: cleanup
-  .uleb128 Ltmp0-Lfunc_begin0   ## >> Call Site 2 <<
-  .uleb128 Ltmp1-Ltmp0          ##   Call between Ltmp0 and Ltmp1
-  .uleb128 Ltmp2-Lfunc_begin0   ##     jumps to Ltmp2
-  .byte 1                       ##   On action: 1
-  .uleb128 Ltmp1-Lfunc_begin0   ## >> Call Site 3 <<
-  .uleb128 Lfunc_end0-Ltmp1     ##   Call between Ltmp1 and Lfunc_end0
-  .byte 0                       ##     has no landing pad
-  .byte 0                       ##   On action: cleanup
-Lcst_end0:
-  .byte 1                       ## >> Action Record 1 <<
-                                         ##   Catch TypeInfo 1
-  .byte 0                       ##   No further actions
+Lexception1:
+  .byte 255                             ## @LPStart Encoding = omit
+  .byte 155                             ## @TType Encoding = indirect pcrel sdata4
+  .uleb128 Lttbase1-Lttbaseref1
+Lttbaseref1:
+  .byte 1                               ## Call site Encoding = uleb128
+  .uleb128 Lcst_end1-Lcst_begin1
+Lcst_begin1:
+  .uleb128 Lfunc_begin1-Lfunc_begin1    ## >> Call Site 1 <<
+  .uleb128 Ltmp3-Lfunc_begin1           ##   Call between Lfunc_begin1 and Ltmp3
+  .byte 0                               ##     has no landing pad
+  .byte 0                               ##   On action: cleanup
+  .uleb128 Ltmp3-Lfunc_begin1           ## >> Call Site 2 <<
+  .uleb128 Ltmp4-Ltmp3                  ##   Call between Ltmp3 and Ltmp4
+  .uleb128 Ltmp5-Lfunc_begin1           ##     jumps to Ltmp5
+  .byte 1                               ##   On action: 1
+  .uleb128 Ltmp4-Lfunc_begin1           ## >> Call Site 3 <<
+  .uleb128 Lfunc_end1-Ltmp4             ##   Call between Ltmp4 and Lfunc_end1
+  .byte 0                               ##     has no landing pad
+  .byte 0                               ##   On action: cleanup
+Lcst_end1:
+  .byte 1                               ## >> Action Record 1 <<
+  .byte 0                               ##   No further actions
   .p2align 2
                                         ## >> Catch TypeInfos <<
-  .long __ZTIi@GOTPCREL+4       ## TypeInfo 1
-Lttbase0:
+  .long __ZTIi@GOTPCREL+4               ## TypeInfo 1
+Lttbase1:
   .p2align 2
                                         ## -- End function
+  .section __TEXT,__text,regular,pure_instructions
+  .p2align 4, 0x90                      ## -- Begin function _Z5unrefv.cold.1
+__Z5unrefv.cold.1:                      ## @_Z5unrefv.cold.1
+  .cfi_startproc
+## %bb.0:
+  pushq  %rbp
+  .cfi_def_cfa_offset 16
+  .cfi_offset %rbp, -16
+  movq  %rsp, %rbp
+  .cfi_def_cfa_register %rbp
+  pushq  %rbx
+  pushq  %rax
+  .cfi_offset %rbx, -24
+  movq  %rdx, %rbx
+  callq  ___cxa_begin_catch
+  movl  (%rax), %eax
+  incl  %eax
+  movl  %eax, (%rbx)
+  addq  $8, %rsp
+  popq  %rbx
+  popq  %rbp
+  jmp  ___cxa_end_catch                 ## TAILCALL
+  .cfi_endproc
+                                        ## -- End function
 .subsections_via_symbols
 
 #--- weak-ref.s
 .text
 .weak_reference _ref_dylib_fun
 .globl _main
 _main:
   callq _ref_dylib_fun

lld/test/MachO/invalid/cfstring.s

 # REQUIRES: x86
 # RUN: rm -rf %t; mkdir %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
 # RUN: not %lld -dylib -framework CoreFoundation --icf=all %t/test.o 2>&1 | FileCheck %s
-# CHECK: error: {{.*}}test.o: __cfstring contains symbol _uh_oh at misaligned offset
+# CHECK: error: {{.*}}test.o:(__cfstring): symbol _uh_oh at misaligned offset
 
 .cstring
 L_.str:
   .asciz  "foo"
 
 .section  __DATA,__cfstring
 .p2align  3
 L__unnamed_cfstring_:
   .quad  ___CFConstantStringClassReference
   .long  1992 ## utf-8
 _uh_oh:
   .space  4
   .quad  L_.str
   .quad  3 ## strlen