[lld-macho][nfc] Factor-out NFC changes from main __eh_frame diff

[gkm]

Summary

In order to keep signal:noise high for the __eh_frame diff, I have teased-out the NFC changes and put them here.

[oontvoo]

lld/MachO/ICF.cpp

190

lld/MachO/InputFiles.cpp

712–713

(dont think it's necessary to copy it)

[gkm]

lld/MachO/InputFiles.cpp

712–713

Copying is only necessary to prevent 13 test cases from crashing ... 😵‍💫🤮

[gkm]

• Revise according to review feedback.
• Move 2 more hunks of NFC-ish code into this diff to ignore useless symbols and SUBTRACTOR relocs in __TEXT,__eh_frame. (See code comments)

[oontvoo]

lg thanks!

lld/MachO/InputFiles.cpp

712–713

Oh, that's ... disturbing. why is it crashing(presumably asan issues?) ?
we're not holding on to the subsec (only its isec field, which is already a pointer )

lld/MachO/UnwindInfoSection.cpp

217

could also be a Lazy symbol (D110040) ?

[oontvoo]

lld/MachO/UnwindInfoSection.cpp

217

(p.s : this is a question, not a request to change the comment :) )

[thevinster]

Minor nits and stuff. Overall, generally looks good

lld/MachO/Driver.cpp

1028

Do we also need to check for segment_names::ld here as well? or can that be assumed that compact_unwind is always under __ld?

lld/MachO/InputFiles.cpp

280

Don't you need braces on these surrounding the sec.addr? I'm surprised that the push_back supports constructor initialization via its arguments (emplace_back supports it though).

lld/MachO/InputSection.h

301

nit: Generally, it would be nice to see variables also get defined and used in the same diff to make things more "self-contained". I imagine this will be used in your next diff? No strong opinions though.

[int3]

lld/MachO/InputFiles.cpp

712–713

+1, this seems unexpected

lld/MachO/UnwindInfoSection.cpp

211–214

nit: can we move this comment above the if statement on line 205? it makes it more obvious that we have a valid single-line unbraced if statement

215

it's become a noun in its own right, I don't think most people spell it as an abbreviation...

217

"it" would refer to the function here, not the reloc

217

@oontvoo D110040 is about changing local (defined) symbol references into dylib symbol references, that's the only reason we may encounter LazySymbols... but "regular" relocation handling should never encounter LazySymbols since they would all have been fetched in the parsing phase already

[gkm]

lld/MachO/Driver.cpp

1028

Yes. Always.

lld/MachO/InputFiles.cpp

280

push_back() supports the constructor argument list.

712–713

I tracked this down. When subsec is a reference, we hit undefined behavior later when subsec is re-seated at the end of the nested loop. I am surprised there was no warning from the compiler. AFAIK, references cannot be re-seated, but I am now C++ expert. I have reworked the offending code.

lld/MachO/InputSection.h

301

While its first use will be in the substantive __eh_frame diff, it has a life independent of __eh_frame, since LSDA is also used by compact unwind.

[gkm]

• Revise according to review feedback

lld/MachO/Driver.cpp

static void createFiles(const InputArgList &args) {
   }
 }
 
 static void gatherInputSections() {
   TimeTraceScope timeScope("Gathering input sections");
   int inputOrder = 0;
   for (const InputFile *file : inputFiles) {
     for (const Section &section : file->sections) {
+      const Subsections &subsections = section.subsections;
+      if (subsections.empty())
+        continue;
+      if (subsections[0].isec->getName() == section_names::compactUnwind)
+        // Compact unwind entries require special handling elsewhere.
+        continue;
       ConcatOutputSection *osec = nullptr;
-      for (const Subsection &subsection : section.subsections) {
+      for (const Subsection &subsection : subsections) {
         if (auto *isec = dyn_cast<ConcatInputSection>(subsection.isec)) {
           if (isec->isCoalescedWeak())
             continue;
-          if (isec->getSegName() == segment_names::ld) {
-            assert(isec->getName() == section_names::compactUnwind);
-            continue;
-          }
           isec->outSecOff = inputOrder++;
           if (!osec)
             osec = ConcatOutputSection::getOrCreateForInput(isec);
           isec->parent = osec;
           inputSections.push_back(isec);
         } else if (auto *isec =
                        dyn_cast<CStringInputSection>(subsection.isec)) {
           if (in.cStringSection->inputOrder == UnspecifiedInputOrder)

lld/MachO/ICF.cpp

static bool equalsVariable(const ConcatInputSection *ia,
   };
   if (!std::equal(ia->relocs.begin(), ia->relocs.end(), ib->relocs.begin(), f))
     return false;
 
   // If there are symbols with associated unwind info, check that the unwind
   // info matches. For simplicity, we only handle the case where there are only
   // symbols at offset zero within the section (which is typically the case with
   // .subsections_via_symbols.)
-  auto hasCU = [](Defined *d) { return d->compactUnwind; };
+  auto hasCU = [](Defined *d) { return d->unwindEntry != nullptr; };
   auto itA = std::find_if(ia->symbols.begin(), ia->symbols.end(), hasCU);
   auto itB = std::find_if(ib->symbols.begin(), ib->symbols.end(), hasCU);
   if (itA == ia->symbols.end())
     return itB == ib->symbols.end();
   if (itB == ib->symbols.end())
     return false;
   const Defined *da = *itA;
   const Defined *db = *itB;
-  if (da->compactUnwind->icfEqClass[icfPass % 2] !=
-          db->compactUnwind->icfEqClass[icfPass % 2] ||
+  if (da->unwindEntry->icfEqClass[icfPass % 2] !=
+          db->unwindEntry->icfEqClass[icfPass % 2] ||
       da->value != 0 || db->value != 0)
     return false;
   auto isZero = [](Defined *d) { return d->value == 0; };
   return std::find_if_not(std::next(itA), ia->symbols.end(), isZero) ==
              ia->symbols.end() &&
          std::find_if_not(std::next(itB), ib->symbols.end(), isZero) ==
              ib->symbols.end();
 }
void macho::foldIdenticalSections() {
   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() && isec->isHashableForICF();
     if (isHashable) {
       hashable.push_back(isec);
       for (Defined *d : isec->symbols)
-        if (d->compactUnwind)
-          hashable.push_back(d->compactUnwind);
+        if (d->unwindEntry)
+          hashable.push_back(d->unwindEntry);
     } 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

 } // namespace llvm
 
 namespace lld {
 namespace macho {
 
 struct PlatformInfo;
 class ConcatInputSection;
 class Symbol;
+class Defined;
 struct Reloc;
 enum class RefState : uint8_t;
 
 // If --reproduce option is given, all input files are written
 // to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> tar;
 
 // If .subsections_via_symbols is set, each InputSection will be split along
 // symbol boundaries. The field offset represents the offset of the subsection
 // from the start of the original pre-split InputSection.
 struct Subsection {
   uint64_t offset = 0;
   InputSection *isec = nullptr;
 };
 
 using Subsections = std::vector<Subsection>;
 
 struct Section {
-  // uint64_t address = 0; // TODO(gkm): this will debut with __eh_frame handler
+  uint64_t address = 0;
   Subsections subsections;
+  Section(uint64_t addr) : address(addr){};
 };
 
 class InputFile {
 public:
   enum Kind {
     ObjKind,
     OpaqueKind,
     DylibKind,
public:
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
   llvm::DWARFUnit *compileUnit = nullptr;
   const uint32_t modTime;
   std::vector<ConcatInputSection *> debugSections;
   ArrayRef<llvm::MachO::data_in_code_entry> dataInCodeEntries;
 
 private:
+  Section *compactUnwindSection = nullptr;
+
   template <class LP> void parse();
   template <class SectionHeader> void parseSections(ArrayRef<SectionHeader>);
   template <class LP>
   void parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                     ArrayRef<typename LP::nlist> nList, const char *strtab,
                     bool subsectionsViaSymbols);
   template <class NList>
   Symbol *parseNonSectionSymbol(const NList &sym, StringRef name);

lld/MachO/InputFiles.cpp

for (const SectionHeader &sec : sectionHeaders) {
     StringRef segname =
         StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
     ArrayRef<uint8_t> data = {isZeroFill(sec.flags) ? nullptr
                                                     : buf + sec.offset,
                               static_cast<size_t>(sec.size)};
     if (sec.align >= 32) {
       error("alignment " + std::to_string(sec.align) + " of section " + name +
             " is too large");
-      sections.push_back({});
+      sections.push_back(sec.addr);
       continue;
     }
     uint32_t align = 1 << sec.align;
     uint32_t flags = sec.flags;
 
     auto splitRecords = [&](int recordSize) -> void {
-      sections.push_back({});
+      sections.push_back(sec.addr);
       if (data.empty())
         return;
-
       Subsections &subsections = sections.back().subsections;
       subsections.reserve(data.size() / recordSize);
       auto *isec = make<ConcatInputSection>(
           segname, name, this, data.slice(0, recordSize), align, flags);
       subsections.push_back({0, isec});
       for (uint64_t off = recordSize; off < data.size(); off += recordSize) {
         // Copying requires less memory than constructing a fresh InputSection.
         auto *copy = make<ConcatInputSection>(*isec);
if (sectionType(sec.flags) == S_CSTRING_LITERALS ||
         isec =
             make<CStringInputSection>(segname, name, this, data, align, flags);
         // FIXME: parallelize this?
         cast<CStringInputSection>(isec)->splitIntoPieces();
       } else {
         isec = make<WordLiteralInputSection>(segname, name, this, data, align,
                                              flags);
       }
-      sections.push_back({});
+      sections.push_back(sec.addr);
       sections.back().subsections.push_back({0, isec});
     } else if (auto recordSize = getRecordSize(segname, name)) {
       splitRecords(*recordSize);
+      if (name == section_names::compactUnwind)
+        compactUnwindSection = &sections.back();
     } else if (segname == segment_names::llvm) {
       // ld64 does not appear to emit contents from sections within the __LLVM
       // segment. Symbols within those sections point to bitcode metadata
       // instead of actual symbols. Global symbols within those sections could
       // have the same name without causing duplicate symbol errors. Push an
       // empty entry to ensure indices line up for the remaining sections.
       // TODO: Evaluate whether the bitcode metadata is needed.
-      sections.push_back({});
+      sections.push_back(sec.addr);
     } else {
       auto *isec =
           make<ConcatInputSection>(segname, name, this, data, align, flags);
       if (isDebugSection(isec->getFlags()) &&
           isec->getSegName() == segment_names::dwarf) {
         // Instead of emitting DWARF sections, we emit STABS symbols to the
         // object files that contain them. We filter them out early to avoid
         // parsing their relocations unnecessarily. But we must still push an
         // empty entry to ensure the indices line up for the remaining sections.
-        sections.push_back({});
+        sections.push_back(sec.addr);
         debugSections.push_back(isec);
       } else {
-        sections.push_back({});
+        sections.push_back(sec.addr);
         sections.back().subsections.push_back({0, isec});
       }
     }
   }
 }
 
 // Find the subsection corresponding to the greatest section offset that is <=
 // that of the given offset.
 //
 // offset: an offset relative to the start of the original InputSection (before
 // any subsection splitting has occurred). It will be updated to represent the
 // same location as an offset relative to the start of the containing
 // subsection.
 template <class T>
-static InputSection *findContainingSubsection(Subsections &subsections,
+static InputSection *findContainingSubsection(const Subsections &subsections,
                                               T *offset) {
   static_assert(std::is_same<uint64_t, T>::value ||
                     std::is_same<uint32_t, T>::value,
                 "unexpected type for offset");
   auto it = std::prev(llvm::upper_bound(
       subsections, *offset,
       [](uint64_t value, Subsection subsec) { return value < subsec.offset; }));
   *offset -= it->offset;
for (size_t i = 0; i < relInfos.size(); i++) {
     // so there is no need to merge opcode bits with address
     // bits. Therefore, it's easy and convenient to store addends in the
     // instruction-stream bytes that would otherwise contain zeroes. By
     // contrast, RISC ISAs such as ARM64 mix opcode bits with with
     // address bits so that bitwise arithmetic is necessary to extract
     // and insert them. Storing addends in the instruction stream is
     // possible, but inconvenient and more costly at link time.
 
-    int64_t pairedAddend = 0;
     relocation_info relInfo = relInfos[i];
+    bool isSubtrahend =
+        target->hasAttr(relInfo.r_type, RelocAttrBits::SUBTRAHEND);
+    if (isSubtrahend && StringRef(sec.sectname) == section_names::ehFrame) {
+      // __TEXT,__eh_frame only has symbols and SUBTRACTOR relocs when ld64 -r
+      // adds local "EH_Frame1" and "func.eh". Ignore them because they have
+      // gone unused by Mac OS since Snow Leopard (10.6), vintage 2009.
+      ++i;
+      continue;
+    }
+    int64_t pairedAddend = 0;
     if (target->hasAttr(relInfo.r_type, RelocAttrBits::ADDEND)) {
       pairedAddend = SignExtend64<24>(relInfo.r_symbolnum);
       relInfo = relInfos[++i];
     }
     assert(i < relInfos.size());
     if (!validateRelocationInfo(this, sec, relInfo))
       continue;
     if (relInfo.r_address & R_SCATTERED)
       fatal("TODO: Scattered relocations not supported");
 
-    bool isSubtrahend =
-        target->hasAttr(relInfo.r_type, RelocAttrBits::SUBTRAHEND);
     int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec.offset, relInfo);
     assert(!(embeddedAddend && pairedAddend));
     int64_t totalAddend = pairedAddend + embeddedAddend;
     Reloc r;
     r.type = relInfo.r_type;
     r.pcrel = relInfo.r_pcrel;
     r.length = relInfo.r_length;
     r.offset = relInfo.r_address;
if ((sym.n_type & N_TYPE) == N_SECT) {
       symbols[i] = parseNonSectionSymbol(sym, name);
     }
   }
 
   for (size_t i = 0; i < sections.size(); ++i) {
     Subsections &subsections = sections[i].subsections;
     if (subsections.empty())
       continue;
-
+    InputSection *lastIsec = subsections.back().isec;
+    if (lastIsec->getName() == section_names::ehFrame) {
+      // __TEXT,__eh_frame only has symbols and SUBTRACTOR relocs when ld64 -r
+      // adds local "EH_Frame1" and "func.eh". Ignore them because they have
+      // gone unused by Mac OS since Snow Leopard (10.6), vintage 2009.
+      continue;
+    }
     std::vector<uint32_t> &symbolIndices = symbolsBySection[i];
     uint64_t sectionAddr = sectionHeaders[i].addr;
     uint32_t sectionAlign = 1u << sectionHeaders[i].align;
 
-    InputSection *lastIsec = subsections.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 (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;
for (size_t i = 0; i < sections.size(); ++i) {
 
     // Calculate symbol sizes and create subsections by splitting the sections
     // along symbol boundaries.
     // We populate subsections by repeatedly splitting the last (highest
     // address) subsection.
     llvm::stable_sort(symbolIndices, [&](uint32_t lhs, uint32_t rhs) {
       return nList[lhs].n_value < nList[rhs].n_value;
     });
-    Subsection subsec = subsections.back();
     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;
+      Subsection &subsec = subsections.back();
       InputSection *isec = subsec.isec;
 
       uint64_t subsecAddr = sectionAddr + subsec.offset;
       size_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;
for (size_t j = 0; j < symbolIndices.size(); ++j) {
       // 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
       // emulating that behavior.
       nextIsec->align = MinAlign(sectionAlign, sym.n_value);
       subsections.push_back({sym.n_value - sectionAddr, nextIsec});
-      subsec = subsections.back();
     }
   }
 
   // Undefined symbols can trigger recursive fetch from Archives due to
   // LazySymbols. Process defined symbols first so that the relative order
   // between a defined symbol and an undefined symbol does not change the
   // symbol resolution behavior. In addition, a set of interconnected symbols
   // will all be resolved to the same file, instead of being resolved to
OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
                        StringRef sectName)
     : InputFile(OpaqueKind, mb) {
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<uint8_t> data = {buf, mb.getBufferSize()};
   ConcatInputSection *isec =
       make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16),
                                /*file=*/this, data);
   isec->live = true;
-  sections.push_back({});
+  sections.push_back(0);
   sections.back().subsections.push_back({0, isec});
 }
 
 ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
     : InputFile(ObjKind, mb), modTime(modTime) {
   this->archiveName = std::string(archiveName);
   if (target->wordSize == 8)
     parse<LP64>();
template <class LP> void ObjFile::parse() {
   for (size_t i = 0, n = sections.size(); i < n; ++i)
     if (!sections[i].subsections.empty())
       parseRelocations(sectionHeaders, sectionHeaders[i],
                        sections[i].subsections);
 
   parseDebugInfo();
   if (config->emitDataInCodeInfo)
     parseDataInCode();
+  if (compactUnwindSection)
     registerCompactUnwind();
 }
 
 void ObjFile::parseDebugInfo() {
   std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
   if (!dObj)
     return;
 
   auto *ctx = make<DWARFContext>(
void ObjFile::parseDataInCode() {
   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.
-  Section *cuSection = nullptr;
-  for (Section &section : sections) {
-    if (section.subsections.empty())
-      continue;
-    if (section.subsections[0].isec->getSegName() != segment_names::ld)
-      continue;
-    cuSection = &section;
-    break;
-  }
-  if (!cuSection)
-    return;
-
-  for (Subsection &subsection : cuSection->subsections) {
+  for (const Subsection &subsection : compactUnwindSection->subsections) {
     ConcatInputSection *isec = cast<ConcatInputSection>(subsection.isec);
     // Hack!! Since each CUE contains a different function address, if ICF
     // operated naively and compared the entire contents of each CUE, entries
     // with identical unwind info but belonging to different functions would
     // never be considered equivalent. To work around this problem, we slice
     // away the function address here. (Note that we do not adjust the offsets
     // of the corresponding relocations.) We rely on `relocateCompactUnwind()`
     // to correctly handle these truncated input sections.
     isec->data = isec->data.slice(target->wordSize);
 
     ConcatInputSection *referentIsec;
     for (auto it = isec->relocs.begin(); it != isec->relocs.end();) {
       Reloc &r = *it;
-      // We only wish to handle the relocation for CUE::functionAddress.
+      // CUE::functionAddress is at offset 0. Skip personality & LSDA relocs.
       if (r.offset != 0) {
         ++it;
         continue;
       }
       uint64_t add = r.addend;
       if (auto *sym = cast_or_null<Defined>(r.referent.dyn_cast<Symbol *>())) {
         // Check whether the symbol defined in this file is the prevailing one.
         // Skip if it is e.g. a weak def that didn't prevail.
for (auto it = isec->relocs.begin(); it != isec->relocs.end();) {
           [](Defined *d, uint64_t add) { return d->value < add; });
       // The relocation should point at the exact address of a symbol (with no
       // addend).
       if (symIt == referentIsec->symbols.end() || (*symIt)->value != add) {
         assert(referentIsec->wasCoalesced);
         ++it;
         continue;
       }
-      (*symIt)->compactUnwind = isec;
+      (*symIt)->unwindEntry = isec;
       // Since we've sliced away the functionAddress, we should remove the
       // corresponding relocation too. Given that clang emits relocations in
       // reverse order of address, this relocation should be at the end of the
       // vector for most of our input object files, so this is typically an O(1)
       // operation.
       it = isec->relocs.erase(it);
     }
   }

lld/MachO/InputSection.h

 constexpr const char codeSignature[] = "__code_signature";
 constexpr const char common[] = "__common";
 constexpr const char compactUnwind[] = "__compact_unwind";
 constexpr const char data[] = "__data";
 constexpr const char debugAbbrev[] = "__debug_abbrev";
 constexpr const char debugInfo[] = "__debug_info";
 constexpr const char debugStr[] = "__debug_str";
 constexpr const char ehFrame[] = "__eh_frame";
+constexpr const char gccExceptTab[] = "__gcc_except_tab";
 constexpr const char export_[] = "__export";
 constexpr const char dataInCode[] = "__data_in_code";
 constexpr const char functionStarts[] = "__func_starts";
 constexpr const char got[] = "__got";
 constexpr const char header[] = "__mach_header";
 constexpr const char indirectSymbolTable[] = "__ind_sym_tab";
 constexpr const char const_[] = "__const";
 constexpr const char lazySymbolPtr[] = "__la_symbol_ptr";

lld/MachO/InputSection.cpp

void ConcatInputSection::foldIdentical(ConcatInputSection *copy) {
   copy->symbols.clear();
 
   // Remove duplicate compact unwind info for symbols at the same address.
   if (symbols.empty())
     return;
   it = symbols.begin();
   uint64_t v = (*it)->value;
   for (++it; it != symbols.end(); ++it) {
-    if ((*it)->value == v)
-      (*it)->compactUnwind = nullptr;
+    Defined *d = *it;
+    if (d->value == v)
+      d->unwindEntry = nullptr;
     else
-      v = (*it)->value;
+      v = d->value;
   }
 }
 
 void ConcatInputSection::writeTo(uint8_t *buf) {
   assert(!shouldOmitFromOutput());
 
   if (getFileSize() == 0)
     return;

lld/MachO/MarkLive.cpp

void markLive() {
 
   auto addSym = [&](Symbol *s) {
     if (s->used)
       return;
     s->used = true;
     if (auto *d = dyn_cast<Defined>(s)) {
       if (d->isec)
         enqueue(d->isec, d->value);
-      if (d->compactUnwind)
-        enqueue(d->compactUnwind, 0);
+      if (d->unwindEntry)
+        enqueue(d->unwindEntry, 0);
     }
   };
 
   // Add GC roots.
   if (config->entry)
     addSym(config->entry);
   for (Symbol *sym : symtab->getSymbols()) {
     if (auto *defined = dyn_cast<Defined>(sym)) {

lld/MachO/Symbols.h

 
 public:
   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;
+  ConcatInputSection *unwindEntry = nullptr;
 };
 
 // This enum does double-duty: as a symbol property, it indicates whether & how
 // a dylib symbol is referenced. As a DylibFile property, it indicates the kind
 // of referenced symbols contained within the file. If there are both weak
 // and strong references to the same file, we will count the file as
 // strongly-referenced.
 enum class RefState : uint8_t { Unreferenced = 0, Weak = 1, Strong = 2 };

lld/MachO/Symbols.cpp

if (!isec->isFinal) {
     // knows that unfinalized functions will be out of range, so it is
     // expedient to return a contrived out-of-range address.
     return TargetInfo::outOfRangeVA;
   }
   return isec->getVA(value);
 }
 
 void Defined::canonicalize() {
-  if (compactUnwind)
-    compactUnwind = compactUnwind->canonical();
+  if (unwindEntry)
+    unwindEntry = unwindEntry->canonical();
   if (isec)
     isec = isec->canonical();
 }
 
 uint64_t DylibSymbol::getVA() const {
   return isInStubs() ? getStubVA() : Symbol::getVA();
 }
 
 void LazySymbol::fetchArchiveMember() { getFile()->fetch(sym); }

lld/MachO/UnwindInfoSection.cpp

UnwindInfoSection::UnwindInfoSection()
   align = 4;
 }
 
 void UnwindInfoSection::prepareRelocations() {
   // This iteration needs to be deterministic, since prepareRelocations may add
   // entries to the GOT. Hence the use of a MapVector for
   // UnwindInfoSection::symbols.
   for (const Defined *d : make_second_range(symbols))
-    if (d->compactUnwind)
-      prepareRelocations(d->compactUnwind);
+    if (d->unwindEntry)
+      prepareRelocations(d->unwindEntry);
 }
 
 // Record function symbols that may need entries emitted in __unwind_info, which
 // stores unwind data for address ranges.
 //
 // Note that if several adjacent functions have the same unwind encoding, LSDA,
 // and personality function, they share one unwind entry. For this to work,
 // functions without 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. Thus, we add function
 // symbols for each unique address regardless of whether they have associated
 // unwind info.
 void UnwindInfoSection::addSymbol(const Defined *d) {
-  if (d->compactUnwind)
+  if (d->unwindEntry)
     allEntriesAreOmitted = false;
   // We don't yet know the final output address of this symbol, but we know that
   // they are uniquely determined by a combination of the isec and value, so
   // we use that as the key here.
   auto p = symbols.insert({{d->isec, d->value}, d});
   // If we have multiple symbols at the same address, only one of them can have
   // an associated CUE.
-  if (!p.second && d->compactUnwind) {
-    assert(!p.first->second->compactUnwind);
+  if (!p.second && d->unwindEntry) {
+    assert(!p.first->second->unwindEntry);
     p.first->second = d;
   }
 }
 
 // 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>
 void UnwindInfoSectionImpl<Ptr>::prepareRelocations(ConcatInputSection *isec) {
   assert(!isec->shouldOmitFromOutput() &&
          "__compact_unwind section should not be omitted");
 
   // FIXME: Make this skip relocations for CompactUnwindEntries that
   // point to dead-stripped functions. That might save some amount of
   // work. But since there are usually just few personality functions
   // that are referenced from many places, at least some of them likely
   // live, it wouldn't reduce number of got entries.
   for (size_t i = 0; i < isec->relocs.size(); ++i) {
     Reloc &r = isec->relocs[i];
     assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
 
+    // Functions and LSDA entries always reside in the same object file as the
+    // compact unwind entries that references them, and thus appear as section
+    // relocs. There is no need to prepare them. We only prepare relocs for
+    // personality functions.
     if (r.offset % sizeof(CompactUnwindEntry<Ptr>) !=
         offsetof(CompactUnwindEntry<Ptr>, personality))
       continue;
 
     if (auto *s = r.referent.dyn_cast<Symbol *>()) {
+      // Personality functions are nearly always system-defined (e.g.,
+      // ___gxx_personality_v0 for C++) and relocated as dylib symbols.  When an
+      // application provides its own personality function, it might be
+      // referenced by an extern Defined symbol reloc, or a local section reloc.
       if (auto *defined = dyn_cast<Defined>(s)) {
         // XXX(vyng) This is a a special case for handling duplicate personality
         // symbols. Note that LD64's behavior is a bit different and it is
         // inconsistent with how symbol resolution usually work
         //
         // So we've decided not to follow it. Instead, simply pick the symbol
         // with the same name from the symbol table to replace the local one.
         //

 void UnwindInfoSectionImpl<Ptr>::relocateCompactUnwind(
     std::vector<CompactUnwindEntry<Ptr>> &cuEntries) {
   parallelForEachN(0, symbolsVec.size(), [&](size_t i) {
     uint8_t *buf = reinterpret_cast<uint8_t *>(cuEntries.data()) +
                    i * sizeof(CompactUnwindEntry<Ptr>);
     const Defined *d = symbolsVec[i].second;
     // Write the functionAddress.
     writeAddress(buf, d->getVA(), sizeof(Ptr) == 8 ? 3 : 2);
-    if (!d->compactUnwind)
+    if (!d->unwindEntry)
       return;
 
     // Write the rest of the CUE.
-    memcpy(buf + sizeof(Ptr), d->compactUnwind->data.data(),
-           d->compactUnwind->data.size());
-    for (const Reloc &r : d->compactUnwind->relocs) {
+    memcpy(buf + sizeof(Ptr), d->unwindEntry->data.data(),
+           d->unwindEntry->data.size());
+    for (const Reloc &r : d->unwindEntry->relocs) {
       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.
while (++foldEnd < cuIndices.end() &&
            canFoldEncoding(cuEntries[*foldEnd].encoding)) {
       // In most cases, we can just compare the values of cuEntries[*].lsda.
       // However, it is possible for -rename_section to cause the LSDA section
       // (__gcc_except_tab) to be finalized after the unwind info section. In
       // that case, we don't yet have unique addresses for the LSDA entries.
       // So we check their relocations instead.
       // FIXME: should we account for an LSDA at an absolute address? ld64 seems
       // to support it, but it seems unlikely to be used in practice.
-      Reloc *lsda1 =
-          findLsdaReloc(symbolsVec[*foldBegin].second->compactUnwind);
-      Reloc *lsda2 = findLsdaReloc(symbolsVec[*foldEnd].second->compactUnwind);
+      Reloc *lsda1 = findLsdaReloc(symbolsVec[*foldBegin].second->unwindEntry);
+      Reloc *lsda2 = findLsdaReloc(symbolsVec[*foldEnd].second->unwindEntry);
       if (lsda1 == nullptr && lsda2 == nullptr)
         continue;
       if (lsda1 == nullptr || lsda2 == nullptr)
         break;
       if (lsda1->referent != lsda2->referent)
         break;
       if (lsda1->addend != lsda2->addend)
         break;
if (i < cuIndices.size() &&
       i = page.entryIndex + page.entryCount;
     } else {
       page.kind = UNWIND_SECOND_LEVEL_COMPRESSED;
     }
   }
 
   for (size_t idx : cuIndices) {
     lsdaIndex[idx] = entriesWithLsda.size();
-    if (findLsdaReloc(symbolsVec[idx].second->compactUnwind))
+    const Defined *d = symbolsVec[idx].second;
+    if (findLsdaReloc(d->unwindEntry))
       entriesWithLsda.push_back(idx);
   }
 
   // compute size of __TEXT,__unwind_info section
   level2PagesOffset = sizeof(unwind_info_section_header) +
                       commonEncodings.size() * sizeof(uint32_t) +
                       personalities.size() * sizeof(uint32_t) +
                       // The extra second-level-page entry is for the sentinel
void UnwindInfoSectionImpl<Ptr>::writeTo(uint8_t *buf) const {
   iep++;
 
   // LSDAs
   auto *lep =
       reinterpret_cast<unwind_info_section_header_lsda_index_entry *>(iep);
   for (size_t idx : entriesWithLsda) {
     const CompactUnwindEntry<Ptr> &cu = cuEntries[idx];
     const Defined *d = symbolsVec[idx].second;
-    if (Reloc *r = findLsdaReloc(d->compactUnwind)) {
+    if (Reloc *r = findLsdaReloc(d->unwindEntry)) {
       uint64_t va;
       if (auto *isec = r->referent.dyn_cast<InputSection *>()) {
         va = isec->getVA(r->addend);
       } else {
         auto *sym = r->referent.get<Symbol *>();
         va = sym->getVA() + r->addend;
       }
       lep->lsdaOffset = va - in.header->addr;