[lld-macho] __eh_frame: relocate & prune redundant entries

[gkm]

Summary

Work in progress ...
See the large block comment above ObjFile::registerUnwindEntries() in lld/MachO/InputFiles.cpp.

[gkm]

• major update

[gkm]

Add address member to ParsedSection. Many other updates.

[gkm]

• factor-out NFC changes into D114017
• many updates

lld/MachO/Driver.cpp

static void gatherInputSections() {
   int inputOrder = 0;
   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);
+          if (isec->getName() == section_names::compactUnwind ||
+              isec->getName() == section_names::ehFrame) {
+            // exception info inputs were already processed in
+            // ObjFile::registerUnwindEntries() at object-file parse time.
             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

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();
     // ICF can't fold functions with unwind info
     if (isHashable)
       for (Defined *d : isec->symbols)
-        if (d->compactUnwind) {
+        if (d->unwindEntry) {
           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();
+  void splitEhFrame();
+  void registerUnwindEntries();
 };
 
 // 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

 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "lld/Common/DWARF.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/ADT/iterator.h"
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/TextAPI/Architecture.h"
 #include "llvm/TextAPI/InterfaceFile.h"
 
 using namespace llvm;
+using namespace llvm::dwarf;
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::macho;
 
 // Returns "<internal>", "foo.a(bar.o)", or "baz.o".
 std::string lld::toString(const InputFile *f) {
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 {};
 }
 
+// Parse the sequence of sections within a single LC_SEGMENT(_64).
+// Split each section into subsections.
 template <class Section>
 void ObjFile::parseSections(ArrayRef<Section> sections) {
   subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
   for (const Section &sec : sections) {
     StringRef name =
         StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
if (sectionType(sec.flags) == S_CSTRING_LITERALS ||
         cast<CStringInputSection>(isec)->splitIntoPieces();
       } else {
         isec = make<WordLiteralInputSection>(segname, name, this, data, align,
                                              flags);
       }
       subsections.push_back({{0, isec}});
     } else if (auto recordSize = getRecordSize(segname, name)) {
       splitRecords(*recordSize);
+    } else if (name == section_names::ehFrame) {
+      subsections.push_back({});
+      if (data.size() == 0)
+        return;
+      auto *isec =
+          make<ConcatInputSection>(segname, name, this, data, align, flags);
+      subsections.back().push_back({0, isec});
+      splitEhFrame();
     } 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 map to ensure indices line up for the remaining sections.
       // TODO: Evaluate whether the bitcode metadata is needed.
       subsections.push_back({});
if (sectionType(sec.flags) == S_CSTRING_LITERALS ||
         debugSections.push_back(isec);
       } else {
         subsections.push_back({{0, isec}});
       }
     }
   }
 }
 
+static void fatalAt(const InputSection *isec, const ArrayRef<uint8_t> &data,
+                    const Twine &msg) {
+  uint64_t offset = data.data() - isec->data.data();
+  fatal("corrupted __eh_frame at offset=" + utohexstr(offset) + ": " + msg +
+        "\n>>> defined in " + toString(isec->getFile()));
+}
+
+// Parse DWARF CIE (Common Information Entry) & FDEs (Frame Description
+// Entries). There is one CIE per object file at subsection[0], and one FDE per
+// function at subsction[1..N].
+void ObjFile::splitEhFrame() {
+  SubsectionMap &subsecMap = subsections.back();
+  SubsectionEntry &entry = subsecMap.back();
+  ConcatInputSection *isec = cast<ConcatInputSection>(entry.isec);
+  ArrayRef<uint8_t> data = isec->data;
+  for (uint64_t off = 0;;) {
+    if (data.size() < 4)
+      fatalAt(isec, data, "CIE/FDE too small");
+    const uint8_t *buf0 = data.data();
+    const uint8_t *buf = buf0;
+    uint64_t length = read32le(buf);
+    buf += 4;
+    if (length == UINT32_MAX) {
+      length = read64le(buf);
+      buf += 8;
+    }
+    length += (buf - buf0);
+    if (length > data.size())
+      fatalAt(isec, data, "CIE/FDE ends past the end of the section");
+    uint32_t id = read32le(buf);
+    if (off == 0 && id > 0)
+      fatalAt(isec, data, "First record must be a CIE");
+    else if (off > 0 && id == 0)
+      fatalAt(isec, data, "An object file can only have one CIE");
+    isec->data = data.take_front(length);
+    data = data.drop_front(length);
+    if (data.size() == 0)
+      break;
+    isec = make<ConcatInputSection>(*isec);
+    off += length;
+    subsecMap.push_back({off, 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.
 static InputSection *findContainingSubsection(SubsectionMap &map,
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();
+  registerUnwindEntries();
 }
 
 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;
+// * The following blog entries provide an for an overview of DWARF
+//   formats for exception-unwind data:
+//   https://www.airs.com/blog/archives/460 about .eh_frame
+//   https://www.airs.com/blog/archives/464 about .gcc_except_table
+//
+// * Though it is irrelevant to MachO, the complete blog series on DWARF
+//   unwinding formats includes this post on a Linux-specific section:
+//   https://www.airs.com/blog/archives/462 about .eh_frame_hdr
+//
+// * Here are more reference documents for exception handling:
+//   https://llvm.org/docs/ExceptionHandling.html
+//   https://refspecs.linuxfoundation.org/abi-eh-1.22.html
+//   https://github.com/itanium-cxx-abi/cxx-abi/blob/main/exceptions.pdf
+//   http://www.dwarfstd.org/doc/DWARF5.pdf
+//
+// * Processing unwind info involves a complex mesh of four input sections:
+//   (1) __LD,__compact_unwind: vector of CUE (Compact Unwind Entry)
+//   (2) __TEXT,__eh_frame: sequence of DWARF records (see below)
+//   (3) __TEXT,__gcc_except_tab: LSDA (Language Specific Data Area)
+//   (4) __TEXT,__text: Functions associated with unwind info
+//
+// * The __eh_frame section contains two types of record: CIE (Common
+//   Information Entry - one per object file) and FDE (Frame Description Entry -
+//   one per function). CIEs are simple to deduplicate, but since an FDE's
+//   content is logically tied to its associated function body, we must
+//   deduplicate function+FDE during ICF.
+//
+// * CUE contains relocation_info for the __text entrypoint of its associated
+//   function. It can also contain relocation_info for the optional personality
+//   function and LSDA
+//
+// * CIE can contain relocation_info to an optional personality function
+//
+// * FDE references the __text entrypoint of its associated function, but the
+//   compiler generates no relocation_info
+//
+// * FDE can reference __gcc_except_tab for LSDA, but again, there is
+//   no compiler-generated relocation_info
+//
+// * The compiler will produce unwind information for a function according to
+//   one of four cases, and the linker must respond accordingly:
+//   (1) no unwind info: linker must create a degenerate CUE
+//   (2) CUE only: no action necessary from linker
+//   (3) CUE and FDE: linker must discard the FDE
+//   (4) FDE only: linker must create a special CUE that references the FDE
+//
+//   Note: case #3 should disappear over time. There is no reason for the
+//   compiler to produce both CUE and FDE, since CUE has been the default format
+//   for many years, and there is no reason to accommodate ancient runtimes that
+//   can only handle FDEs. Even so, in mid-2021 most LLVM MachO compiler targets
+//   still produce both CUEs & FDEs. Unfortunately, all of the complexity
+//   in transforming input to output for section __TEXT,__eh_frame pertains to
+//   case #3, which shouldn't exist anymore. Ugh.
+//
+// * When complete, the linker output will contain CUEs for every function,
+//   including those that are merely references to DWARF FDEs. The output will
+//   contain FDEs only for functions whose unwind info cannot be represented as
+//   a full CUE. The output will have a __TEXT,__eh_frame section only if there
+//   are one or more FDEs.
+
+static void registerCompactUnwindEntries(SubsectionMap &subsectionMap);
+static void registerEhFrameUnwindEntries(SubsectionMap &subsectionMap);
+
+// Create pointers from symbols to their associated unwind entries, either
+// compact (CUEs) or DWARF (FDEs).
+
+void ObjFile::registerUnwindEntries() {
+  // First, locate the unwind info sections.
+  SubsectionMap *cuSubsectionMap = nullptr;
+  SubsectionMap *ehSubsectionMap = nullptr;
   for (SubsectionMap &map : subsections) {
     if (map.empty())
       continue;
-    if (map[0].isec->getSegName() != segment_names::ld)
-      continue;
-    cuSubsecMap = &map;
-    break;
-  }
-  if (!cuSubsecMap)
-    return;
+    StringRef name = map[0].isec->getName();
+    if (name == section_names::compactUnwind)
+      cuSubsectionMap = &map;
+    else if (name == section_names::ehFrame)
+      ehSubsectionMap = &map;
+  }
+  if (cuSubsectionMap)
+    registerCompactUnwindEntries(*cuSubsectionMap);
+  if (ehSubsectionMap)
+    registerEhFrameUnwindEntries(*ehSubsectionMap);
 
-  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 *>());
-      }
-      if (referentIsec->getSegName() != segment_names::text)
-        error("compact unwind references address in " + toString(referentIsec) +
-              " which is not in segment __TEXT");
-      // 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);
+static Defined *findFunctionSymbol(const macho::Reloc &r) {
+  uint64_t value = r.addend;
+  if (auto *sym =
+          cast_or_null<Defined>(r.referent.dyn_cast<macho::Symbol *>())) {
+    value += sym->value;
+      referentIsec->symbols, value,
+      [](Defined *d, uint64_t val) { return d->value < val; });
+  if (it == referentIsec->symbols.end() || (*it)->value != value) {
+    return nullptr;
+  }
+  return *it;
+}
+
+static void registerCompactUnwindEntries(SubsectionMap &subsectionMap) {
+  for (SubsectionEntry &entry : subsectionMap) {
+    ConcatInputSection *isec = cast<ConcatInputSection>(entry.isec);
+    for (const macho::Reloc &r : isec->relocs) {
+      // Skip the personality and LSDA relocs, which have non-zero offset.
+      if (r.offset)
         continue;
+      if (Defined *d = findFunctionSymbol(r)) {
+        d->unwindEntry = isec;
+        d->hasCompactUnwind = true;
+      }
+    }
+  }
+}
+
+// These are the encodings we expect to see for all __eh_frame CIEs and FDEs.
+
+// Object files only contain relocation records for personality function
+// addresses in the CIE. We must synthesize Reloc entries in FDEs for the LSDA
+// and function entrypoint addresses. We have already registered the CUEs, so
+// function symbols with CUEs have Defined::hasCompactUnwind == true. When
+// a function has a CUE, we ignore the FDE.
+
+static void registerEhFrameUnwindEntries(SubsectionMap &subsectionMap) {
+  const uint8_t PersEncode =
+      DW_EH_PE_sdata4 | DW_EH_PE_pcrel | DW_EH_PE_indirect;
+  const uint8_t FuncEncode = DW_EH_PE_pcrel | DW_EH_PE_absptr;
+  const uint8_t LsdaEncode = DW_EH_PE_pcrel | DW_EH_PE_absptr;
+  uint8_t persEncode;
+  uint8_t lsdaEncode;
+  uint8_t funcEncode;
+  for (SubsectionEntry &entry : subsectionMap) {
+    ConcatInputSection *isec = cast<ConcatInputSection>(entry.isec);
+    const uint8_t *buf = isec->data.data();
+    buf += 4; // skip length
+    uint32_t id = read32le(buf);
+    buf += 5; // skip ID & version
+    if (id == 0) {
+      // CIE:
+      // Augmentation has two pieces: format string--which only appears in
+      // CIEs--and data--which appears in both CIEs. The string contains the
+      // format, and the data follows the format. The augmentation data for 'P'
+      // (personality) appears in the CIE, while data for 'L' (LSDA) and 'R'
+      // (function address & size) appear in the FDE. When we parse a CIE,
+      // we must save info extracted from the augmentation string in order
+      // to properly parse the FDEs that immediately follow it.
+      persEncode = lsdaEncode = funcEncode = DW_EH_PE_omit;
+      auto *augmentString = reinterpret_cast<const char *>(buf);
+      buf += strlen(augmentString) + 1; // skip augmentation string
+      buf += 3; // skip code align, data align, return addr reg
+      while (*augmentString) {
+        // Numbers below are encoded as ULEB128, but expected quantities
+        // fit within a single byte, so we can skip the parsing machinery.
+        switch (*augmentString++) {
+        case 'z':
+          assert(*buf < 128);
+          buf++; // skip augmentation data length
+          break;
+        case 'P':
+          persEncode = *buf++;
+          assert(persEncode == PersEncode);
+          buf += 4;
+          break;
+        case 'L':
+          lsdaEncode = *buf++;
+          assert(lsdaEncode == LsdaEncode);
+          break;
+        case 'R':
+          funcEncode = *buf++;
+          assert(funcEncode == FuncEncode);
+          break;
+        case 'S': // signal trampoline
+        case 'B': // signing b-key
+          break;
+        default:
+          llvm_unreachable("unknown DWARF EH augmentation char");
+        }
+      }
+    } else {
+      // FDE:
+      uint8_t length = target->wordSize == 8 ? 3 : 2;
+      uint64_t offset = buf - isec->data.data();
+      isec->relocs.push_back({/*type=*/GENERIC_RELOC_VANILLA,
+                              /*pcrel=*/true, length, offset,
+                              /*addend=*/0, /*referent=*/nullptr});
+      macho::Reloc &r = isec->relocs.back();
+      if (Defined *d = findFunctionSymbol(r)) {
+        if (d->hasCompactUnwind)
+          continue;
+        r.referent = d;
+        assert(d->unwindEntry == nullptr);
+        d->unwindEntry = isec;
+        d->hasDwarfFDE = true;
+        if (lsdaEncode != DW_EH_PE_omit) {
+          uint64_t offset = buf - isec->data.data() + 2 * target->wordSize;
+          isec->relocs.push_back({/*type=*/GENERIC_RELOC_VANILLA,
+                                  /*pcrel=*/true, length, offset,
+                                  /*addend=*/0,
+                                  /*referent=*/});
+        }
       }
-      (*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) {

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) {
 
   // 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;
+      (*it)->unwindEntry = nullptr;
     else
       v = (*it)->value;
   }
 }
 
 void ConcatInputSection::writeTo(uint8_t *buf) {
   assert(!shouldOmitFromOutput());
 

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:
   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;
+  // hasCompactUnwind -> unwindEntry points to a CUE
+  // !hasCompactUnwind && hasDwarfFDE -> unwindEntry points to an FDE
+  ConcatInputSection *unwindEntry = 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;
   // Symbols marked referencedDynamically won't be removed from the output's
   // symbol table by tools like strip. In theory, this could be set on arbitrary
   // symbols in input object files. In practice, it's used solely for the
   // synthetic __mh_execute_header symbol.
   // This is information for the static linker, and it's also written to the
   // output file's symbol table for tools running later (such as `strip`).
   bool referencedDynamically : 1;
   // Set on symbols that should not be removed by dead code stripping.
   // Set for example on `__attribute__((used))` globals, or on some Objective-C
   // metadata. This is information only for the static linker and not written
   // to the output.
   bool noDeadStrip : 1;
+  // unwindEntry can be compact (CUE) and/or DWARF (FDE). When both are present,
+  // the CUE takes precedence. Older MC emitted both, and expected the linker to
+  // discard the redundant FDEs. Newer MC does the right thing, which is that
+  // when a frame can be represented by a CUE, emit only the CUE. When a frame
+  // is too complex for a CUE, then emit only an FDE. When a frame has no unwind
+  // info, older MC doesn't emit the trivial no-op CUE, but always emits the
+  // trivial no-op FDE. In this case, LD64 preserves the FDE since there is no
+  // CUE to override it. LLD does the right thing, which is to synthesize the
+  // no-op CUE.
+  bool hasCompactUnwind : 1;
+  bool hasDwarfFDE : 1;
 
 private:
   const bool weakDef : 1;
   const bool external : 1;
 };
 
 // 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

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/SyntheticSections.h

 namespace lld {
 namespace macho {
 
 class Defined;
 class DylibSymbol;
 class LoadCommand;
 class ObjFile;
 class UnwindInfoSection;
+class EhFrameSection;
 
 class SyntheticSection : public OutputSection {
 public:
   SyntheticSection(const char *segname, const char *name);
   virtual ~SyntheticSection() = default;
 
   static bool classof(const OutputSection *sec) {
     return sec->kind() == SyntheticKind;
struct InStruct {
   LazyBindingSection *lazyBinding = nullptr;
   ExportSection *exports = nullptr;
   GotSection *got = nullptr;
   TlvPointerSection *tlvPointers = nullptr;
   LazyPointerSection *lazyPointers = nullptr;
   StubsSection *stubs = nullptr;
   StubHelperSection *stubHelper = nullptr;
   UnwindInfoSection *unwindInfo = nullptr;
+  EhFrameSection *ehFrame = nullptr;
   ConcatInputSection *imageLoaderCache = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 void createSyntheticSymbols();
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/UnwindInfoSection.h

llvm::MapVector<std::pair<const InputSection *, uint64_t /*Defined::value*/>,
                   const Defined *>
       symbols;
   uint64_t unwindInfoSize = 0;
   bool allEntriesAreOmitted = true;
 };
 
 UnwindInfoSection *makeUnwindInfoSection();
 
+class EhFrameSection : public SyntheticSection {
+public:
+  EhFrameSection();
+
+  bool isNeeded() const override { return !allEntriesAreOmitted; }
+  uint64_t getSize() const override { return ehFrameSize; }
+  void finalize() override;
+  void writeTo(uint8_t *buf) const override;
+
+  // void addInput(ConcatInputSection *);
+  void prepareRelocations();
+
+  void prepareRelocations(ConcatInputSection *);
+
+  llvm::MapVector<std::pair<const InputSection *, uint64_t /*Defined::value*/>,
+                  const Defined *>
+      symbols;
+  ConcatOutputSection *ehFrameSection;
+  uint64_t ehFrameSize = 0;
+  bool allEntriesAreOmitted = true;
+};
+
+EhFrameSection *makeEhFrameSection();
+
 } // namespace macho
 } // namespace lld
 
 #endif

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 relocateCompactUnwind(std::vector<CompactUnwindEntry<Ptr>> &);
+  void relocateCompactUnwindEntries(std::vector<CompactUnwindEntry<Ptr>> &);
   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;
   SmallDenseMap<std::pair<InputSection *, uint64_t /* addend */>, Symbol *>
       personalityTable;
   std::vector<unwind_info_section_header_lsda_index_entry> lsdaEntries;
   // Map of function offset (from the image base) to an index within the LSDA
   // array.
   DenseMap<uint32_t, uint32_t> functionToLsdaIndex;
+  // std::vector<EhFrameEntry<Ptr>> ehVector;
   std::vector<CompactUnwindEntry<Ptr>> cuVector;
   std::vector<CompactUnwindEntry<Ptr> *> cuPtrVector;
   std::vector<SecondLevelPage> secondLevelPages;
   uint64_t level2PagesOffset = 0;
 };
 
 UnwindInfoSection::UnwindInfoSection()
     : SyntheticSection(segment_names::text, section_names::unwindInfo) {
   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.
+// actually end up in the final binary. Second, personality-function pointers
+// usually 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 this 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 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.
         //
static ConcatInputSection *checkTextSegment(InputSection *isec) {
   return cast<ConcatInputSection>(isec);
 }
 
 // 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>
-void UnwindInfoSectionImpl<Ptr>::relocateCompactUnwind(
+void UnwindInfoSectionImpl<Ptr>::relocateCompactUnwindEntries(
     std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
   auto symbolsVec = symbols.takeVector();
   parallelForEachN(0, symbolsVec.size(), [&](size_t i) {
     uint8_t *buf = reinterpret_cast<uint8_t *>(cuVector.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, d->compactUnwind->data.data(), d->compactUnwind->data.size());
-    for (const Reloc &r : d->compactUnwind->relocs) {
+    memcpy(buf, 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.
template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
   // At this point, the address space for __TEXT,__text has been
   // assigned, so we can relocate the __LD,__compact_unwind entries
   // into a temporary buffer. Relocation is necessary in order to sort
   // the CU entries by function address. Sorting is necessary so that
   // we can fold adjacent CU entries with identical
   // encoding+personality+lsda. Folding is necessary because it reduces
   // the number of CU entries by as much as 3 orders of magnitude!
   cuVector.resize(symbols.size());
-  relocateCompactUnwind(cuVector);
+  relocateCompactUnwindEntries(cuVector);
 
   // Rather than sort & fold the 32-byte entries directly, we create a
   // vector of pointers to entries and sort & fold that instead.
   cuPtrVector.reserve(cuVector.size());
   for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
     cuPtrVector.emplace_back(&cuEntry);
   llvm::sort(cuPtrVector, [](const CompactUnwindEntry<Ptr> *a,
                              const CompactUnwindEntry<Ptr> *b) {

 }
 
 UnwindInfoSection *macho::makeUnwindInfoSection() {
   if (target->wordSize == 8)
     return make<UnwindInfoSectionImpl<uint64_t>>();
   else
     return make<UnwindInfoSectionImpl<uint32_t>>();
 }
+
+EhFrameSection::EhFrameSection()
+    : SyntheticSection(segment_names::text, section_names::ehFrame) {
+  align = 4;
+  ehFrameSection = make<ConcatOutputSection>(section_names::ehFrame);
+}
+
+void EhFrameSection::prepareRelocations() {
+  for (const Defined *d : make_second_range(symbols))
+    if (d->unwindEntry)
+      prepareRelocations(d->unwindEntry);
+}
+
+void EhFrameSection::prepareRelocations(ConcatInputSection *isec) {
+  // TODO(gkm): write me
+}
+
+void EhFrameSection::finalize() {
+  // TODO(gkm): write me
+}
+
+void EhFrameSection::writeTo(uint8_t *buf) const {
+  // TODO(gkm): write me
+}
+
+#if 0
+
+void EhFrameSection::addInput(EhFrameSection *isec) {
+  assert(isec->getName() == section_names::ehFrame);
+  isec->parent = ehFrameSection;
+  ehFrameSection->addInput(isec);
+}
+
+EhFrameSection *macho::makeEhFrameSection() {
+  if (target->wordSize == 8)
+    return make<EhFrameSectionImpl<uint64_t>>();
+  else
+    return make<EhFrameSectionImpl<uint32_t>>();
+}
+
+#endif

lld/MachO/Writer.cpp

for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
         r.referent = referentIsec->canonical();
         if (!r.pcrel)
           in.rebase->addEntry(isec, r.offset);
       }
     }
   }
 
   in.unwindInfo->prepareRelocations();
+  in.ehFrame->prepareRelocations();
 }
 
 void Writer::scanSymbols() {
   TimeTraceScope timeScope("Scan symbols");
   for (Symbol *sym : symtab->getSymbols()) {
     if (auto *defined = dyn_cast<Defined>(sym)) {
       if (!defined->isLive())
         continue;
void macho::createSyntheticSections() {
   in.lazyBinding = make<LazyBindingSection>();
   in.exports = make<ExportSection>();
   in.got = make<GotSection>();
   in.tlvPointers = make<TlvPointerSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.unwindInfo = makeUnwindInfoSection();
+  in.ehFrame = make<EhFrameSection>();
 
   // This section contains space for just a single word, and will be used by
   // dyld to cache an address to the image loader it uses.
   uint8_t *arr = bAlloc.Allocate<uint8_t>(target->wordSize);
   memset(arr, 0, target->wordSize);
   in.imageLoaderCache = make<ConcatInputSection>(
       segment_names::data, section_names::data, /*file=*/nullptr,
       ArrayRef<uint8_t>{arr, target->wordSize},