[lld-macho][nfc] rename parsed-section types & variables

[gkm]

Summary

This is an NFC diff that prepares for pruning & relocating __eh_frame.

Along the way, I made the following changes to ...

• clarify usage of section vs. subsection
• remove map & vec from type names
• disambiguate class Section from template parameter SectionHeader.

[gkm]

I missed a rename ...

• s/Subsection/ParsedSubsection/

[gkm]

lld/MachO/Writer.cpp

506

Gotta revert this

[int3]

The Map instead of Vec thing was intentional... a vector of pairs is semantically a map.

Not a huge fan of the Parsed stuff either, I don't think there's much confusion about when we are working with parsed vs serialized structures...

As for the offset member... seems kind of hard to evaluate it without the context of the __eh_frame.

[gkm]

In D113241#3113825, @int3 wrote:

The Map instead of Vec thing was intentional... a vector of pairs is semantically a map.

I was thinking of "map" operationally, i.e., used for associative lookups.

Not a huge fan of the Parsed stuff either, I don't think there's much confusion about when we are working with parsed vs serialized structures...

That sounds like mitigated speech for "veto". Correct me if I misinterpret.

As for the offset member... seems kind of hard to evaluate it without the context of the __eh_frame.

FYI, it morphed into an address member. I'll put-up a new __eh_frame diff.

[gkm]

In D113241#3113825, @int3 wrote:

Not a huge fan of the Parsed stuff either, I don't think there's much confusion about when we are working with parsed vs serialized structures...

Prepending Parsed was a late change and I'm OK with reversing it. My concern was that Section is misleading, since it is not a base class of InputSection or OutputSection as the name might suggest. No big deal though. The more important change was s/Section/SectionHeader/ for the template arg.

[thevinster]

I'm a big fan of the variable names switching from s/subsections/sections, s/subsectionMap/subsections. It's clearer to me that there are layers whereas the original subsections->subsectionMap layer is not as easily decipherable. Section->SectionHeader makes sense to me, but I would like it if we had some consistency, which means also renaming SegmentCommand->SegmentCommandHeader, NList->NListHeader, etc.

[gkm]

In D113241#3114368, @thevinster wrote:

I'm a big fan of the variable names switching from s/subsections/sections, s/subsectionMap/subsections. It's clearer to me that there are layers whereas the original subsections->subsectionMap layer is not as easily decipherable.

Yes, that really is the crux of this effort. It is good to hear that this change helps newcomers to the code.

Section->SectionHeader makes sense to me, but I would like it if we had some consistency, which means also renaming SegmentCommand->SegmentCommandHeader, NList->NListHeader, etc.

In InputFiles.cpp, sections are front & center, and disambiguating the several varieties of them is important. Section->SectionHeader has value because it offloads the overloaded name Section.

OTOH, SegmentCommand is not overloaded, and used only once. Nlist is not overloaded, and isn't even a header but rather an element in a vector.

[thevinster]

OTOH, SegmentCommand is not overloaded, and used only once. Nlist is not overloaded, and isn't even a header but rather an element in a vector.

Makes sense. I guess what I was getting at is whether we can make it more obvious that Nlist or SegmentCommand are structures defined from MachOStructs.h. If this is the best we can do, then it's fine as is, but assuming we could find such a pattern, then it could also apply to Section to make it consistent.

[gkm]

Major FUBAR revision -- ignore this one.

[gkm]

Revert previous revision

[oontvoo]

also +1 to the s/section/subsection and SectionHeader renaming(much clearer now)

I've no strong opinion on Map vs Vec but generally I'm not a fan of putting the type (ie., vect, list, map, etc) into the variable name anyway. Seems redundant.
Perhaps if we could make the name clear enough, then it wouldn't be necessary to add the extra clarification.

lld/MachO/InputSection.cpp

80

IMHO, it is not particularly clearer to say ParsedSection here

[int3]

That sounds like mitigated speech for "veto". Correct me if I misinterpret.

It's vote, not veto ;)

Yeah the s/subsections/sections/ and s/subsecMap/subsections/ thing looks reasonable. +1 to Vy's opinion that types should ideally be left out of the name anyway; let's drop both the Map and Vec.

I agree with Vincent's opinion that Section -> SectionHeader breaks consistency with the other MachOStructs.h types. The convention I was going for was to have all non-serialized section/segment types be prefixed by "Input" or "Output". But I don't feel super strongly about this, so if you prefer SectionHeader, go for it.

[gkm]

• revert Parsed prefix to shorten class names and lower impact of this diff

[thevinster]

Gucci.

lld/MachO/InputSection.cpp

80

Missed this part?

[oontvoo]

In D113241#3132610, @thevinster wrote:

Gucci.

👜 ???

[oontvoo]

lld/MachO/InputSection.cpp

80

right :) maybe just print the invalid type here

[thevinster]

In D113241#3132635, @oontvoo wrote:

In D113241#3132610, @thevinster wrote:

Gucci.

👜 ???

Haha. https://slangit.com/meaning/gucci

[int3]

Thanks!

[gkm]

• fix one remaining s/ParsedSection/Section/

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 ParsedSection &section : file->sections) {
+      const ParsedSubsecVec &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 ParsedSubsection &subsection : section.subsections) {
+      for (const ParsedSubsection &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

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

 } // 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 ParsedSubsection {
   uint64_t offset = 0;
   InputSection *isec = nullptr;
 };
 
 using ParsedSubsecVec = std::vector<ParsedSubsection>;
 
 struct ParsedSection {
-  // uint64_t offset = 0; // TODO(gkm): this will debut with __eh_frame hacking
+  uint64_t address = 0;
   ParsedSubsecVec subsections;
+  ParsedSection(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:
+  ParsedSection *textSection = nullptr;
+  ParsedSection *staticInitSection = nullptr;
+  ParsedSection *gccExceptTabSection = nullptr;
+  ParsedSection *compactUnwindSection = nullptr;
+  ParsedSection *ehFrameSection = 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);
   template <class SectionHeader>
   void parseRelocations(ArrayRef<SectionHeader> sectionHeaders,
                         const SectionHeader &, ParsedSubsecVec &);
   void parseDebugInfo();
   void parseDataInCode();
-  void registerCompactUnwind();
+  void splitEhFrame();
+  void registerCompactUnwindEntries();
+  void registerEhFrameUnwindEntries();
+  Defined *findFunctionSymbol(const Reloc &r); // for __compact_unwind
+  Defined *findFunctionSymbol(uint64_t value); // for __eh_frame
+  Defined *findLSDASymbol(uint64_t value);     // for __eh_frame
 };
 
 // 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) {
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;
-
       ParsedSubsecVec &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 (name == section_names::ehFrame) {
+      sections.push_back(sec.addr);
+      if (data.size() == 0)
+        return;
+      auto *isec =
+          make<ConcatInputSection>(segname, name, this, data, align, flags);
+      ehFrameSection = &sections.back();
+      sections.back().subsections.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 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});
+        if (name == section_names::text)
+          textSection = &sections.back();
+        else if (name == section_names::staticInit)
+          staticInitSection = &sections.back();
+        else if (name == section_names::gccExceptTab)
+          gccExceptTabSection = &sections.back();
       }
     }
   }
 }
 
+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() {
+  ParsedSubsecVec &subsections = sections.back().subsections;
+  ConcatInputSection *isec = cast<ConcatInputSection>(subsections.back().isec);
+  ArrayRef<uint8_t> data = isec->data;
+  uint64_t off = 0;
+  while (true) {
+    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");
+    isec->data = data.take_front(length);
+    data = data.drop_front(length);
+    if (data.size() == 0)
+      break;
+    isec = make<ConcatInputSection>(*isec);
+    off += length;
+    subsections.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(ParsedSubsecVec &subsections,
-                                              uint64_t *offset) {
+static InputSection *
+findContainingSubsection(const ParsedSubsecVec &subsections, uint64_t *offset) {
   auto it = std::prev(llvm::upper_bound(
       subsections, *offset, [](uint64_t value, ParsedSubsection subsec) {
         return value < subsec.offset;
       }));
   *offset -= it->offset;
   return it->isec;
 }
 
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();
-  registerCompactUnwind();
+  if (compactUnwindSection)
+    registerCompactUnwindEntries();
+  if (false && ehFrameSection)
+    registerEhFrameUnwindEntries();
 }
 
 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.
-  ParsedSection *cuSection = nullptr;
-  for (ParsedSection &section : sections) {
-    if (section.subsections.empty())
-      continue;
-    if (section.subsections[0].isec->getSegName() != segment_names::ld)
-      continue;
-    cuSection = &section;
-    break;
-  }
-  if (!cuSection)
-    return;
+// * 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.
+
+// Create pointers from symbols to their associated unwind entries, either
+// compact (CUEs) or DWARF (FDEs).
+
+static Defined *findSymbol(const ConcatInputSection *isec, uint64_t value) {
+  // 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(isec->symbols, value, [](Defined *d, uint64_t val) {
+        return d->value < val;
+      });
+  // The relocation should point at the exact address of a symbol (with no
+  // addend).
+  if (it != isec->symbols.end() && (*it)->value == value)
+    return *it;
+  return nullptr;
 
-  for (ParsedSubsection &subsection : cuSection->subsections) {
-    ConcatInputSection *isec = cast<ConcatInputSection>(subsection.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 *findSymbol(const ParsedSection &section, uint64_t value) {
+  value -= section.address;
+  auto it = llvm::lower_bound(section.subsections, value,
+                              [](const ParsedSubsection &subsec, uint64_t val) {
+                                return subsec.offset < val;
+                              });
+  if (it != section.subsections.end()) {
+    ConcatInputSection *isec = cast<ConcatInputSection>(it->isec);
+    if (Defined *d = findSymbol(isec, it->offset - value))
+      return d;
+    assert(isec->wasCoalesced);
+  }
+  return nullptr;
+}
+
+Defined *ObjFile::findFunctionSymbol(uint64_t value) {
+  if (textSection)
+    if (Defined *d = findSymbol(*textSection, value))
+      return d;
+  if (staticInitSection)
+    if (Defined *d = findSymbol(*staticInitSection, value))
+      return d;
+  return nullptr;
+}
+
+Defined *ObjFile::findLSDASymbol(uint64_t value) {
+  if (Defined *d = findSymbol(*textSection, value))
+    return d;
+  if (staticInitSection)
+    if (Defined *d = findSymbol(*staticInitSection, value))
+      return d;
+  return nullptr;
+}
+
+Defined *ObjFile::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;
+  Defined *d = findSymbol(referentIsec, value);
+  assert(d || referentIsec->wasCoalesced);
+  return d;
+}
+
+void ObjFile::registerCompactUnwindEntries() {
+  assert(textSection);
+  for (const ParsedSubsection &subsection : compactUnwindSection->subsections) {
+    ConcatInputSection *isec = cast<ConcatInputSection>(subsection.isec);
+    for (const macho::Reloc &r : isec->relocs) {
+      // Skip the personality and LSDA relocs, which have non-zero offset.
+      if (r.offset != 0)
         continue;
+      if (Defined *d = findFunctionSymbol(r)) {
+        d->unwindEntry = isec;
+        d->hasCompactUnwind = true;
+      }
+    }
+  }
+}
+
+static uint64_t readEhFrameEncodedAddress(const uint8_t *buf, uint64_t offset) {
+  return target->wordSize == 8 ? read64le(buf) + offset
+                               : static_cast<int32_t>(read32le(buf) + offset);
+}
+
+// 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.
+
+// TODO(gkm): need ...
+// * VMA of __eh_frame section
+// * assume VMA of __text is 0
+// * sectionEntry of __text for lower_bound() on funcAddr
+
+void ObjFile::registerEhFrameUnwindEntries() {
+  assert(textSection);
+  assert(textSection->address == 0);
+  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 (const ParsedSubsection &subsection : ehFrameSection->subsections) {
+    ConcatInputSection *isec = cast<ConcatInputSection>(subsection.isec);
+    const uint8_t *buf = isec->data.data();
+    // uint8_t length = read32le(buf);
+    buf += 4; // skip length
+    uint32_t id = read32le(buf);
+    buf += 4; // skip ID
+    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.
+      buf++; // version
+      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 width = target->wordSize == 8 ? 3 : 2;
+      uint64_t offset =
+          ehFrameSection->address + subsection.offset + buf - isec->data.data();
+      // TODO(gkm): decode pointer at *buf and resolve to the
+      // ConcatInputSection for the function.
+      uint64_t funcAddr = readEhFrameEncodedAddress(buf, offset);
+      buf += target->wordSize; // skip function address
+      buf += target->wordSize; // skip function length
+      if (Defined *d = findFunctionSymbol(funcAddr)) {
+        if (d->hasCompactUnwind)
+          continue;
+        if (read64le(buf) == 0) {
+          continue;
+          // If the next 8 bytes are 0, i.e., 0 (aug-data-length) followed by
+          // seven 0 (DW_CFA_nop), then this is a degenerate FDE for a function
+          // that has no unwind info. It is a bug in MC that this object file
+          // has no degenerate CUE for this function, so we must synthesize one
+          // here.
+          ConcatInputSection *cuIsec =
+              nullptr; // FIXME: create within CU section
+          d->hasCompactUnwind = true;
+          d->unwindEntry = cuIsec;
+          cuIsec->relocs.push_back({/*type=*/GENERIC_RELOC_VANILLA,
+                                    /*pcrel=*/false, width, offset,
+                                    /*addend=*/0,
+                                    /*referent=*/d});
+          continue;
+        }
+        isec->relocs.push_back({/*type=*/GENERIC_RELOC_VANILLA,
+                                /*pcrel=*/true, width, offset,
+                                /*addend=*/0, /*referent=*/d});
+        assert(d->unwindEntry == nullptr);
+        d->unwindEntry = isec;
+        d->hasDwarfFDE = true;
+        if (lsdaEncode != DW_EH_PE_omit) {
+          uint64_t offset = ehFrameSection->address + subsection.offset + buf -
+                            isec->data.data();
+          uint64_t lsdaAddr = readEhFrameEncodedAddress(buf, offset);
+          if (Defined *d = findLSDASymbol(lsdaAddr))
+            isec->relocs.push_back({/*type=*/GENERIC_RELOC_VANILLA,
+                                    /*pcrel=*/true, width, offset,
+                                    /*addend=*/0,
+                                    /*referent=*/d});
+          buf += target->wordSize; // lsda address
+        }
       }
-      (*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

bool ConcatInputSection::isHashableForICF() const {
   case S_LAZY_DYLIB_SYMBOL_POINTERS:
   case S_THREAD_LOCAL_REGULAR:
   case S_THREAD_LOCAL_ZEROFILL:
   case S_THREAD_LOCAL_VARIABLES:
   case S_THREAD_LOCAL_VARIABLE_POINTERS:
   case S_THREAD_LOCAL_INIT_FUNCTION_POINTERS:
     return false;
   default:
     llvm_unreachable("ParsedSection type");
   }
 }
 
 void ConcatInputSection::hashForICF() {
   assert(data.data()); // zeroFill section data has nullptr with non-zero size
   assert(icfEqClass[0] == 0); // don't overwrite a unique ID!
   // Turn-on the top bit to guarantee that valid hashes have no collisions
   // with the small-integer unique IDs for ICF-ineligible sections
void ConcatInputSection::foldIdentical(ConcatInputSection *copy) {
 
   // 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;
+      (*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;
+
+  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;
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.
+// 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::finalize() {
+  // TODO(gkm): write me
+}
+
+void EhFrameSection::writeTo(uint8_t *buf) const {
+  // TODO(gkm): write me
+}

lld/MachO/Writer.cpp

void writeUuid(uint64_t digest) const {
     // want to lose bits of the digest in byte 8, so swap that with a byte of
     // fixed data that happens to have the right bits set.
     std::swap(uuidBuf[3], uuidBuf[8]);
 
     // Claim that this is an MD5-based hash. It isn't, but this signals that
     // this is not a time-based and not a random hash. MD5 seems like the least
     // bad lie we can put here.
     assert((uuidBuf[6] & 0xf0) == 0x30 && "See RFC 4122 Sections 4.2.2, 4.1.3");
     assert((uuidBuf[8] & 0xc0) == 0x80 && "See RFC 4122 ParsedSection 4.2.2");
   }
 
   mutable uint8_t *uuidBuf;
 };
 
 template <class LP> class LCEncryptionInfo final : public LoadCommand {
 public:
   uint32_t getSize() const override {
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},