[lld] [mach-o] implement minimal __unwind_info support

[t.p.northover]

Summary

Hi,

I've finally had some time to work on generating __unwind_info sections. The attached patch is fairly limited, but seemed like a minimally useful implementation:

• It's x86_64 only.
• It will fail if more than 3 personality functions are used.
• It will fail if there is a function without a __compact_unwind entry.
• It only produces normal pages, rather than compressed.

I intend to fix those, and I think most of them should be fairly small additions in the current scheme, but I'd like to get any major design problems hammered out before I start.

So, any suggestions? Is it OK to commit?

Cheers.

Tim.

[kledzik]

A few nits, but over all a great start.

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

101–103

This style (ulittle32_t) won't scale if we ever have a big endian architecture. That is why I use the style elsewhere of:

write32(headerEntries[0], _swap, 1);

230–235

These ivars need a leading underscore.

lib/ReaderWriter/MachO/CompactUnwindPass.hpp

1–31 ↗

(On Diff #13450)

Why does this file exist?

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

284–291

The should also be true for MH_DYLIB and MH_BUNDLE. It should also call archHandler. needsCompactUnwind().

lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

449

_imageBase should be initialized in the constructor from a new method MachOLinkingContext::baseAddress().

Then in assignAddressesToSections(), the FIXME for the initial value for "address" can be changed to be _imageBase.

test/mach-o/unwind-info-simple.yaml

1 ↗

(On Diff #13450)

Should name this test case with x86_64 in the name, since will need similar test case for other arches

68–71 ↗

(On Diff #13450)

You can add %p/Inputs/libSystem.yaml to the link line, then you don't need to define dyld_stub_binder

[t.p.northover]

Hi Nick,

Thanks for the comments. The writeN one makes me sad, it's a fairly clunky interface, but they all seem sensible. I'll work on an updated patch.

Cheers.

Tim.

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

230–235

That's a really dodgy convention, by the way. As soon as you want a member that starts with a capital (say from an acronym or proper name) you get undefined behaviour. There are already multiple instances of this in the lld source.

But it makes no sense to change it piecemeal, I meant to go back and do that actually, but forgot.

lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

449

Certainly, but I think that's a completely separate issue to __unwind_info (it's basically implementing "-image_base"). I'll do that today; I should be able to get a commit in before this one lands and make use of the infrastructure.

[t.p.northover]

I think this fixes everything Nick mentioned (including the ulittle32_t thing, we can sort out a better solution later if needed). How does it look now?

Cheers.

Tim.

[ruiu]

Could you run clang-format on the new code?

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

10

Needs a brief description about what this file is for.

[kledzik]

LGTM

[t.p.northover]

Thanks for the reviews. I've committed it as r218703 and r218704 (I ran clang-format for the first one, but forgot the file-level comment).

I'll work on filling in the gaps now that the basic pass is in place.

Cheers.

Tim.

include/lld/Core/DefinedAtom.h

enum ContentType {
     typeInitializerPtr,     // pointer to initializer function
     typeTerminatorPtr,      // pointer to terminator function
     typeCStringPtr,         // pointer to UTF8 C string [Darwin]
     typeObjCClassPtr,       // pointer to ObjC class [Darwin]
     typeObjC2CategoryList,  // pointers to ObjC category [Darwin]
     typeDTraceDOF,          // runtime data for Dtrace [Darwin]
     typeTempLTO,            // temporary atom for bitcode reader
     typeCompactUnwindInfo,  // runtime data for unwinder [Darwin]
+    typeProcessedUnwindInfo,// compressed compact unwind info [Darwin]
     typeThunkTLV,           // thunk used to access a TLV [Darwin]
     typeTLVInitialData,     // initial data for a TLV [Darwin]
     typeTLVInitialZeroFill, // TLV initial zero fill data [Darwin]
     typeTLVInitializerPtr,  // pointer to thread local initializer [Darwin]
     typeThreadZeroFill,     // Uninitialized thread local data(TBSS) [ELF]
     typeThreadData,         // Initialized thread local data(TDATA) [ELF]
     typeRONote,             // Identifies readonly note sections [ELF]
     typeRWNote,             // Identifies readwrite note sections [ELF]

include/lld/ReaderWriter/MachOLinkingContext.h

public:
   StringRef dyldPath() const { return "/usr/lib/dyld"; }
 
   /// Stub creation Pass should be run.
   bool needsStubsPass() const;
 
   // GOT creation Pass should be run.
   bool needsGOTPass() const;
 
+  /// Pass to transform __compact_unwind into __unwind_info should be run.
+  bool needsCompactUnwindPass() const;
+
   /// Magic symbol name stubs will need to help lazy bind.
   StringRef binderSymbolName() const;
 
   /// Used to keep track of direct and indirect dylibs.
   void registerDylib(mach_o::MachODylibFile *dylib);
 
   /// Used to find indirect dylibs. Instantiates a MachODylibFile if one
   /// has not already been made for the requested dylib.  Uses -L and -F

lib/Core/DefinedAtom.cpp

DefinedAtom::ContentPermissions DefinedAtom::permissions(ContentType type) {
   case typeUTF16String:
   case typeCFI:
   case typeLSDA:
   case typeLiteral4:
   case typeLiteral8:
   case typeLiteral16:
   case typeDTraceDOF:
   case typeCompactUnwindInfo:
+  case typeProcessedUnwindInfo:
   case typeRONote:
   case typeNoAlloc:
     return permR__;
 
   case typeData:
   case typeDataFast:
   case typeZeroFill:
   case typeZeroFillFast:

lib/ReaderWriter/MachO/ArchHandler.h

public:
   /// Used by GOTPass to locate GOT References
   virtual bool isGOTAccess(const Reference &, bool &canBypassGOT) {
     return false;
   }
 
   /// Used by GOTPass to update GOT References
   virtual void updateReferenceToGOT(const Reference *, bool targetIsNowGOT) {}
 
+  /// Does this architecture make use of __unwind_info sections for exception
+  /// handling? If so, it will need a separate pass to create them.
+  virtual bool needsCompactUnwind() = 0;
+
+  /// Returns the kind of reference to use to synthesize a 32-bit image-offset
+  /// value, used in the __unwind_info section.
+  virtual Reference::KindValue imageOffsetKind() = 0;
+
+  /// Returns the kind of reference to use to synthesize a 32-bit image-offset
+  /// indirect value. Used for personality functions in the __unwind_info
+  /// section.
+  virtual Reference::KindValue imageOffsetKindIndirect() = 0;
+
+
   /// Used by normalizedFromAtoms() to know where to generated rebasing and 
   /// binding info in final executables.
   virtual bool isPointer(const Reference &) = 0;
   
   /// Used by normalizedFromAtoms() to know where to generated lazy binding 
   /// info in final executables.
   virtual bool isLazyPointer(const Reference &);
 
public:
   /// Some architectures require local symbols on anonymous atoms.
   virtual bool needsLocalSymbolInRelocatableFile(const DefinedAtom *atom) {
     return false;
   }
 
   /// Copy raw content then apply all fixup References on an Atom.
   virtual void generateAtomContent(const DefinedAtom &atom, bool relocatable,
                                    FindAddressForAtom findAddress,
+                                   uint64_t imageBaseAddress,
                                    uint8_t *atomContentBuffer) = 0;
 
   /// Used in -r mode to convert a Reference to a mach-o relocation.
   virtual void appendSectionRelocations(const DefinedAtom &atom,
                                         uint64_t atomSectionOffset,
                                         const Reference &ref,
                                         FindSymbolIndexForAtom,
                                         FindSectionIndexForAtom,

lib/ReaderWriter/MachO/ArchHandler_arm.cpp

public:
   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
 
   Reference::KindArch kindArch() override { return Reference::KindArch::ARM; }
 
   const ArchHandler::StubInfo &stubInfo() override;
   bool isCallSite(const Reference &) override;
   bool isPointer(const Reference &) override;
   bool isPairedReloc(const normalized::Relocation &) override;
+
+  bool needsCompactUnwind() override {
+    return false;
+  }
+  Reference::KindValue imageOffsetKind() override {
+    return invalid;
+  }
+  Reference::KindValue imageOffsetKindIndirect() override {
+    return invalid;
+  }
+
   std::error_code getReferenceInfo(const normalized::Relocation &reloc,
                                    const DefinedAtom *inAtom,
                                    uint32_t offsetInAtom,
                                    uint64_t fixupAddress, bool swap,
                                    FindAtomBySectionAndAddress atomFromAddress,
                                    FindAtomBySymbolIndex atomFromSymbolIndex,
                                    Reference::KindValue *kind,
                                    const lld::Atom **target,
                                    Reference::Addend *addend) override;
   std::error_code
       getPairReferenceInfo(const normalized::Relocation &reloc1,
                            const normalized::Relocation &reloc2,
                            const DefinedAtom *inAtom,
                            uint32_t offsetInAtom,
                            uint64_t fixupAddress, bool swap,
                            FindAtomBySectionAndAddress atomFromAddress,
                            FindAtomBySymbolIndex atomFromSymbolIndex,
                            Reference::KindValue *kind,
                            const lld::Atom **target,
                            Reference::Addend *addend) override;
 
   void generateAtomContent(const DefinedAtom &atom, bool relocatable,
                            FindAddressForAtom findAddress,
+                           uint64_t imageBaseAddress,
                            uint8_t *atomContentBuffer) override;
 
   void appendSectionRelocations(const DefinedAtom &atom,
                                 uint64_t atomSectionOffset,
                                 const Reference &ref,
                                 FindSymbolIndexForAtom,
                                 FindSectionIndexForAtom,
                                 FindAddressForAtom,
case lazyImmediateLocation:
     break;
   case invalid:
     llvm_unreachable("invalid ARM Reference Kind");
     break;
   }
 }
 
 void ArchHandler_arm::generateAtomContent(const DefinedAtom &atom,
-                                           bool relocatable,
-                                           FindAddressForAtom findAddress,
-                                           uint8_t *atomContentBuffer) {
+                                          uint64_t imageBaseAddress,
   // Copy raw bytes.
   memcpy(atomContentBuffer, atom.rawContent().data(), atom.size());
   // Apply fix-ups.
   bool thumbMode = false;
   for (const Reference *ref : atom) {
     uint32_t offset = ref->offsetInAtom();
     const Atom *target = ref->target();
     uint64_t targetAddress = 0;

lib/ReaderWriter/MachO/ArchHandler_arm64.cpp

void updateReferenceToGOT(const Reference *ref, bool targetNowGOT) override {
     }
   }
 
   const StubInfo &stubInfo() override { return _sStubInfo; }
 
   bool isCallSite(const Reference &) override;
   bool isPointer(const Reference &) override;
   bool isPairedReloc(const normalized::Relocation &) override;
+
+  bool needsCompactUnwind() override {
+    return false;
+  }
+  Reference::KindValue imageOffsetKind() override {
+    return invalid;
+  }
+  Reference::KindValue imageOffsetKindIndirect() override {
+    return invalid;
+  }
+
   std::error_code getReferenceInfo(const normalized::Relocation &reloc,
                                    const DefinedAtom *inAtom,
                                    uint32_t offsetInAtom,
                                    uint64_t fixupAddress, bool swap,
                                    FindAtomBySectionAndAddress atomFromAddress,
                                    FindAtomBySymbolIndex atomFromSymbolIndex,
                                    Reference::KindValue *kind,
                                    const lld::Atom **target,
std::error_code
                            Reference::Addend *addend) override;
 
   virtual bool needsLocalSymbolInRelocatableFile(const DefinedAtom *atom) {
     return (atom->contentType() == DefinedAtom::typeCString);
   }
 
   void generateAtomContent(const DefinedAtom &atom, bool relocatable,
                            FindAddressForAtom findAddress,
+                           uint64_t imageBaseAddress,
                            uint8_t *atomContentBuffer) override;
 
   void appendSectionRelocations(const DefinedAtom &atom,
                                 uint64_t atomSectionOffset,
                                 const Reference &ref,
                                 FindSymbolIndexForAtom symbolIndexForAtom,
                                 FindSectionIndexForAtom sectionIndexForAtom,
                                 FindAddressForAtom addressForAtom,
std::error_code ArchHandler_arm64::getPairReferenceInfo(
   default:
     return make_dynamic_error_code(Twine("unsupported arm64 relocation pair"));
   }
 }
 
 void ArchHandler_arm64::generateAtomContent(const DefinedAtom &atom,
                                             bool relocatable,
                                             FindAddressForAtom findAddress,
+                                            uint64_t imageBaseAddress,
                                             uint8_t *atomContentBuffer) {
   // Copy raw bytes.
   memcpy(atomContentBuffer, atom.rawContent().data(), atom.size());
   // Apply fix-ups.
   for (const Reference *ref : atom) {
     uint32_t offset = ref->offsetInAtom();
     const Atom *target = ref->target();
     uint64_t targetAddress = 0;

lib/ReaderWriter/MachO/ArchHandler_x86.cpp

public:
   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
 
   Reference::KindArch kindArch() override { return Reference::KindArch::x86; }
 
   const StubInfo &stubInfo() override { return _sStubInfo; }
   bool isCallSite(const Reference &) override;
   bool isPointer(const Reference &) override;
   bool isPairedReloc(const normalized::Relocation &) override;
+
+  bool needsCompactUnwind() override {
+    return false;
+  }
+  Reference::KindValue imageOffsetKind() override {
+    return invalid;
+  }
+  Reference::KindValue imageOffsetKindIndirect() override {
+    return invalid;
+  }
+
   std::error_code getReferenceInfo(const normalized::Relocation &reloc,
                                    const DefinedAtom *inAtom,
                                    uint32_t offsetInAtom,
                                    uint64_t fixupAddress, bool swap,
                                    FindAtomBySectionAndAddress atomFromAddress,
                                    FindAtomBySymbolIndex atomFromSymbolIndex,
                                    Reference::KindValue *kind,
                                    const lld::Atom **target,
                                    Reference::Addend *addend) override;
   std::error_code
       getPairReferenceInfo(const normalized::Relocation &reloc1,
                            const normalized::Relocation &reloc2,
                            const DefinedAtom *inAtom,
                            uint32_t offsetInAtom,
                            uint64_t fixupAddress, bool swap,
                            FindAtomBySectionAndAddress atomFromAddress,
                            FindAtomBySymbolIndex atomFromSymbolIndex,
                            Reference::KindValue *kind,
                            const lld::Atom **target,
                            Reference::Addend *addend) override;
 
   void generateAtomContent(const DefinedAtom &atom, bool relocatable,
                            FindAddressForAtom findAddress,
+                           uint64_t imageBaseAddress,
                            uint8_t *atomContentBuffer) override;
 
   void appendSectionRelocations(const DefinedAtom &atom,
                                 uint64_t atomSectionOffset,
                                 const Reference &ref,
                                 FindSymbolIndexForAtom symbolIndexForAtom,
                                 FindSectionIndexForAtom sectionIndexForAtom,
                                 FindAddressForAtom addressForAtom,
case ((GENERIC_RELOC_LOCAL_SECTDIFF | rScattered | rLength4) << 16 |
     return std::error_code();
     break;
   default:
     return make_dynamic_error_code(Twine("unsupported i386 relocation type"));
   }
 }
 
 void ArchHandler_x86::generateAtomContent(const DefinedAtom &atom,
-                                           bool relocatable,
-                                           FindAddressForAtom findAddress,
-                                           uint8_t *atomContentBuffer) {
+                                          uint64_t imageBaseAddress,
   // Copy raw bytes.
   memcpy(atomContentBuffer, atom.rawContent().data(), atom.size());
   // Apply fix-ups.
   for (const Reference *ref : atom) {
     uint32_t offset = ref->offsetInAtom();
     const Atom *target = ref->target();
     uint64_t targetAddress = 0;
     if (isa<DefinedAtom>(target))

lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp

bool isGOTAccess(const Reference &ref, bool &canBypassGOT) override {
     assert(ref.kindArch() == Reference::KindArch::x86_64);
     switch (ref.kindValue()) {
     case ripRel32GotLoad:
       canBypassGOT = true;
       return true;
     case ripRel32Got:
       canBypassGOT = false;
       return true;
+    case imageOffsetGot:
+      canBypassGOT = false;
+      return true;
     default:
       return false;
     }
   }
 
   /// Used by GOTPass to update GOT References
   void updateReferenceToGOT(const Reference *ref, bool targetNowGOT) override {
     assert(ref->kindNamespace() == Reference::KindNamespace::mach_o);
     assert(ref->kindArch() == Reference::KindArch::x86_64);
+
+    switch (ref->kindValue()) {
+    case ripRel32Got:
+      assert(targetNowGOT && "target must be GOT");
+    case ripRel32GotLoad:
       const_cast<Reference *>(ref)
         ->setKindValue(targetNowGOT ? ripRel32 : ripRel32GotLoadNowLea);
+      break;
+    case imageOffsetGot:
+      const_cast<Reference *>(ref)->setKindValue(imageOffset);
+      break;
+    default:
+      llvm_unreachable("unknown GOT reference kind");
+    }
+  }
+
+  bool needsCompactUnwind() override {
+    return true;
+  }
+  Reference::KindValue imageOffsetKind() override {
+    return imageOffset;
+  }
+  Reference::KindValue imageOffsetKindIndirect() override {
+    return imageOffsetGot;
   }
 
   const StubInfo &stubInfo() override { return _sStubInfo; }
 
   bool isCallSite(const Reference &) override;
   bool isPointer(const Reference &) override;
   bool isPairedReloc(const normalized::Relocation &) override;
+
   std::error_code getReferenceInfo(const normalized::Relocation &reloc,
                                    const DefinedAtom *inAtom,
                                    uint32_t offsetInAtom,
                                    uint64_t fixupAddress, bool swap,
                                    FindAtomBySectionAndAddress atomFromAddress,
                                    FindAtomBySymbolIndex atomFromSymbolIndex,
                                    Reference::KindValue *kind, 
                                    const lld::Atom **target, 
std::error_code
                            Reference::Addend *addend) override;
 
   virtual bool needsLocalSymbolInRelocatableFile(const DefinedAtom *atom) {
     return (atom->contentType() == DefinedAtom::typeCString);
   }
 
   void generateAtomContent(const DefinedAtom &atom, bool relocatable,
                            FindAddressForAtom findAddress,
+                           uint64_t imageBase,
                            uint8_t *atomContentBuffer) override;
 
   void appendSectionRelocations(const DefinedAtom &atom,
                                 uint64_t atomSectionOffset,
                                 const Reference &ref,
                                 FindSymbolIndexForAtom symbolIndexForAtom,
                                 FindSectionIndexForAtom sectionIndexForAtom,
                                 FindAddressForAtom addressForAtom,
enum X86_64_Kinds: Reference::KindValue {
     delta32Anon,           /// ex: .long L1 - .
     
     // Kinds introduced by Passes:
     ripRel32GotLoadNowLea, /// Target of GOT load is in linkage unit so 
                            ///  "movq  _foo@GOTPCREL(%rip), %rax" can be changed
                            /// to "leaq _foo(%rip), %rax
     lazyPointer,           /// Location contains a lazy pointer.
     lazyImmediateLocation, /// Location contains immediate value used in stub.
+
+    imageOffset,           /// Location contains offset of atom in final image
+    imageOffsetGot,        /// Location contains offset of GOT entry for atom in
+                           /// final image (typically personality function).
+
   };
 
   Reference::KindValue kindFromReloc(const normalized::Relocation &reloc);
   Reference::KindValue kindFromRelocPair(const normalized::Relocation &reloc1,
                                          const normalized::Relocation &reloc2);
 
   void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
-                       uint64_t inAtomAddress);
+                       uint64_t inAtomAddress, uint64_t imageBaseAddress);
 
   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
                              uint64_t fixupAddress,
                              uint64_t targetAddress,
                              uint64_t inAtomAddress);
 
   const bool _swap;
 };
const Registry::KindStrings ArchHandler_x86_64::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(ripRel32Minus2), LLD_KIND_STRING_ENTRY(ripRel32Minus4),
   LLD_KIND_STRING_ENTRY(ripRel32Anon), LLD_KIND_STRING_ENTRY(ripRel32GotLoad),
   LLD_KIND_STRING_ENTRY(ripRel32GotLoadNowLea),
   LLD_KIND_STRING_ENTRY(ripRel32Got), LLD_KIND_STRING_ENTRY(lazyPointer),
   LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
   LLD_KIND_STRING_ENTRY(pointer64), LLD_KIND_STRING_ENTRY(pointer64Anon),
   LLD_KIND_STRING_ENTRY(delta32), LLD_KIND_STRING_ENTRY(delta64),
   LLD_KIND_STRING_ENTRY(delta32Anon), LLD_KIND_STRING_ENTRY(delta64Anon),
+  LLD_KIND_STRING_ENTRY(imageOffset), LLD_KIND_STRING_ENTRY(imageOffsetGot),
   LLD_KIND_STRING_END
 };
 
 const ArchHandler::StubInfo ArchHandler_x86_64::_sStubInfo = {
   "dyld_stub_binder",
 
   // Lazy pointer references 
   { Reference::KindArch::x86_64, pointer64, 0, 0 },
ArchHandler_x86_64::getPairReferenceInfo(const normalized::Relocation &reloc1,
   default:
     llvm_unreachable("bad reloc pair kind");
   }
 }
 
 void ArchHandler_x86_64::generateAtomContent(const DefinedAtom &atom,
                                              bool relocatable,
                                              FindAddressForAtom findAddress,
+                                             uint64_t imageBaseAddress,
                                              uint8_t *atomContentBuffer) {
   // Copy raw bytes.
   memcpy(atomContentBuffer, atom.rawContent().data(), atom.size());
   // Apply fix-ups.
   for (const Reference *ref : atom) {
     uint32_t offset = ref->offsetInAtom();
     const Atom *target = ref->target();
     uint64_t targetAddress = 0;
     if (isa<DefinedAtom>(target))
       targetAddress = findAddress(*target);
     uint64_t atomAddress = findAddress(atom);
     uint64_t fixupAddress = atomAddress + offset;
     if (relocatable) {
       applyFixupRelocatable(*ref, &atomContentBuffer[offset],
                                         fixupAddress, targetAddress,
                                         atomAddress);
     } else {
       applyFixupFinal(*ref, &atomContentBuffer[offset],
-                                  fixupAddress, targetAddress,
-                                  atomAddress);
+                      atomAddress, imageBaseAddress);
     }
   }
 }
 
 void ArchHandler_x86_64::applyFixupFinal(const Reference &ref,
                                          uint8_t *location,
                                          uint64_t fixupAddress,
                                          uint64_t targetAddress,
-                                         uint64_t inAtomAddress) {
+                                         uint64_t inAtomAddress,
+                                         uint64_t imageBaseAddress) {
   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
     return;
   assert(ref.kindArch() == Reference::KindArch::x86_64);
   int32_t *loc32 = reinterpret_cast<int32_t *>(location);
   uint64_t *loc64 = reinterpret_cast<uint64_t *>(location);
   switch (static_cast<X86_64_Kinds>(ref.kindValue())) {
   case branch32:
   case ripRel32:
case ripRel32GotLoadNowLea:
     assert(location[-2] == 0x8B);
     location[-2] = 0x8D;
     write32(*loc32, _swap, (targetAddress - (fixupAddress + 4)) + ref.addend());
     return;
   case lazyPointer:
   case lazyImmediateLocation:
     // do nothing
     return;
+  case imageOffset:
+  case imageOffsetGot:
+    write32(*loc32, _swap, (targetAddress - imageBaseAddress) + ref.addend());
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("invalid x86_64 Reference Kind");
 }
 
 
case delta64Anon:
     return;
   case ripRel32GotLoadNowLea:
     llvm_unreachable("ripRel32GotLoadNowLea implies GOT pass was run");
     return;
   case lazyPointer:
   case lazyImmediateLocation:
     llvm_unreachable("lazy reference kind implies Stubs pass was run");
     return;
+  case imageOffset:
+  case imageOffsetGot:
+    llvm_unreachable("image offset implies __unwind_info");
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("unknown x86_64 Reference Kind");
 }
 
 void ArchHandler_x86_64::appendSectionRelocations(
case delta64Anon:
     return;
   case ripRel32GotLoadNowLea:
     llvm_unreachable("ripRel32GotLoadNowLea implies GOT pass was run");
     return;
   case lazyPointer:
   case lazyImmediateLocation:
     llvm_unreachable("lazy reference kind implies Stubs pass was run");
     return;
+  case imageOffset:
+  case imageOffsetGot:
+    llvm_unreachable("__unwind_info references should have been resolved");
+    return;
   case invalid:
     // Fall into llvm_unreachable().
     break;
   }
   llvm_unreachable("unknown x86_64 Reference Kind");
 }
 
 
 std::unique_ptr<mach_o::ArchHandler> ArchHandler::create_x86_64() {
   return std::unique_ptr<mach_o::ArchHandler>(new ArchHandler_x86_64());
 }
 
 } // namespace mach_o
 } // namespace lld

lib/ReaderWriter/MachO/CMakeLists.txt

 add_lld_library(lldMachO
   ArchHandler.cpp
   ArchHandler_arm.cpp
   ArchHandler_arm64.cpp
   ArchHandler_x86.cpp
   ArchHandler_x86_64.cpp
+  CompactUnwindPass.cpp
   GOTPass.cpp
   MachOLinkingContext.cpp
   MachONormalizedFileBinaryReader.cpp
   MachONormalizedFileBinaryWriter.cpp
   MachONormalizedFileFromAtoms.cpp
   MachONormalizedFileToAtoms.cpp
   MachONormalizedFileYAML.cpp
   StubsPass.cpp

lib/ReaderWriter/MachO/CompactUnwindPass.cpp

+//===- lib/ReaderWriter/MachO/CompactUnwindPass.cpp -----------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+//===----------------------------------------------------------------------===//
+
+#include "ArchHandler.h"
+#include "File.h"
+#include "MachOPasses.h"
+#include "MachONormalizedFileBinaryUtils.h"
+
+#include "lld/Core/DefinedAtom.h"
+#include "lld/Core/File.h"
+#include "lld/Core/LLVM.h"
+#include "lld/Core/Reference.h"
+#include "lld/Core/Simple.h"
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Format.h"
+
+#define DEBUG_TYPE "macho-compact-unwind"
+
+namespace lld {
+namespace mach_o {
+
+namespace {
+  struct CompactUnwindEntry {
+    const Atom *rangeStart;
+    const Atom *personalityFunction;
+    const Atom *lsdaLocation;
+
+    uint32_t rangeLength;
+    uint32_t encoding;
+  };
+
+  struct UnwindInfoPage {
+    std::vector<CompactUnwindEntry> entries;
+  };
+}
+
+class UnwindInfoAtom : public SimpleDefinedAtom {
+public:
+  UnwindInfoAtom(ArchHandler &archHandler, const File &file, bool swap,
+                 std::vector<uint32_t> commonEncodings,
+                 std::vector<const Atom *> personalities,
+                 std::vector<UnwindInfoPage> pages, uint32_t numLSDAs)
+      : SimpleDefinedAtom(file), _archHandler(archHandler),
+        _commonEncodingsOffset(7 * sizeof(uint32_t)),
+        _personalityArrayOffset(_commonEncodingsOffset +
+                                commonEncodings.size() * sizeof(uint32_t)),
+        _topLevelIndexOffset(_personalityArrayOffset +
+                             personalities.size() * sizeof(uint32_t)),
+        _lsdaIndexOffset(_topLevelIndexOffset +
+                         3 * (pages.size() + 1) * sizeof(uint32_t)),
+        _firstPageOffset(_lsdaIndexOffset + 2 * numLSDAs * sizeof(uint32_t)),
+        _swap(swap) {
+
+    addHeader(commonEncodings.size(), personalities.size(), pages.size());
+    addCommonEncodings(commonEncodings);
+    addPersonalityFunctions(personalities);
+    addTopLevelIndexes(pages);
+    addLSDAIndexes(pages, numLSDAs);
+    addSecondLevelPages(pages);
+  }
+
+  ContentType contentType() const override {
+    return DefinedAtom::typeProcessedUnwindInfo;
+  }
+
+  Alignment alignment() const override {
+    return Alignment(2);
+  }
+
+  uint64_t size() const override {
+    return _contents.size();
+  }
+
+  ContentPermissions permissions() const override {
+    return DefinedAtom::permR__;
+  }
+
+  ArrayRef<uint8_t> rawContent() const override {
+    return _contents;
+  }
+
+  void addHeader(uint32_t numCommon, uint32_t numPersonalities,
+                 uint32_t numPages) {
+    using normalized::write32;
+
+    uint32_t headerSize = 7 * sizeof(uint32_t);
+    _contents.resize(headerSize);
+
+    int32_t *headerEntries = (int32_t *)_contents.data();
+    // version
+    write32(headerEntries[0], _swap, 1);
+    // commonEncodingsArraySectionOffset
+    write32(headerEntries[1], _swap, _commonEncodingsOffset);
+    // commonEncodingsArrayCount
+    write32(headerEntries[2], _swap, numCommon);
+    // personalityArraySectionOffset
+    write32(headerEntries[3], _swap, _personalityArrayOffset);
+    // personalityArrayCount
+    write32(headerEntries[4], _swap, numPersonalities);
+    // indexSectionOffset
+    write32(headerEntries[5], _swap, _topLevelIndexOffset);
+    // indexCount
+    write32(headerEntries[6], _swap, numPages + 1);
+  }
+
+  /// Add the list of common encodings to the section; this is simply an array
+  /// of uint32_t compact values. Size has already been specified in the header.
+  void addCommonEncodings(std::vector<uint32_t> &commonEncodings) {
+    using normalized::write32;
+
+    _contents.resize(_commonEncodingsOffset +
+                    commonEncodings.size() * sizeof(uint32_t));
+    int32_t *commonEncodingsArea =
+        (int32_t *)&_contents[_commonEncodingsOffset];
+
+    for (uint32_t encoding : commonEncodings)
+      write32(*commonEncodingsArea++, _swap, encoding);
+  }
+
+  void addPersonalityFunctions(std::vector<const Atom *> personalities) {
+    _contents.resize(_personalityArrayOffset +
+                    personalities.size() * sizeof(uint32_t));
+
+    for (unsigned i = 0; i < personalities.size(); ++i)
+      addImageReferenceIndirect(_personalityArrayOffset + i * sizeof(uint32_t),
+                                personalities[i]);
+  }
+
+  void addTopLevelIndexes(std::vector<UnwindInfoPage> &pages) {
+    using normalized::write32;
+
+    uint32_t numIndexes = pages.size() + 1;
+    _contents.resize(_topLevelIndexOffset + numIndexes * 3 * sizeof(uint32_t));
+
+    uint32_t pageLoc = _firstPageOffset;
+
+    // The most difficult job here is calculating the LSDAs; everything else
+    // follows fairly naturally, but we can't state where the first
+    int32_t *indexData = (int32_t *)&_contents[_topLevelIndexOffset];
+    uint32_t numLSDAs = 0;
+    for (unsigned i = 0; i < pages.size(); ++i) {
+      // functionOffset
+      addImageReference(_topLevelIndexOffset + 3 * i * sizeof(uint32_t),
+                        pages[i].entries[0].rangeStart);
+      // secondLevelPagesSectionOffset
+      write32(indexData[3 * i + 1], _swap, pageLoc);
+      write32(indexData[3 * i + 2], _swap,
+              _lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t));
+
+      for (auto &entry : pages[i].entries)
+        if (entry.lsdaLocation)
+          ++numLSDAs;
+    }
+
+    // Finally, write out the final sentinel index
+    CompactUnwindEntry &finalEntry = pages[pages.size() - 1].entries.back();
+    addImageReference(_topLevelIndexOffset + 3 * pages.size() * sizeof(uint32_t),
+                      finalEntry.rangeStart, finalEntry.rangeLength);
+    // secondLevelPagesSectionOffset => 0
+    indexData[3 * pages.size() + 2] =
+        _lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t);
+  }
+
+  void addLSDAIndexes(std::vector<UnwindInfoPage> &pages, uint32_t numLSDAs) {
+    _contents.resize(_lsdaIndexOffset + numLSDAs * 2 * sizeof(uint32_t));
+
+    uint32_t curOffset = _lsdaIndexOffset;
+    for (auto & page : pages) {
+      for (auto &entry : page.entries) {
+        if (!entry.lsdaLocation)
+          continue;
+
+        addImageReference(curOffset, entry.rangeStart);
+        addImageReference(curOffset + sizeof(uint32_t), entry.lsdaLocation);
+        curOffset += 2 * sizeof(uint32_t);
+      }
+    }
+  }
+
+  void addSecondLevelPages(std::vector<UnwindInfoPage> &pages) {
+    for (auto &page : pages) {
+      addRegularSecondLevelPage(page);
+    }
+  }
+
+  void addRegularSecondLevelPage(const UnwindInfoPage &page) {
+    uint32_t curPageOffset = _contents.size();
+    const int16_t headerSize = sizeof(uint32_t) + 2 * sizeof(uint16_t);
+    uint32_t curPageSize =
+        headerSize + 2 * page.entries.size() * sizeof(uint32_t);
+    _contents.resize(curPageOffset + curPageSize);
+
+    using normalized::write32;
+    using normalized::write16;
+    // 2 => regular page
+    write32(*(int32_t *)&_contents[curPageOffset], _swap, 2);
+    // offset of 1st entry
+    write16(*(int16_t *)&_contents[curPageOffset + 4], _swap, headerSize);
+    write16(*(int16_t *)&_contents[curPageOffset + 6], _swap,
+            page.entries.size());
+
+    uint32_t pagePos = curPageOffset + headerSize;
+    for (auto &entry : page.entries) {
+      addImageReference(pagePos, entry.rangeStart);
+      write32(reinterpret_cast<int32_t *>(_contents.data() + pagePos)[1], _swap,
+              entry.encoding);
+      pagePos += 2 * sizeof(uint32_t);
+    }
+  }
+
+  void addImageReference(uint32_t offset, const Atom *dest,
+                         Reference::Addend addend = 0) {
+    addReference(Reference::KindNamespace::mach_o, _archHandler.kindArch(),
+                 _archHandler.imageOffsetKind(), offset, dest, addend);
+  }
+
+  void addImageReferenceIndirect(uint32_t offset, const Atom *dest) {
+    addReference(Reference::KindNamespace::mach_o, _archHandler.kindArch(),
+                 _archHandler.imageOffsetKindIndirect(), offset, dest, 0);
+  }
+
+private:
+  mach_o::ArchHandler &_archHandler;
+  std::vector<uint8_t> _contents;
+  uint32_t _commonEncodingsOffset;
+  uint32_t _personalityArrayOffset;
+  uint32_t _topLevelIndexOffset;
+  uint32_t _lsdaIndexOffset;
+  uint32_t _firstPageOffset;
+  bool _swap;
+};
+
+
+/// Pass for instantiating and optimizing GOT slots.
+///
+class CompactUnwindPass : public Pass {
+public:
+  CompactUnwindPass(const MachOLinkingContext &context)
+      : _context(context), _archHandler(_context.archHandler()),
+        _file("<mach-o Compact Unwind Pass>"),
+        _swap(!MachOLinkingContext::isHostEndian(_context.arch())) {}
+
+private:
+  void perform(std::unique_ptr<MutableFile> &mergedFile) override {
+    DEBUG(llvm::dbgs() << "MachO Compact Unwind pass\n");
+
+    // First collect all __compact_unwind entries, addressable by the function
+    // it's referring to.
+    std::map<const Atom *, CompactUnwindEntry> unwindLocs;
+    std::vector<const Atom *> personalities;
+    uint32_t numLSDAs = 0;
+
+    collectCompactUnwindEntries(mergedFile, unwindLocs, personalities,
+                                numLSDAs);
+
+    // FIXME: if there are more than 4 personality functions then we need to
+    // defer to DWARF info for the ones we don't put in the list. They should
+    // also probably be sorted by frequency.
+    assert(personalities.size() <= 4);
+
+    // Now sort the entries by final address and fixup the compact encoding to
+    // its final form (i.e. set personality function bits & create DWARF
+    // references where needed).
+    std::vector<CompactUnwindEntry> unwindInfos =
+      createUnwindInfoEntries(mergedFile, unwindLocs, personalities);
+
+    // Finally, we can start creating pages based on these entries.
+
+    DEBUG(llvm::dbgs() << "  Splitting entries into pages\n");
+    // FIXME: we split the entries into pages naively: lots of 4k pages followed
+    // by a small one. ld64 tried to minimize space and align them to real 4k
+    // boundaries. That might be worth doing, or perhaps we could perform some
+    // minor balancing for expected number of lookups.
+    std::vector<UnwindInfoPage> pages;
+    unsigned pageStart = 0;
+    do {
+      pages.push_back(UnwindInfoPage());
+
+      // FIXME: we only create regular pages at the moment. These can hold up to
+      // 1021 entries according to the documentation.
+      unsigned entriesInPage =
+          std::min(1021U, (unsigned)unwindInfos.size() - pageStart);
+
+      std::copy(unwindInfos.begin() + pageStart,
+                unwindInfos.begin() + pageStart + entriesInPage,
+                std::back_inserter(pages.back().entries));
+      pageStart += entriesInPage;
+
+      DEBUG(llvm::dbgs()
+            << "    Page from " << pages.back().entries[0].rangeStart->name()
+            << " to " << pages.back().entries.back().rangeStart->name() << " + "
+            << llvm::format("0x%x", pages.back().entries.back().rangeLength)
+            << " has " << entriesInPage << " entries\n");
+    } while (pageStart < unwindInfos.size());
+
+    // FIXME: we should also erase all compact-unwind atoms; their job is done.
+    UnwindInfoAtom *unwind = new (_file.allocator())
+        UnwindInfoAtom(_archHandler, _file, _swap, std::vector<uint32_t>(),
+                       personalities, pages, numLSDAs);
+    mergedFile->addAtom(*unwind);
+  }
+
+  void collectCompactUnwindEntries(
+      std::unique_ptr<MutableFile> &mergedFile,
+      std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
+      std::vector<const Atom *> &personalities, uint32_t &numLSDAs) {
+    DEBUG(llvm::dbgs() << "  Collecting __compact_unwind entries\n");
+
+    for (const DefinedAtom *atom : mergedFile->defined()) {
+      if (atom->contentType() != DefinedAtom::typeCompactUnwindInfo)
+        continue;
+
+      auto unwindEntry = extractCompactUnwindEntry(atom);
+      unwindLocs.insert(std::make_pair(unwindEntry.rangeStart, unwindEntry));
+
+      DEBUG(llvm::dbgs() << "    Entry for " << unwindEntry.rangeStart->name()
+            << ", encoding=" << llvm::format("0x%08x", unwindEntry.encoding));
+      if (unwindEntry.personalityFunction)
+        DEBUG(llvm::dbgs() << ", personality="
+                           << unwindEntry.personalityFunction->name()
+                           << ", lsdaLoc=" << unwindEntry.lsdaLocation->name());
+      DEBUG(llvm::dbgs() << '\n');
+
+      // Count number of LSDAs we see, since we need to know how big the index
+      // will be while laying out the section.
+      if (unwindEntry.lsdaLocation)
+        ++numLSDAs;
+
+      // Gather the personality functions now, so that they're in deterministic
+      // order (derived from the DefinedAtom order).
+      if (unwindEntry.personalityFunction) {
+        auto pFunc = std::find(personalities.begin(), personalities.end(),
+                               unwindEntry.personalityFunction);
+        if (pFunc == personalities.end())
+          personalities.push_back(unwindEntry.personalityFunction);
+      }
+    }
+  }
+
+  CompactUnwindEntry extractCompactUnwindEntry(const DefinedAtom *atom) {
+    CompactUnwindEntry entry = { nullptr, nullptr, nullptr, 0, 0};
+
+    for (const Reference *ref : *atom) {
+      switch (ref->offsetInAtom()) {
+      case 0:
+        // FIXME: there could legitimately be functions with multiple encoding
+        // entries. However, nothing produces them at the moment.
+        assert(ref->addend() == 0 && "unexpected offset into function");
+        entry.rangeStart = ref->target();
+        break;
+      case  0x10:
+        assert(ref->addend() == 0 && "unexpected offset into personality fn");
+        entry.personalityFunction = ref->target();
+        break;
+      case 0x18:
+        assert(ref->addend() == 0 && "unexpected offset into LSDA atom");
+        entry.lsdaLocation = ref->target();
+        break;
+      }
+    }
+
+    using normalized::read32;
+    entry.rangeLength =
+        read32(_swap, ((uint32_t *)atom->rawContent().data())[2]);
+    entry.encoding = read32(_swap, ((uint32_t *)atom->rawContent().data())[3]);
+    return entry;
+  }
+
+  /// Every atom defined in __TEXT,__text needs an entry in the final
+  /// __unwind_info section (in order). These comes from two sources:
+  ///   + Input __compact_unwind sections where possible (after adding the
+  ///      personality function offset which is only known now).
+  ///   + A synthesised reference to __eh_frame if there's no __compact_unwind
+  ///     or too many personality functions to be accommodated.
+  std::vector<CompactUnwindEntry> createUnwindInfoEntries(
+      const std::unique_ptr<MutableFile> &mergedFile,
+      const std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
+      const std::vector<const Atom *> &personalities) {
+    std::vector<CompactUnwindEntry> unwindInfos;
+
+    DEBUG(llvm::dbgs() << "  Creating __unwind_info entries\n");
+    // The final order in the __unwind_info section must be derived from the
+    // order of typeCode atoms, since that's how they'll be put into the object
+    // file eventually (yuck!).
+    for (const DefinedAtom *atom : mergedFile->defined()) {
+      if (atom->contentType() != DefinedAtom::typeCode)
+        continue;
+
+      unwindInfos.push_back(
+          finalizeUnwindInfoEntryForAtom(atom, unwindLocs, personalities));
+
+      DEBUG(llvm::dbgs() << "    Entry for " << atom->name()
+                         << ", final encoding="
+                         << llvm::format("0x%08x", unwindInfos.back().encoding)
+                         << '\n');
+    }
+
+    return unwindInfos;
+  }
+
+  CompactUnwindEntry finalizeUnwindInfoEntryForAtom(
+      const DefinedAtom *function,
+      const std::map<const Atom *, CompactUnwindEntry> &unwindLocs,
+      const std::vector<const Atom *> &personalities) {
+    auto unwindLoc = unwindLocs.find(function);
+
+    // FIXME: we should synthesize a DWARF compact unwind entry before claiming
+    // there's no unwind if a __compact_unwind atom doesn't exist.
+    if (unwindLoc == unwindLocs.end()) {
+      CompactUnwindEntry entry;
+      memset(&entry, 0, sizeof(CompactUnwindEntry));
+      entry.rangeStart = function;
+      entry.rangeLength = function->size();
+      return entry;
+    }
+
+    CompactUnwindEntry entry = unwindLoc->second;
+    auto personality = std::find(personalities.begin(), personalities.end(),
+                                 entry.personalityFunction);
+    uint32_t personalityIdx = personality == personalities.end()
+                                  ? 0
+                                  : personality - personalities.begin() + 1;
+
+    // FIXME: We should also use DWARF when there isn't enough room for the
+    // personality function in the compact encoding.
+    assert(personalityIdx < 4 && "too many personality functions");
+
+    entry.encoding |= personalityIdx << 28;
+
+    if (entry.lsdaLocation)
+      entry.encoding |= 1U << 30;
+
+    return entry;
+  }
+
+  const MachOLinkingContext                       &_context;
+  mach_o::ArchHandler                             &_archHandler;
+  MachOFile                                        _file;
+  bool                                             _swap;
+};
+
+void addCompactUnwindPass(PassManager &pm, const MachOLinkingContext &ctx) {
+  assert(ctx.needsCompactUnwindPass());
+  pm.add(std::unique_ptr<Pass>(new CompactUnwindPass(ctx)));
+}
+
+} // end namesapce mach_o
+} // end namesapce lld

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

switch (_arch) {
     case arch_x86_64:
     case arch_arm64:
       return true;
     default:
       return false;
   }
 }
 
+bool MachOLinkingContext::needsCompactUnwindPass() const {
+  switch (_outputMachOType) {
+  case MH_EXECUTE:
+  case MH_DYLIB:
+  case MH_BUNDLE:
+    return archHandler().needsCompactUnwind();
+  default:
+    return false;
+  }
+}
 
 StringRef MachOLinkingContext::binderSymbolName() const {
   return archHandler().stubInfo().binderSymbolName;
 }
 
 
 
 
bool MachOLinkingContext::validateImpl(raw_ostream &diagnostics) {
 
   return true;
 }
 
 void MachOLinkingContext::addPasses(PassManager &pm) {
   pm.add(std::unique_ptr<Pass>(new LayoutPass(registry())));
   if (needsStubsPass())
     mach_o::addStubsPass(pm, *this);
+  if (needsCompactUnwindPass())
+    mach_o::addCompactUnwindPass(pm, *this);
   if (needsGOTPass())
     mach_o::addGOTPass(pm, *this);
 }
 
 Writer &MachOLinkingContext::writer() const {
   if (!_writer)
     _writer = createWriterMachO(*this);
   return *_writer;

lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

const MachOFinalSectionFromAtomType sectsToAtomType[] = {
   ENTRY("__TEXT", "__const",          S_REGULAR,          typeConstant),
   ENTRY("__TEXT", "__const",          S_4BYTE_LITERALS,   typeLiteral4),
   ENTRY("__TEXT", "__const",          S_8BYTE_LITERALS,   typeLiteral8),
   ENTRY("__TEXT", "__const",          S_16BYTE_LITERALS,  typeLiteral16),
   ENTRY("__TEXT", "__stubs",          S_SYMBOL_STUBS,     typeStub),
   ENTRY("__TEXT", "__stub_helper",    S_REGULAR,          typeStubHelper),
   ENTRY("__TEXT", "__gcc_except_tab", S_REGULAR,          typeLSDA),
   ENTRY("__TEXT", "__eh_frame",       S_COALESCED,        typeCFI),
+  ENTRY("__TEXT", "__unwind_info",    S_REGULAR,          typeProcessedUnwindInfo),
   ENTRY("__DATA", "__data",           S_REGULAR,          typeData),
   ENTRY("__DATA", "__const",          S_REGULAR,          typeConstData),
   ENTRY("__DATA", "__cfstring",       S_REGULAR,          typeCFString),
   ENTRY("__DATA", "__la_symbol_ptr",  S_LAZY_SYMBOL_POINTERS,
                                                           typeLazyPointer),
   ENTRY("__DATA", "__mod_init_func",  S_MOD_INIT_FUNC_POINTERS,
                                                           typeInitializerPtr),
   ENTRY("__DATA", "__mod_term_func",  S_MOD_TERM_FUNC_POINTERS,
void Util::layoutSectionsInSegment(SegmentInfo *seg, uint64_t &addr) {
   }
   seg->size = llvm::RoundUpToAlignment(addr - seg->address,_context.pageSize());
 }
 
 
 // __TEXT segment lays out backwards so padding is at front after load commands.
 void Util::layoutSectionsInTextSegment(size_t hlcSize, SegmentInfo *seg,
                                                                uint64_t &addr) {
   seg->address = addr;
   // Walks sections starting at end to calculate padding for start.
   int64_t taddr = 0;
   for (auto it = seg->sections.rbegin(); it != seg->sections.rend(); ++it) {
     SectionInfo *sect = *it;
     taddr -= sect->size;
     taddr = taddr & (0 - (1 << sect->alignment));
   }
   int64_t padding = taddr - hlcSize;
if (si->type == llvm::MachO::S_ZEROFILL)
       continue;
     // Copy content from atoms to content buffer for section.
     uint8_t *sectionContent = file.ownedAllocations.Allocate<uint8_t>(si->size);
     Section *normSect = &file.sections[si->normalizedSectionIndex];
     normSect->content = llvm::makeArrayRef(sectionContent, si->size);
     for (AtomInfo &ai : si->atomsAndOffsets) {
       uint8_t *atomContent = reinterpret_cast<uint8_t*>
                                           (&sectionContent[ai.offsetInSection]);
-      _archHandler.generateAtomContent(*ai.atom, r, addrForAtom, atomContent);
+      _archHandler.generateAtomContent(*ai.atom, r, addrForAtom,
+                                       _context.baseAddress(), atomContent);
     }
   }
 }
 
 
 void Util::copySectionInfo(NormalizedFile &file) {
   file.sections.reserve(_sectionInfos.size());
   // For final linked images, write sections grouped by segment.

lib/ReaderWriter/MachO/MachOPasses.h

 #include "lld/Core/PassManager.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 
 namespace lld {
 namespace mach_o {
 
 void addStubsPass(PassManager &pm, const MachOLinkingContext &ctx);
 void addGOTPass(PassManager &pm, const MachOLinkingContext &ctx);
+void addCompactUnwindPass(PassManager &pm, const MachOLinkingContext &ctx);
 
 } // namespace mach_o
 } // namespace lld
 
 #endif // LLD_READER_WRITER_MACHO_PASSES_H

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

static void enumeration(IO &io, lld::DefinedAtom::ContentType &value) {
     io.enumCase(value, "objc-class-pointer",
                                           DefinedAtom::typeObjCClassPtr);
     io.enumCase(value, "objc-category-list",
                                           DefinedAtom::typeObjC2CategoryList);
     io.enumCase(value, "objc-class1",     DefinedAtom::typeObjC1Class);
     io.enumCase(value, "dtraceDOF",       DefinedAtom::typeDTraceDOF);
     io.enumCase(value, "lto-temp",        DefinedAtom::typeTempLTO);
     io.enumCase(value, "compact-unwind",  DefinedAtom::typeCompactUnwindInfo);
+    io.enumCase(value, "unwind-info",     DefinedAtom::typeProcessedUnwindInfo);
     io.enumCase(value, "tlv-thunk",       DefinedAtom::typeThunkTLV);
     io.enumCase(value, "tlv-data",        DefinedAtom::typeTLVInitialData);
     io.enumCase(value, "tlv-zero-fill",   DefinedAtom::typeTLVInitialZeroFill);
     io.enumCase(value, "tlv-initializer-ptr",
                                           DefinedAtom::typeTLVInitializerPtr);
     io.enumCase(value, "thread-data",     DefinedAtom::typeThreadData);
     io.enumCase(value, "thread-zero-fill",DefinedAtom::typeThreadZeroFill);
     io.enumCase(value, "ro-note",         DefinedAtom::typeRONote);

test/mach-o/exe-offsets.yaml

 
 # CHECK-LABEL: Section {
 # CHECK:     Name: __text
 # CHECK:     Segment: __TEXT
 # CHECK:     Size: 0x1
 # CHECK:     Offset: 0
 
 # CHECK-LABEL: Section {
+# CHECK:     Name: __unwind_info
+
+# CHECK-LABEL: Section {
 # CHECK:     Name: __data
 # CHECK:     Segment: __DATA
 # CHECK:     Size: 0x5
 # CHECK:     Offset: 4096
 
 # CHECK-LABEL: Section {
 # CHECK:     Name: ___bss
 # CHECK:     Segment: __DATA
 # CHECK:     Size: 0x0
 # CHECK:     Offset: 4101

test/mach-o/exe-segment-overlap.yaml

- name:            dyld_stub_binder
     scope:           [ N_EXT ]
     sect:            1
     value:           0x0000000000000000
 
 # CHECK-LABEL: Section {
 # CHECK:     Name: __text
 # CHECK:     Segment: __TEXT
 # CHECK:     Size: 0x1
-# CHECK:     Offset: 4095
+# CHECK:     Offset: 4027
+
+# CHECK-LABEL: Section {
+# CHECK:     Name: __unwind_info
 
 # CHECK-LABEL: Section {
 # CHECK:     Name: __data
 # CHECK:     Segment: __DATA
 # CHECK:     Size: 0x4
 # CHECK:     Offset: 4096
 # CHECK:     SectionData (
 # CHECK-NEXT: 0000: 31323334

test/mach-o/unwind-info-simple-x86_64.yaml

+# RUN: lld -flavor darwin -arch x86_64 %s -o %t -e _main %p/Inputs/libSystem.yaml
+# RUN: llvm-objdump -unwind-info %t | FileCheck %s
+
+# CHECK: Contents of __unwind_info section:
+# CHECK:   Version:                                   0x1
+# CHECK:   Common encodings array section offset:     0x1c
+# CHECK:   Number of common encodings in array:       0x0
+# CHECK:   Personality function array section offset: 0x1c
+# CHECK:   Number of personality functions in array:  0x1
+# CHECK:   Index array section offset:                0x20
+# CHECK:   Number of indices in array:                0x2
+# CHECK:   Common encodings: (count = 0)
+# CHECK:   Personality functions: (count = 1)
+# CHECK:     personality[1]: 0x00001000
+# CHECK:   Top level indices: (count = 2)
+# CHECK:     [0]: function offset=0x00000f7e, 2nd level page offset=0x00000040, LSDA offset=0x00000038
+# CHECK:     [1]: function offset=0x00000f80, 2nd level page offset=0x00000000, LSDA offset=0x00000040
+# CHECK:   LSDA descriptors:
+# CHECK:     [0]: function offset=0x00000f7e, LSDA offset=0x00000f80
+# CHECK:   Second level indices:
+# CHECK:     Second level index[0]: offset in section=0x00000040, base function offset=0x00000f7e
+# CHECK:       [0]: function offset=0x00000f7e, encoding=0x51000000
+# CHECK:       [1]: function offset=0x00000f7f, encoding=0x01000000
+
+--- !native
+path:            '<linker-internal>'
+defined-atoms:
+  - name:            GCC_except_table1
+    type:            unwind-lsda
+    content:         [ FF, 9B, A2, 80, 80, 00, 03, 1A, 08, 00, 00, 00,
+                       05, 00, 00, 00, 1A, 00, 00, 00, 01, 0D, 00, 00,
+                       00, 64, 00, 00, 00, 00, 00, 00, 00, 00, 01, 00,
+                       04, 00, 00, 00 ]
+  - type:            compact-unwind
+    content:         [ 40, 00, 00, 00, 00, 00, 00, 00, 01, 00, 00, 00,
+                       00, 00, 00, 41, 00, 00, 00, 00, 00, 00, 00, 00,
+                       E0, 00, 00, 00, 00, 00, 00, 00 ]
+    references:
+      - kind:            pointer64Anon
+        offset:          0
+        target:          __Z3barv
+      - kind:            pointer64
+        offset:          16
+        target:          ___gxx_personality_v0
+      - kind:            pointer64Anon
+        offset:          24
+        target:          GCC_except_table1
+  - type:            compact-unwind
+    content:         [ C0, 00, 00, 00, 00, 00, 00, 00, 01, 00, 00, 00,
+                       00, 00, 00, 01, 00, 00, 00, 00, 00, 00, 00, 00,
+                       00, 00, 00, 00, 00, 00, 00, 00 ]
+    references:
+      - kind:            pointer64Anon
+        offset:          0
+        target:          _main
+
+  - name:            __Z3barv
+    scope:           global
+    content:         [ C3 ]
+  - name:            _main
+    scope:           global
+    content:         [ C3 ]
+    references:
+      - kind:            branch32
+        offset:          9
+        target:          __Z3barv
+
+shared-library-atoms:
+  - name:            ___gxx_personality_v0
+    load-name:       '/usr/lib/libc++abi.dylib'
+    type:            unknown