[lld-macho] Add 32-bit compact unwind support

[int3]

Summary

This could probably have been part of D99633, but I split it up to make
things a bit more reviewable. I also fixed some bugs in the implementation that
were masked through integer underflows when operating in 64-bit mode.

[int3]

lld/MachO/UnwindInfoSection.cpp

210

Taking the address difference here doesn't make sense since at this point in the link, personality contains an index, not a real address (see the comments on lines 189-191 above.)

445

this is the right place to be taking the offset from the header.

[gkm]

LGTM

lld/MachO/UnwindInfoSection.cpp

121

139–140

I will skip the many similar edit suggestions for sake of time. You get the idea.

422–424

527–529

[int3]

lld/MachO/UnwindInfoSection.cpp

121

what is 'P' supposed to stand for? Maybe 'CPE' instead?

[int3]

lld/MachO/UnwindInfoSection.cpp

121

I meant CUE

[int3]

lld/MachO/UnwindInfoSection.cpp

121

Oh, I see -- you mean to parameterize things by the word size rather than the struct. That makes sense...

[int3]

change template param

lld/MachO/Relocations.h

 //===- Relocations.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_RELOCATIONS_H
 #define LLD_MACHO_RELOCATIONS_H
 
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/Endian.h"
 
 #include <cstddef>
 #include <cstdint>
 
 namespace lld {
 namespace macho {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 

 }
 
 template <typename Diagnostic>
 inline void checkUInt(Diagnostic d, uint64_t v, int bits) {
   if ((v >> bits) != 0)
     reportRangeError(d, llvm::Twine(v), bits, 0, llvm::maxUIntN(bits));
 }
 
+inline void writeAddress(uint8_t *loc, uint64_t addr, uint8_t length) {
+  switch (length) {
+  case 2:
+    llvm::support::endian::write32le(loc, addr);
+    break;
+  case 3:
+    llvm::support::endian::write64le(loc, addr);
+    break;
+  default:
+    llvm_unreachable("invalid r_length");
+  }
+}
+
 extern const RelocAttrs invalidRelocAttrs;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SyntheticSections.h

 
 namespace lld {
 namespace macho {
 
 class Defined;
 class DylibSymbol;
 class LoadCommand;
 class ObjFile;
+class UnwindInfoSection;
 
 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;
   ImageLoaderCacheSection *imageLoaderCache = nullptr;
+  UnwindInfoSection *unwindInfo = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 void createSyntheticSymbols();
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/UnwindInfoSection.h

 #include "MergedOutputSection.h"
 #include "SyntheticSections.h"
 
 #include "mach-o/compact_unwind_encoding.h"
 #include "llvm/ADT/DenseMap.h"
 
 #include <vector>
 
-// In 2020, we mostly care about 64-bit targets: x86_64 and arm64
-struct CompactUnwindEntry64 {
-  uint64_t functionAddress;
-  uint32_t functionLength;
-  compact_unwind_encoding_t encoding;
-  uint64_t personality;
-  uint64_t lsda;
-};
-
-// FIXME(gkm): someday we might care about 32-bit targets: x86 & arm
-struct CompactUnwindEntry32 {
-  uint32_t functionAddress;
-  uint32_t functionLength;
-  compact_unwind_encoding_t encoding;
-  uint32_t personality;
-  uint32_t lsda;
-};
-
 namespace lld {
 namespace macho {
 
 class UnwindInfoSection : public SyntheticSection {
 public:
-  UnwindInfoSection();
+  bool isNeeded() const override { return compactUnwindSection != nullptr; }
   uint64_t getSize() const override { return unwindInfoSize; }
-  bool isNeeded() const override;
-  void finalize() override;
-  void writeTo(uint8_t *buf) const override;
+  virtual void prepareRelocations(InputSection *) = 0;
+
   void setCompactUnwindSection(MergedOutputSection *cuSection) {
     compactUnwindSection = cuSection;
   }
 
-  using EncodingMap = llvm::DenseMap<compact_unwind_encoding_t, size_t>;
-
-  struct SecondLevelPage {
-    uint32_t kind;
-    size_t entryIndex;
-    size_t entryCount;
-    size_t byteCount;
-    std::vector<compact_unwind_encoding_t> localEncodings;
-    EncodingMap localEncodingIndexes;
-  };
+protected:
+  UnwindInfoSection()
+      : SyntheticSection(segment_names::text, section_names::unwindInfo) {
+    align = 4;
+  }
 
-private:
-  std::vector<std::pair<compact_unwind_encoding_t, size_t>> commonEncodings;
-  EncodingMap commonEncodingIndexes;
-  // Indices of personality functions within the GOT.
-  std::vector<uint32_t> personalities;
-  std::vector<unwind_info_section_header_lsda_index_entry> lsdaEntries;
-  // Map of function offset (from the image base) to an index within the LSDA
-  // array.
-  llvm::DenseMap<uint32_t, uint32_t> functionToLsdaIndex;
-  std::vector<CompactUnwindEntry64> cuVector;
-  std::vector<CompactUnwindEntry64 *> cuPtrVector;
-  std::vector<SecondLevelPage> secondLevelPages;
   MergedOutputSection *compactUnwindSection = nullptr;
-  uint64_t level2PagesOffset = 0;
   uint64_t unwindInfoSize = 0;
 };
 
+UnwindInfoSection *makeUnwindInfoSection();
 void prepareCompactUnwind(InputSection *isec);
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/UnwindInfoSection.cpp

 //
 // Refer to the definition of unwind_info_section_header in
 // compact_unwind_encoding.h for an overview of the format we are encoding
 // here.
 
 // TODO(gkm): prune __eh_frame entries superseded by __unwind_info
 // TODO(gkm): how do we align the 2nd-level pages?
 
-UnwindInfoSection::UnwindInfoSection()
-    : SyntheticSection(segment_names::text, section_names::unwindInfo) {
-  align = 4; // mimic ld64
-}
-
-bool UnwindInfoSection::isNeeded() const {
-  return (compactUnwindSection != nullptr);
-}
+using EncodingMap = llvm::DenseMap<compact_unwind_encoding_t, size_t>;
 
+template <class Ptr> struct CompactUnwindEntry {
+  Ptr functionAddress;
+  uint32_t functionLength;
+  compact_unwind_encoding_t encoding;
+  Ptr personality;
+  Ptr lsda;
+};
+
+struct SecondLevelPage {
+  uint32_t kind;
+  size_t entryIndex;
+  size_t entryCount;
+  size_t byteCount;
+  std::vector<compact_unwind_encoding_t> localEncodings;
+  EncodingMap localEncodingIndexes;
+};
+
+template <class Ptr> class UnwindInfoSectionImpl : public UnwindInfoSection {
+public:
+  void prepareRelocations(InputSection *) override;
+  void finalize() override;
+  void writeTo(uint8_t *buf) const override;
+
+private:
+  std::vector<std::pair<compact_unwind_encoding_t, size_t>> commonEncodings;
+  EncodingMap commonEncodingIndexes;
+  // Indices of personality functions within the GOT.
+  std::vector<uint32_t> personalities;
   SmallDenseMap<std::pair<InputSection *, uint64_t /* addend */>, Symbol *>
       personalityTable;
+  std::vector<unwind_info_section_header_lsda_index_entry> lsdaEntries;
+  // Map of function offset (from the image base) to an index within the LSDA
+  // array.
+  llvm::DenseMap<uint32_t, uint32_t> functionToLsdaIndex;
+  std::vector<CompactUnwindEntry<Ptr>> cuVector;
+  std::vector<CompactUnwindEntry<Ptr> *> cuPtrVector;
+  std::vector<SecondLevelPage> secondLevelPages;
+  uint64_t level2PagesOffset = 0;
+};
 
 // 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.
-void macho::prepareCompactUnwind(InputSection *isec) {
+template <class Ptr>
+void UnwindInfoSectionImpl<Ptr>::prepareRelocations(InputSection *isec) {
   assert(isec->segname == segment_names::ld &&
          isec->name == section_names::compactUnwind);
 
   for (Reloc &r : isec->relocs) {
     assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
-    if (r.offset % sizeof(CompactUnwindEntry64) !=
-        offsetof(struct CompactUnwindEntry64, personality))
+    if (r.offset % sizeof(CompactUnwindEntry<Ptr>) !=
+        offsetof(CompactUnwindEntry<Ptr>, personality))
       continue;
 
     if (auto *s = r.referent.dyn_cast<Symbol *>()) {
       if (auto *undefined = dyn_cast<Undefined>(s)) {
         treatUndefinedSymbol(*undefined);
         // treatUndefinedSymbol() can replace s with a DylibSymbol; re-check.
         if (isa<Undefined>(s))
           continue;
if (isec->segname != segment_names::text)
     error("compact unwind references address in " + toString(isec) +
           " which is not in segment __TEXT");
 }
 
 // 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.
-static void relocateCompactUnwind(MergedOutputSection *compactUnwindSection,
-                                  std::vector<CompactUnwindEntry64> &cuVector) {
+template <class Ptr>
+static void
+relocateCompactUnwind(MergedOutputSection *compactUnwindSection,
+                      std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
   for (const InputSection *isec : compactUnwindSection->inputs) {
     uint8_t *buf =
         reinterpret_cast<uint8_t *>(cuVector.data()) + isec->outSecFileOff;
     memcpy(buf, isec->data.data(), isec->data.size());
 
     for (const Reloc &r : isec->relocs) {
       uint64_t referentVA = 0;
       if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
         if (!isa<Undefined>(referentSym)) {
           assert(referentSym->isInGot());
           if (auto *defined = dyn_cast<Defined>(referentSym))
             checkTextSegment(defined->isec);
           // At this point in the link, we may not yet know the final address of
           // the GOT, so we just encode the index. We make it a 1-based index so
           // that we can distinguish the null pointer case.
           referentVA = referentSym->gotIndex + 1;
         }
       } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
         checkTextSegment(referentIsec);
         referentVA = referentIsec->getVA() + r.addend;
       }
-      support::endian::write64le(buf + r.offset, referentVA);
+
+      writeAddress(buf + r.offset, referentVA, r.length);
     }
   }
 }
 
 // There should only be a handful of unique personality pointers, so we can
 // encode them as 2-bit indices into a small array.
-void encodePersonalities(const std::vector<CompactUnwindEntry64 *> &cuPtrVector,
-                         std::vector<uint32_t> &personalities) {
-  for (CompactUnwindEntry64 *cu : cuPtrVector) {
+template <class Ptr>
+void encodePersonalities(
+    const std::vector<CompactUnwindEntry<Ptr> *> &cuPtrVector,
+  for (CompactUnwindEntry<Ptr> *cu : cuPtrVector) {
     if (cu->personality == 0)
       continue;
-    uint32_t personalityOffset = cu->personality - in.header->addr;
     // Linear search is fast enough for a small array.
-    auto it = find(personalities, personalityOffset);
+    auto it = find(personalities, cu->personality);
     uint32_t personalityIndex; // 1-based index
     if (it != personalities.end()) {
       personalityIndex = std::distance(personalities.begin(), it) + 1;
     } else {
       personalities.push_back(cu->personality);
       personalityIndex = personalities.size();
     }
     cu->encoding |=
         personalityIndex << countTrailingZeros(
             static_cast<compact_unwind_encoding_t>(UNWIND_PERSONALITY_MASK));
   }
   if (personalities.size() > 3)
     error("too many personalities (" + std::to_string(personalities.size()) +
           ") for compact unwind to encode");
 }
 
 // Scan the __LD,__compact_unwind entries and compute the space needs of
 // __TEXT,__unwind_info and __TEXT,__eh_frame
-void UnwindInfoSection::finalize() {
+template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
   if (compactUnwindSection == nullptr)
     return;
 
   // 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!
   compactUnwindSection->finalize();
-  assert(compactUnwindSection->getSize() % sizeof(CompactUnwindEntry64) == 0);
+  assert(compactUnwindSection->getSize() % sizeof(CompactUnwindEntry<Ptr>) ==
+         0);
   size_t cuCount =
-      compactUnwindSection->getSize() / sizeof(CompactUnwindEntry64);
+      compactUnwindSection->getSize() / sizeof(CompactUnwindEntry<Ptr>);
   cuVector.resize(cuCount);
   relocateCompactUnwind(compactUnwindSection, 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(cuCount);
-  for (CompactUnwindEntry64 &cuEntry : cuVector)
+  for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
     cuPtrVector.emplace_back(&cuEntry);
-  std::sort(cuPtrVector.begin(), cuPtrVector.end(),
-            [](const CompactUnwindEntry64 *a, const CompactUnwindEntry64 *b) {
-              return a->functionAddress < b->functionAddress;
-            });
+  std::sort(
+      cuPtrVector.begin(), cuPtrVector.end(),
+      [](const CompactUnwindEntry<Ptr> *a, const CompactUnwindEntry<Ptr> *b) {
 
   // Fold adjacent entries with matching encoding+personality+lsda
   // We use three iterators on the same cuPtrVector to fold in-situ:
   // (1) `foldBegin` is the first of a potential sequence of matching entries
   // (2) `foldEnd` is the first non-matching entry after `foldBegin`.
   // The semi-open interval [ foldBegin .. foldEnd ) contains a range
   // entries that can be folded into a single entry and written to ...
   // (3) `foldWrite`
for (auto foldBegin = cuPtrVector.begin(); foldBegin < cuPtrVector.end();) {
     foldBegin = foldEnd;
   }
   cuPtrVector.erase(foldWrite, cuPtrVector.end());
 
   encodePersonalities(cuPtrVector, personalities);
 
   // Count frequencies of the folded encodings
   EncodingMap encodingFrequencies;
-  for (const CompactUnwindEntry64 *cuPtrEntry : cuPtrVector)
+  for (const CompactUnwindEntry<Ptr> *cuPtrEntry : cuPtrVector)
     encodingFrequencies[cuPtrEntry->encoding]++;
 
   // Make a vector of encodings, sorted by descending frequency
   for (const auto &frequency : encodingFrequencies)
     commonEncodings.emplace_back(frequency);
   std::sort(commonEncodings.begin(), commonEncodings.end(),
             [](const std::pair<compact_unwind_encoding_t, size_t> &a,
                const std::pair<compact_unwind_encoding_t, size_t> &b) {
template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
   // (b) 24-bit difference between first & final function address
   // (c) 8-bit compact-encoding-table index,
   //     for which 0..126 references the global common-encodings table,
   //     and 127..255 references a local per-second-level-page table.
   // First we try the compact format and determine how many entries fit.
   // If more entries fit in the regular format, we use that.
   for (size_t i = 0; i < cuPtrVector.size();) {
     secondLevelPages.emplace_back();
-    UnwindInfoSection::SecondLevelPage &page = secondLevelPages.back();
+    SecondLevelPage &page = secondLevelPages.back();
     page.entryIndex = i;
     uintptr_t functionAddressMax =
         cuPtrVector[i]->functionAddress + COMPRESSED_ENTRY_FUNC_OFFSET_MASK;
     size_t n = commonEncodings.size();
     size_t wordsRemaining =
         SECOND_LEVEL_PAGE_WORDS -
         sizeof(unwind_info_compressed_second_level_page_header) /
             sizeof(uint32_t);
     while (wordsRemaining >= 1 && i < cuPtrVector.size()) {
-      const CompactUnwindEntry64 *cuPtr = cuPtrVector[i];
+      const CompactUnwindEntry<Ptr> *cuPtr = cuPtrVector[i];
       if (cuPtr->functionAddress >= functionAddressMax) {
         break;
       } else if (commonEncodingIndexes.count(cuPtr->encoding) ||
                  page.localEncodingIndexes.count(cuPtr->encoding)) {
         i++;
         wordsRemaining--;
       } else if (wordsRemaining >= 2 && n < COMPACT_ENCODINGS_MAX) {
         page.localEncodings.emplace_back(cuPtr->encoding);
if (i < cuPtrVector.size() &&
       page.entryCount = std::min(REGULAR_SECOND_LEVEL_ENTRIES_MAX,
                                  cuPtrVector.size() - page.entryIndex);
       i = page.entryIndex + page.entryCount;
     } else {
       page.kind = UNWIND_SECOND_LEVEL_COMPRESSED;
     }
   }
 
-  for (const CompactUnwindEntry64 *cu : cuPtrVector) {
+  for (const CompactUnwindEntry<Ptr> *cu : cuPtrVector) {
     uint32_t functionOffset = cu->functionAddress - in.header->addr;
     functionToLsdaIndex[functionOffset] = lsdaEntries.size();
     if (cu->lsda != 0)
       lsdaEntries.push_back(
           {functionOffset, static_cast<uint32_t>(cu->lsda - in.header->addr)});
   }
 
   // compute size of __TEXT,__unwind_info section
   level2PagesOffset =
       sizeof(unwind_info_section_header) +
       commonEncodings.size() * sizeof(uint32_t) +
       personalities.size() * sizeof(uint32_t) +
       // The extra second-level-page entry is for the sentinel
       (secondLevelPages.size() + 1) *
           sizeof(unwind_info_section_header_index_entry) +
       lsdaEntries.size() * sizeof(unwind_info_section_header_lsda_index_entry);
   unwindInfoSize =
       level2PagesOffset + secondLevelPages.size() * SECOND_LEVEL_PAGE_BYTES;
 }
 
 // All inputs are relocated and output addresses are known, so write!
 
-void UnwindInfoSection::writeTo(uint8_t *buf) const {
+template <class Ptr>
+void UnwindInfoSectionImpl<Ptr>::writeTo(uint8_t *buf) const {
   // section header
   auto *uip = reinterpret_cast<unwind_info_section_header *>(buf);
   uip->version = 1;
   uip->commonEncodingsArraySectionOffset = sizeof(unwind_info_section_header);
   uip->commonEncodingsArrayCount = commonEncodings.size();
   uip->personalityArraySectionOffset =
       uip->commonEncodingsArraySectionOffset +
       (uip->commonEncodingsArrayCount * sizeof(uint32_t));
   uip->personalityArrayCount = personalities.size();
   uip->indexSectionOffset = uip->personalityArraySectionOffset +
                             (uip->personalityArrayCount * sizeof(uint32_t));
   uip->indexCount = secondLevelPages.size() + 1;
 
   // Common encodings
   auto *i32p = reinterpret_cast<uint32_t *>(&uip[1]);
   for (const auto &encoding : commonEncodings)
     *i32p++ = encoding.first;
 
   // Personalities
   for (const uint32_t &personality : personalities)
-    *i32p++ = in.got->addr + (personality - 1) * target->wordSize;
+    *i32p++ =
+        in.got->addr + (personality - 1) * target->wordSize - in.header->addr;
 
   // Level-1 index
   uint32_t lsdaOffset =
       uip->indexSectionOffset +
       uip->indexCount * sizeof(unwind_info_section_header_index_entry);
   uint64_t l2PagesOffset = level2PagesOffset;
   auto *iep = reinterpret_cast<unwind_info_section_header_index_entry *>(i32p);
   for (const SecondLevelPage &page : secondLevelPages) {
     iep->functionOffset =
         cuPtrVector[page.entryIndex]->functionAddress - in.header->addr;
     iep->secondLevelPagesSectionOffset = l2PagesOffset;
     iep->lsdaIndexArraySectionOffset =
         lsdaOffset + functionToLsdaIndex.lookup(iep->functionOffset) *
                          sizeof(unwind_info_section_header_lsda_index_entry);
     iep++;
     l2PagesOffset += SECOND_LEVEL_PAGE_BYTES;
   }
   // Level-1 sentinel
-  const CompactUnwindEntry64 &cuEnd = cuVector.back();
+  const CompactUnwindEntry<Ptr> &cuEnd = cuVector.back();
   iep->functionOffset = cuEnd.functionAddress + cuEnd.functionLength;
   iep->secondLevelPagesSectionOffset = 0;
   iep->lsdaIndexArraySectionOffset =
       lsdaOffset +
       lsdaEntries.size() * sizeof(unwind_info_section_header_lsda_index_entry);
   iep++;
 
   // LSDAs
if (page.kind == UNWIND_SECOND_LEVEL_COMPRESSED) {
       p2p->entryPageOffset =
           sizeof(unwind_info_compressed_second_level_page_header);
       p2p->entryCount = page.entryCount;
       p2p->encodingsPageOffset =
           p2p->entryPageOffset + p2p->entryCount * sizeof(uint32_t);
       p2p->encodingsCount = page.localEncodings.size();
       auto *ep = reinterpret_cast<uint32_t *>(&p2p[1]);
       for (size_t i = 0; i < page.entryCount; i++) {
-        const CompactUnwindEntry64 *cuep = cuPtrVector[page.entryIndex + i];
+        const CompactUnwindEntry<Ptr> *cuep = cuPtrVector[page.entryIndex + i];
         auto it = commonEncodingIndexes.find(cuep->encoding);
         if (it == commonEncodingIndexes.end())
           it = page.localEncodingIndexes.find(cuep->encoding);
         *ep++ = (it->second << COMPRESSED_ENTRY_FUNC_OFFSET_BITS) |
                 (cuep->functionAddress - functionAddressBase);
       }
       if (page.localEncodings.size() != 0)
         memcpy(ep, page.localEncodings.data(),
                page.localEncodings.size() * sizeof(uint32_t));
     } else {
       auto *p2p =
           reinterpret_cast<unwind_info_regular_second_level_page_header *>(pp);
       p2p->kind = page.kind;
       p2p->entryPageOffset =
           sizeof(unwind_info_regular_second_level_page_header);
       p2p->entryCount = page.entryCount;
       auto *ep = reinterpret_cast<uint32_t *>(&p2p[1]);
       for (size_t i = 0; i < page.entryCount; i++) {
-        const CompactUnwindEntry64 *cuep = cuPtrVector[page.entryIndex + i];
+        const CompactUnwindEntry<Ptr> *cuep = cuPtrVector[page.entryIndex + i];
         *ep++ = cuep->functionAddress;
         *ep++ = cuep->encoding;
       }
     }
     pp += SECOND_LEVEL_PAGE_WORDS;
   }
 }
+
+UnwindInfoSection *macho::makeUnwindInfoSection() {
+  if (target->wordSize == 8)
+    return make<UnwindInfoSectionImpl<uint64_t>>();
+  else
+    return make<UnwindInfoSectionImpl<uint32_t>>();
+}

lld/MachO/Writer.cpp

public:
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   MachHeaderSection *header = nullptr;
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
   IndirectSymtabSection *indirectSymtabSection = nullptr;
   CodeSignatureSection *codeSignatureSection = nullptr;
-  UnwindInfoSection *unwindInfoSection = nullptr;
   FunctionStartsSection *functionStartsSection = nullptr;
 
   LCUuid *uuidCommand = nullptr;
   OutputSegment *linkEditSegment = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
 class LCDyldInfo : public LoadCommand {
if (!(isThreadLocalVariables(isec->flags) && isa<Defined>(sym)))
       addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
   }
 }
 
 void Writer::scanRelocations() {
   TimeTraceScope timeScope("Scan relocations");
   for (InputSection *isec : inputSections) {
     if (isec->segname == segment_names::ld) {
-      prepareCompactUnwind(isec);
+      in.unwindInfo->prepareRelocations(isec);
       continue;
     }
 
     for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
       Reloc &r = *it;
       if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
         // Skip over the following UNSIGNED relocation -- it's just there as the
         // minuend, and doesn't have the usual UNSIGNED semantics. We don't want
if (newName != config->segmentRenameMap.end())
     return std::make_pair(newName->second, key.second);
   return key;
 }
 
 template <class LP> void Writer::createOutputSections() {
   TimeTraceScope timeScope("Create output sections");
   // First, create hidden sections
   stringTableSection = make<StringTableSection>();
-  unwindInfoSection = make<UnwindInfoSection>(); // TODO(gkm): only when no -r
   symtabSection = makeSymtabSection<LP>(*stringTableSection);
   indirectSymtabSection = make<IndirectSymtabSection>();
   if (config->adhocCodesign)
     codeSignatureSection = make<CodeSignatureSection>();
   if (config->emitFunctionStarts)
     functionStartsSection = make<FunctionStartsSection>();
 
   switch (config->outputType) {
for (InputSection *isec : inputSections) {
     if (osec == nullptr)
       osec = make<MergedOutputSection>(names.second);
     osec->mergeInput(isec);
   }
 
   for (const auto &it : mergedOutputSections) {
     StringRef segname = it.first.first;
     MergedOutputSection *osec = it.second;
-    if (unwindInfoSection && segname == segment_names::ld) {
+    if (segname == segment_names::ld) {
       assert(osec->name == section_names::compactUnwind);
-      unwindInfoSection->setCompactUnwindSection(osec);
+      in.unwindInfo->setCompactUnwindSection(osec);
     } else {
       getOrCreateOutputSegment(segname)->addOutputSection(osec);
     }
   }
 
   for (SyntheticSection *ssec : syntheticSections) {
     auto it = mergedOutputSections.find({ssec->segname, ssec->name});
     if (it == mergedOutputSections.end()) {
template <class LP> 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.imageLoaderCache = make<ImageLoaderCacheSection>();
+  in.unwindInfo = makeUnwindInfoSection();
 }
 
 OutputSection *macho::firstTLVDataSection = nullptr;
 
 template void macho::writeResult<LP64>();
 template void macho::writeResult<ILP32>();
 template void macho::createSyntheticSections<LP64>();
 template void macho::createSyntheticSections<ILP32>();

lld/test/MachO/compact-unwind.s

 # REQUIRES: x86, aarch64
 # RUN: rm -rf %t; split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/my-personality.s -o %t/x86_64-my-personality.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/main.s -o %t/x86_64-main.o
 # RUN: %lld -arch x86_64 -pie -lSystem -lc++ %t/x86_64-my-personality.o %t/x86_64-main.o -o %t/x86_64-personality-first
-# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x100000000
 # RUN: %lld -arch x86_64 -pie -lSystem -lc++ %t/x86_64-main.o %t/x86_64-my-personality.o -o %t/x86_64-personality-second
-# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/x86_64-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK -D#%x,BASE=0x100000000
 
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin19.0.0 %t/my-personality.s -o %t/arm64-my-personality.o
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin19.0.0 %t/main.s -o %t/arm64-main.o
 # RUN: %lld -arch arm64 -pie -lSystem -lc++ %t/arm64-my-personality.o %t/arm64-main.o -o %t/arm64-personality-first
-# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x100000000
 # RUN: %lld -arch arm64 -pie -lSystem -lc++ %t/arm64-main.o %t/arm64-my-personality.o -o %t/arm64-personality-second
-# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK -D#%x,BASE=0x100000000
+
+# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %t/my-personality.s -o %t/arm64-32-my-personality.o
+# RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %t/main.s -o %t/arm64-32-main.o
+# RUN: %lld-watchos -pie -lSystem -lc++ %t/arm64-32-my-personality.o %t/arm64-32-main.o -o %t/arm64-32-personality-first
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-32-personality-first | FileCheck %s --check-prefixes=FIRST,CHECK -D#%x,BASE=0x4000
+# RUN: %lld-watchos -pie -lSystem -lc++ %t/arm64-32-main.o %t/arm64-32-my-personality.o -o %t/arm64-32-personality-second
+# RUN: llvm-objdump --macho --unwind-info --syms --indirect-symbols --rebase %t/arm64-32-personality-second | FileCheck %s --check-prefixes=SECOND,CHECK -D#%x,BASE=0x4000
 
 # FIRST:      Indirect symbols for (__DATA_CONST,__got)
 # FIRST-NEXT: address                    index name
 # FIRST-DAG:  0x[[#%x,GXX_PERSONALITY:]] [[#]] ___gxx_personality_v0
 # FIRST-DAG:  0x[[#%x,MY_PERSONALITY:]]  LOCAL
 
 # SECOND:      Indirect symbols for (__DATA_CONST,__got)
 # SECOND-NEXT: address                    index name
 # SECOND-DAG:  0x[[#%x,GXX_PERSONALITY:]] [[#]] ___gxx_personality_v0
 # SECOND-DAG:  0x[[#%x,MY_PERSONALITY:]]  [[#]] _my_personality
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-DAG:  [[#%x,MAIN:]]       g  F __TEXT,__text _main
 # CHECK-DAG:  [[#%x,FOO:]]        l  F __TEXT,__text _foo
 # CHECK-DAG:  [[#%x,EXCEPTION0:]] g  O __TEXT,__gcc_except_tab _exception0
 # CHECK-DAG:  [[#%x,EXCEPTION1:]] g  O __TEXT,__gcc_except_tab _exception1
 
 # CHECK:      Contents of __unwind_info section:
 # CHECK:        Personality functions: (count = 2)
-# CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#MY_PERSONALITY-0x100000000]]
-# CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#GXX_PERSONALITY-0x100000000]]
+# CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#MY_PERSONALITY-BASE]]
+# CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#GXX_PERSONALITY-BASE]]
 # CHECK:        LSDA descriptors:
-# CHECK-DAG:     function offset=0x{{0*}}[[#FOO-0x100000000]],  LSDA offset=0x{{0*}}[[#EXCEPTION0-0x100000000]]
-# CHECK-DAG:     function offset=0x{{0*}}[[#MAIN-0x100000000]], LSDA offset=0x{{0*}}[[#EXCEPTION1-0x100000000]]
+# CHECK-DAG:     function offset=0x[[#%.8x,FOO-BASE]],  LSDA offset=0x[[#%.8x,EXCEPTION0-BASE]]
+# CHECK-DAG:     function offset=0x[[#%.8x,MAIN-BASE]], LSDA offset=0x[[#%.8x,EXCEPTION1-BASE]]
 
 ## Check that we do not add rebase opcodes to the compact unwind section.
 # CHECK:      Rebase table:
 # CHECK-NEXT: segment      section        address          type
-# CHECK-NEXT: __DATA_CONST __got          0x{{[0-9a-f]*}}  pointer
+# CHECK-NEXT: __DATA_CONST __got          0x{{[0-9A-F]*}}  pointer
 # CHECK-NOT:  __TEXT
 
 #--- my-personality.s
 .globl _my_personality, _exception0
 .text
 .p2align 2
 _foo:
   .cfi_startproc