Change reference kind for FDE references the compiler already emitted

[pete]

Summary

In processFDE, we currently early exit if there are any references. This is taken to mean the the compiler knew what it was doing so we trust it.

However, there were a couple of issues here.

The first is that these references may not have the correct kind. For example, we expect the function reference to be of type unwindFDEToFunction and so must change the kind of the compiler emitted reference to that. Similarly for CFI and LSDA.

The second issue was that we were stopping processing the FDE if the compiler emitted any references, but there's no guarantee that it emitted all of them. So the compiler may emit a func ref but we should still parse the FDE to generate the CFI and LSDA refs.

We now work out which refs we got from the compiler, then parse the FDE. We create those refs which the compiler did not emit, and any it did are converted to the correct kinds.

[kledzik]

lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

762–774 ↗

(On Diff #42492)

You can also add asserts that the offset of the reference in the atom is the correct location in the compact unwind struct.

Actually, all these should not be assert()s. Malformed input files should generate a (descriptive) error message (not an assert).

824–828 ↗

(On Diff #42492)

The other way to fix this is in getPairReferenceInfo() to check the type of "inAtom" and if compact unwind, generate an unwindFDEToFunction instead of delta32.

The difference between the two is that unwindFDEToFunction does not create a reloc in -r mode. That is, it upgrades the format to not need the relocation.

test/mach-o/eh-frame-relocs-arm64.yaml

1–3 ↗

(On Diff #42492)

I like to add an extra round trip test here. That is, run lld again on %t to verify the new output (that should be same as original input) still passes the test.

[pete]

lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

762–774 ↗

(On Diff #42492)

Yeah, you're right.

There's a couple of asserts which were there already but which I can also convert to error messages. For example, we make sure that CIE references from the FDE point to the start of the CIE atom:

assert(!addend && "FDE's CIE field does not point at the start of a CIE.");
assert(cie && cie->contentType() == DefinedAtom::typeCFI &&

"FDE's CIE field does not point at the start of a CIE.");

In this case, I should actually also add that the contentType is CFI but also that we return true from ArchHandler::isDwarfCIE(isBig, atom).

In terms of the error checking, it will be hard to write the error checking tests without committing (some version of) this patch first. Would you be ok with me doing extensive error checking (including replacing most of the asserts) in follow up commits from this one?

824–828 ↗

(On Diff #42492)

That actually sounds better to handle this in getPairReferenceInfo(). I took a look but its slightly more complicated than just checking the atom type. For example, CIE's and FDE's both get typeCFI, so when processing a delta64 we don't know if we are in an FDE with calling ArchHandler::isDwarfCIE(isBig, atom). That function is unfortunately long enough that I don't think I want to call it on all delta64's:

bool ArchHandler::isDwarfCIE(bool isBig, const DefinedAtom *atom) {

assert(atom->contentType() == DefinedAtom::typeCFI);
if (atom->rawContent().size() < sizeof(uint32_t))
  return false;
uint32_t size = read32(atom->rawContent().data(), isBig);

uint32_t idOffset = sizeof(uint32_t);
if (size == 0xffffffffU)
  idOffset += sizeof(uint64_t);

return read32(atom->rawContent().data() + idOffset, isBig) == 0;

}

Perhaps I could add a typeCIE and typeFDE and classify these early, and remove typeCFI?

test/mach-o/eh-frame-relocs-arm64.yaml

1–3 ↗

(On Diff #42492)

Ah yeah, i've seen that in other tests. I'll add that.

[kledzik]

lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

824–828 ↗

(On Diff #42492)

The design issue this is dancing around is unwindFDEToFunction vs delta32. In terms of the fixup they do in the final executable, they are the same thing. The reason for the existence of unwindFDEToFunction is two-fold: 1) In -r mode it suppresses a relocation being added to __compact_unwind section (since it is not needed), 2) slightly easier to differentiate ref to function vs ref to CIE when walking references.

By having unwindFDEToFunction, we make the parsing of the .o file slightly harder, but the rest of the linker is easier.

In this case we don't need/want relocations on the __compact_unwind section. Maybe another approach is to not have unwindFDEToFunction (just use delta32), but have a new attribute on sections saying where they use relocations or not. That way applyFixupFinal() would consult that section attribute to decide whether to make a reloc or not.

[pete]

Updated patch to address Nick's feedback about setting the kind of the reference in getPairReferenceInfo.

After r257099 (Don't emit relocs for the __eh_frame section as they can be implicit.), I've also had to update this patch to handle parsing the reloc in the CIE too, as it was otherwise being emitted as an implicit reloc (i.e., the reloc isn't edited at all, and the fixup bytes contain the offset to the personality function), but not parsed as an implicit reloc.

I'd like to handle more error checking in a follow up patch as this one has grown quite large already. Once the structure of this one is ok, i'll make sure all the asserts are errors and we have tests for them.

[lhames]

Thanks Pete!

lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

1001 ↗

(On Diff #44332)

These blocks (this one and the previous ones that use currentRefGetter) look pretty regular. Could these be pulled out into some sort of "fixEHFrameAtomReference" function? That could probably contain the logic from currentRefGetter too.

Otherwise LGTM.

lld/trunk/include/lld/Core/DefinedAtom.h

public:
   /// Utility function to check if the atom occupies file space
   bool occupiesDiskSpace() const {
     ContentType atomContentType = contentType();
     return !(atomContentType == DefinedAtom::typeZeroFill ||
              atomContentType == DefinedAtom::typeZeroFillFast ||
              atomContentType == DefinedAtom::typeTLVInitialZeroFill);
   }
 
+  /// Utility function to check if relocations in this atom to other defined
+  /// atoms can be implicitly generated, and so we don't need to explicitly
+  /// emit those relocations.
+  bool relocsToDefinedCanBeImplicit() const {
+    ContentType atomContentType = contentType();
+    return atomContentType == typeCFI;
+  }
+
   // Returns true if lhs should be placed before rhs in the final output.
   static bool compareByPosition(const DefinedAtom *lhs,
                                 const DefinedAtom *rhs);
 
 protected:
   // DefinedAtom is an abstract base class. Only subclasses can access
   // constructor.
   DefinedAtom() : Atom(definitionRegular) { }

lld/trunk/lib/ReaderWriter/MachO/ArchHandler.h

public:
   /// indirect value. Used for personality functions in the __unwind_info
   /// section.
   virtual Reference::KindValue imageOffsetKindIndirect() = 0;
 
   /// Architecture specific compact unwind type that signals __eh_frame should
   /// actually be used.
   virtual uint32_t dwarfCompactUnwindType() = 0;
 
+  /// Reference from an __eh_frame CIE atom to its personality function it's
+  /// describing. Usually pointer-sized and PC-relative, but differs in whether
+  /// it needs to be in relocatable objects.
+  virtual Reference::KindValue unwindRefToPersonalityFunctionKind() = 0;
+
   /// Reference from an __eh_frame FDE to the CIE it's based on.
   virtual Reference::KindValue unwindRefToCIEKind() = 0;
 
   /// Reference from an __eh_frame FDE atom to the function it's
   /// describing. Usually pointer-sized and PC-relative, but differs in whether
   /// it needs to be in relocatable objects.
   virtual Reference::KindValue unwindRefToFunctionKind() = 0;
 

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_arm.cpp

public:
   }
   Reference::KindValue imageOffsetKind() override {
     return invalid;
   }
   Reference::KindValue imageOffsetKindIndirect() override {
     return invalid;
   }
 
+  Reference::KindValue unwindRefToPersonalityFunctionKind() override {
+    return invalid;
+  }
+
   Reference::KindValue unwindRefToCIEKind() override {
     return invalid;
   }
 
   Reference::KindValue unwindRefToFunctionKind() override {
     return invalid;
   }
 

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_arm64.cpp

bool isGOTAccess(const Reference &ref, bool &canBypassGOT) override {
     switch (ref.kindValue()) {
     case gotPage21:
     case gotOffset12:
       canBypassGOT = true;
       return true;
     case delta32ToGOT:
       canBypassGOT = false;
       return true;
+    case unwindCIEToPersonalityFunction:
+      canBypassGOT = false;
+      return true;
     case imageOffsetGot:
       canBypassGOT = false;
       return true;
     default:
       return false;
     }
   }
 
public:
   }
   Reference::KindValue imageOffsetKind() override {
     return imageOffset;
   }
   Reference::KindValue imageOffsetKindIndirect() override {
     return imageOffsetGot;
   }
 
+  Reference::KindValue unwindRefToPersonalityFunctionKind() override {
+    return unwindCIEToPersonalityFunction;
+  }
+
   Reference::KindValue unwindRefToCIEKind() override {
     return negDelta32;
   }
 
   Reference::KindValue unwindRefToFunctionKind() override {
     return unwindFDEToFunction;
   }
 
enum Arm64Kind : Reference::KindValue {
 
     // Kinds introduced by Passes:
     addOffset12,           /// Location contains LDR to change into ADD.
     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).
+    unwindCIEToPersonalityFunction,   /// Nearly delta32ToGOT, but cannot be
+                           /// rematerialized in relocatable object
+                           /// (yay for implicit contracts!).
     unwindFDEToFunction,   /// Nearly delta64, but cannot be rematerialized in
                            /// relocatable object (yay for implicit contracts!).
     unwindInfoToEhFrame,   /// Fix low 24 bits of compact unwind encoding to
                            /// refer to __eh_frame entry.
   };
 
   void applyFixupFinal(const Reference &ref, uint8_t *location,
                        uint64_t fixupAddress, uint64_t targetAddress,
const Registry::KindStrings ArchHandler_arm64::_sKindStrings[] = {
   LLD_KIND_STRING_ENTRY(pointer64ToGOT),
   LLD_KIND_STRING_ENTRY(delta32ToGOT),
 
   LLD_KIND_STRING_ENTRY(addOffset12),
   LLD_KIND_STRING_ENTRY(lazyPointer),
   LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
   LLD_KIND_STRING_ENTRY(imageOffset),
   LLD_KIND_STRING_ENTRY(imageOffsetGot),
+  LLD_KIND_STRING_ENTRY(unwindCIEToPersonalityFunction),
   LLD_KIND_STRING_ENTRY(unwindFDEToFunction),
   LLD_KIND_STRING_ENTRY(unwindInfoToEhFrame),
 
   LLD_KIND_STRING_END
 };
 
 const ArchHandler::StubInfo ArchHandler_arm64::_sStubInfo = {
   "dyld_stub_binder",
case ARM64_RELOC_POINTER_TO_GOT              | rExtern | rLength8:
     // ex: .quad _foo@GOT
     *kind = pointer64ToGOT;
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   case ARM64_RELOC_POINTER_TO_GOT     | rPcRel | rExtern | rLength4:
     // ex: .long _foo@GOT - .
+
+    // If we are in an .eh_frame section, then the kind of the relocation should
+    // not be delta32ToGOT.  It may instead be unwindCIEToPersonalityFunction.
+    if (inAtom->contentType() == DefinedAtom::typeCFI)
+      *kind = unwindCIEToPersonalityFunction;
+    else
       *kind = delta32ToGOT;
+
     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
       return ec;
     *addend = 0;
     return std::error_code();
   default:
     return make_dynamic_error_code("unsupported arm64 relocation type");
   }
 }
case ((ARM64_RELOC_ADDEND                                | rLength4) << 16 |
     *kind = offset12KindFromInstruction(*cont32);
     if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
     *addend = reloc1.symbol;
     return std::error_code();
   case ((ARM64_RELOC_SUBTRACTOR                  | rExtern | rLength8) << 16 |
          ARM64_RELOC_UNSIGNED                    | rExtern | rLength8):
     // ex: .quad _foo - .
-    *kind = delta64;
     if (auto ec = atomFromSymbolIndex(reloc2.symbol, target))
       return ec;
+
+    // If we are in an .eh_frame section, then the kind of the relocation should
+    // not be delta64.  It may instead be unwindFDEToFunction.
+    if (inAtom->contentType() == DefinedAtom::typeCFI)
+      *kind = unwindFDEToFunction;
+    else
+      *kind = delta64;
+
     // The offsets of the 2 relocations must match
     if (reloc1.offset != reloc2.offset)
       return make_dynamic_error_code("paired relocs must have the same offset");
     *addend = (int64_t)*(const little64_t *)fixupContent + offsetInAtom;
     return std::error_code();
   case ((ARM64_RELOC_SUBTRACTOR                  | rExtern | rLength4) << 16 |
          ARM64_RELOC_UNSIGNED                    | rExtern | rLength4):
     // ex: .quad _foo - .
case pointer64ToGOT:
     *loc64 = targetAddress + ref.addend();
     return;
   case delta64:
   case unwindFDEToFunction:
     *loc64 = (targetAddress - fixupAddress) + ref.addend();
     return;
   case delta32:
   case delta32ToGOT:
+  case unwindCIEToPersonalityFunction:
     *loc32 = (targetAddress - fixupAddress) + ref.addend();
     return;
   case negDelta32:
     *loc32 = fixupAddress - targetAddress + ref.addend();
     return;
   case lazyPointer:
     // Do nothing
     return;
case negDelta32:
     *loc32 = fixupAddress - targetAddress + ref.addend();
     return;
   case pointer64ToGOT:
     *loc64 = 0;
     return;
   case delta32ToGOT:
     *loc32 = inAtomAddress - fixupAddress;
     return;
+  case unwindCIEToPersonalityFunction:
+    // We don't emit unwindCIEToPersonalityFunction in -r mode as they are
+    // implicitly generated from the data in the __eh_frame section.  So here we
+    // need to use the targetAddress so that we can generate the full relocation
+    // when we parse again later.
+    *loc32 = targetAddress - fixupAddress;
+    return;
   case addOffset12:
     llvm_unreachable("lazy reference kind implies GOT pass was run");
   case lazyPointer:
   case lazyImmediateLocation:
     llvm_unreachable("lazy reference kind implies Stubs pass was run");
   case imageOffset:
   case imageOffsetGot:
   case unwindInfoToEhFrame:
void ArchHandler_arm64::appendSectionRelocations(
   case addOffset12:
     llvm_unreachable("lazy reference kind implies GOT pass was run");
   case lazyPointer:
   case lazyImmediateLocation:
     llvm_unreachable("lazy reference kind implies Stubs pass was run");
   case imageOffset:
   case imageOffsetGot:
     llvm_unreachable("deltas from mach_header can only be in final images");
+  case unwindCIEToPersonalityFunction:
   case unwindFDEToFunction:
   case unwindInfoToEhFrame:
   case negDelta32:
     // Do nothing.
     return;
   case invalid:
     // Fall into llvm_unreachable().
     break;

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_x86.cpp

public:
   Reference::KindValue imageOffsetKind() override {
     return invalid;
   }
 
   Reference::KindValue imageOffsetKindIndirect() override {
     return invalid;
   }
 
+  Reference::KindValue unwindRefToPersonalityFunctionKind() override {
+    return invalid;
+  }
+
   Reference::KindValue unwindRefToCIEKind() override {
     return negDelta32;
   }
 
   Reference::KindValue unwindRefToFunctionKind() override{
     return delta32;
   }
 

lld/trunk/lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp

public:
   Reference::KindValue imageOffsetKind() override {
     return imageOffset;
   }
 
   Reference::KindValue imageOffsetKindIndirect() override {
     return imageOffsetGot;
   }
 
+  Reference::KindValue unwindRefToPersonalityFunctionKind() override {
+    return ripRel32Got;
+  }
+
   Reference::KindValue unwindRefToCIEKind() override {
     return negDelta32;
   }
 
   Reference::KindValue unwindRefToFunctionKind() override{
     return unwindFDEToFunction;
   }
 

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

static int64_t readSPtr(bool is64, bool isBig, const uint8_t *addr) {
   int32_t res = read32(addr, isBig);
   return res;
 }
 
 /// --- Augmentation String Processing ---
 
 struct CIEInfo {
   bool _augmentationDataPresent = false;
-  bool _mayHaveLSDA = false;
+  bool _mayHaveEH = false;
+  uint32_t _offsetOfLSDA = ~0U;
+  uint32_t _offsetOfPersonality = ~0U;
+  uint32_t _offsetOfFDEPointerEncoding = ~0U;
+  uint32_t _augmentationDataLength = ~0U;
 };
 
 typedef llvm::DenseMap<const MachODefinedAtom*, CIEInfo> CIEInfoMap;
 
 static std::error_code processAugmentationString(const uint8_t *augStr,
                                                  CIEInfo &cieInfo,
-                                                 unsigned *len = nullptr) {
+                                                 unsigned &len) {
 
   if (augStr[0] == '\0') {
-    if (len)
-      *len = 1;
+    len = 1;
     return std::error_code();
   }
 
   if (augStr[0] != 'z')
     return make_dynamic_error_code("expected 'z' at start of augmentation "
                                    "string");
 
   cieInfo._augmentationDataPresent = true;
   uint64_t idx = 1;
 
+  uint32_t offsetInAugmentationData = 0;
   while (augStr[idx] != '\0') {
     if (augStr[idx] == 'L') {
-      cieInfo._mayHaveLSDA = true;
+      cieInfo._offsetOfLSDA = offsetInAugmentationData;
+      // This adds a single byte to the augmentation data.
+      ++offsetInAugmentationData;
       ++idx;
-    } else
-      ++idx;
+      continue;
+    }
+    if (augStr[idx] == 'P') {
+      cieInfo._offsetOfPersonality = offsetInAugmentationData;
+      // This adds a single byte to the augmentation data for the encoding,
+      // then a number of bytes for the pointer data.
+      // FIXME: We are assuming 4 is correct here for the pointer size as we
+      // always currently use delta32ToGOT.
+      offsetInAugmentationData += 5;
+      ++idx;
+      continue;
+    }
+    if (augStr[idx] == 'R') {
+      cieInfo._offsetOfFDEPointerEncoding = offsetInAugmentationData;
+      // This adds a single byte to the augmentation data.
+      ++offsetInAugmentationData;
+      ++idx;
+      continue;
+    }
+    if (augStr[idx] == 'e') {
+      if (augStr[idx + 1] != 'h')
+        return make_dynamic_error_code("expected 'eh' in augmentation string");
+      cieInfo._mayHaveEH = true;
+      idx += 2;
+      continue;
+    }
   }
 
-  if (len)
-    *len = idx + 1;
+  cieInfo._augmentationDataLength = offsetInAugmentationData;
+
+  len = idx + 1;
   return std::error_code();
 }
 
 static std::error_code processCIE(const NormalizedFile &normalizedFile,
+                                  MachOFile &file,
+                                  mach_o::ArchHandler &handler,
+                                  const Section *ehFrameSection,
                                   MachODefinedAtom *atom,
+                                  uint64_t offset,
                                   CIEInfoMap &cieInfos) {
   const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   const uint8_t *frameData = atom->rawContent().data();
 
   CIEInfo cieInfo;
 
   uint32_t size = read32(frameData, isBig);
   uint64_t cieIDField = size == 0xffffffffU
                           ? sizeof(uint32_t) + sizeof(uint64_t)
                           : sizeof(uint32_t);
   uint64_t versionField = cieIDField + sizeof(uint32_t);
   uint64_t augmentationStringField = versionField + sizeof(uint8_t);
 
+  unsigned augmentationStringLength = 0;
   if (auto err = processAugmentationString(frameData + augmentationStringField,
-                                           cieInfo))
+                                           cieInfo, augmentationStringLength))
     return err;
 
+  if (cieInfo._offsetOfPersonality != ~0U) {
+    // If we have augmentation data for the personality function, then we may
+    // need to implicitly generate its relocation.
+
+    // Parse the EH Data field which is pointer sized.
+    uint64_t EHDataField = augmentationStringField + augmentationStringLength;
+    const bool is64 = MachOLinkingContext::is64Bit(normalizedFile.arch);
+    unsigned EHDataFieldSize = (cieInfo._mayHaveEH ? (is64 ? 8 : 4) : 0);
+
+    // Parse Code Align Factor which is a ULEB128.
+    uint64_t CodeAlignField = EHDataField + EHDataFieldSize;
+    unsigned lengthFieldSize = 0;
+    llvm::decodeULEB128(frameData + CodeAlignField, &lengthFieldSize);
+
+    // Parse Data Align Factor which is a SLEB128.
+    uint64_t DataAlignField = CodeAlignField + lengthFieldSize;
+    llvm::decodeSLEB128(frameData + DataAlignField, &lengthFieldSize);
+
+    // Parse Return Address Register which is a byte.
+    uint64_t ReturnAddressField = DataAlignField + lengthFieldSize;
+
+    // Parse the augmentation length which is a ULEB128.
+    uint64_t AugmentationLengthField = ReturnAddressField + 1;
+    uint64_t AugmentationLength =
+      llvm::decodeULEB128(frameData + AugmentationLengthField,
+                          &lengthFieldSize);
+
+    if (AugmentationLength != cieInfo._augmentationDataLength)
+      return make_dynamic_error_code("CIE augmentation data length mismatch");
+
+    // Get the start address of the augmentation data.
+    uint64_t AugmentationDataField = AugmentationLengthField + lengthFieldSize;
+
+    // Parse the personality function from the augmentation data.
+    uint64_t PersonalityField =
+      AugmentationDataField + cieInfo._offsetOfPersonality;
+
+    // Parse the personality encoding.
+    // FIXME: Verify that this is a 32-bit pcrel offset.
+    uint64_t PersonalityFunctionField = PersonalityField + 1;
+
+    if (atom->begin() != atom->end()) {
+      // If we have an explicit relocation, then make sure it matches this
+      // offset as this is where we'd expect it to be applied to.
+      DefinedAtom::reference_iterator CurrentRef = atom->begin();
+      if (CurrentRef->offsetInAtom() != PersonalityFunctionField)
+        return make_dynamic_error_code("CIE personality reloc at wrong offset");
+
+      if (++CurrentRef != atom->end())
+        return make_dynamic_error_code("CIE contains too many relocs");
+    } else {
+      // Implicitly generate the personality function reloc.  It's assumed to
+      // be a delta32 offset to a GOT entry.
+      // FIXME: Parse the encoding and check this.
+      int32_t funcDelta = read32(frameData + PersonalityFunctionField, isBig);
+      uint64_t funcAddress = ehFrameSection->address + offset +
+                             PersonalityFunctionField;
+      funcAddress += funcDelta;
+
+      const MachODefinedAtom *func = nullptr;
+      Reference::Addend addend;
+      func = findAtomCoveringAddress(normalizedFile, file, funcAddress,
+                                     &addend);
+      atom->addReference(Reference::KindNamespace::mach_o, handler.kindArch(),
+                         handler.unwindRefToPersonalityFunctionKind(),
+                         PersonalityFunctionField, func, addend);
+    }
+  } else if (atom->begin() != atom->end()) {
+    // Otherwise, we expect there to be no relocations in this atom as the only
+    // relocation would have been to the personality function.
+    return make_dynamic_error_code("unexpected relocation in CIE");
+  }
+
+
   cieInfos[atom] = std::move(cieInfo);
 
   return std::error_code();
 }
 
 static std::error_code processFDE(const NormalizedFile &normalizedFile,
                                   MachOFile &file,
                                   mach_o::ArchHandler &handler,
                                   const Section *ehFrameSection,
                                   MachODefinedAtom *atom,
                                   uint64_t offset,
                                   const CIEInfoMap &cieInfos) {
 
   const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   const bool is64 = MachOLinkingContext::is64Bit(normalizedFile.arch);
 
   // Compiler wasn't lazy and actually told us what it meant.
+  // Unfortunately, the compiler may not have generated references for all of
+  // [cie, func, lsda] and so we still need to parse the FDE and add references
+  // for any the compiler didn't generate.
   if (atom->begin() != atom->end())
-    return std::error_code();
+    atom->sortReferences();
+
+  DefinedAtom::reference_iterator CurrentRef = atom->begin();
+
+  // This helper returns the reference (if one exists) at the offset we are
+  // currently processing.  It automatically increments the ref iterator if we
+  // do return a ref, and throws an error if we pass over a ref without
+  // comsuming it.
+  auto currentRefGetter = [&CurrentRef,
+                           &atom](uint64_t Offset)->const Reference* {
+    // If there are no more refs found, then we are done.
+    if (CurrentRef == atom->end())
+      return nullptr;
+
+    const Reference *Ref = *CurrentRef;
+
+    // If we haven't reached the offset for this reference, then return that
+    // we don't yet have a reference to process.
+    if (Offset < Ref->offsetInAtom())
+      return nullptr;
+
+    // If the offset is equal, then we want to process this ref.
+    if (Offset == Ref->offsetInAtom()) {
+      ++CurrentRef;
+      return Ref;
+    }
+
+    // The current ref is at an offset which is earlier than the current
+    // offset, then we failed to consume it when we should have.  In this case
+    // throw an error.
+    llvm::report_fatal_error("Skipped reference when processing FDE");
+  };
+
+  // Helper to either get the reference at this current location, and verify
+  // that it is of the expected type, or add a reference of that type.
+  // Returns the reference target.
+  auto verifyOrAddReference = [&](uint64_t targetAddress,
+                                  Reference::KindValue refKind,
+                                  uint64_t refAddress,
+                                  bool allowsAddend)->const Atom* {
+    if (auto *ref = currentRefGetter(refAddress)) {
+      // The compiler already emitted a relocation for the CIE ref.  This should
+      // have been converted to the correct type of reference in
+      // get[Pair]ReferenceInfo().
+      assert(ref->kindValue() == refKind &&
+             "Incorrect EHFrame reference kind");
+      return ref->target();
+    }
+    Reference::Addend addend;
+    auto *target = findAtomCoveringAddress(normalizedFile, file,
+                                           targetAddress, &addend);
+    atom->addReference(Reference::KindNamespace::mach_o, handler.kindArch(),
+                       refKind, refAddress, target, addend);
+
+    if (!allowsAddend)
+      assert(!addend && "EHFrame reference cannot have addend");
+    return target;
+  };
+
+  const uint8_t *startFrameData = atom->rawContent().data();
+  const uint8_t *frameData = startFrameData;
 
-  const uint8_t *frameData = atom->rawContent().data();
   uint32_t size = read32(frameData, isBig);
   uint64_t cieFieldInFDE = size == 0xffffffffU
     ? sizeof(uint32_t) + sizeof(uint64_t)
     : sizeof(uint32_t);
 
   // Linker needs to fixup a reference from the FDE to its parent CIE (a
   // 32-bit byte offset backwards in the __eh_frame section).
   uint32_t cieDelta = read32(frameData + cieFieldInFDE, isBig);
   uint64_t cieAddress = ehFrameSection->address + offset + cieFieldInFDE;
   cieAddress -= cieDelta;
 
-  Reference::Addend addend;
-  const MachODefinedAtom *cie =
-    findAtomCoveringAddress(normalizedFile, file, cieAddress, &addend);
-  atom->addReference(Reference::KindNamespace::mach_o, handler.kindArch(),
-                     handler.unwindRefToCIEKind(), cieFieldInFDE, cie, addend);
-
-  assert(cie && cie->contentType() == DefinedAtom::typeCFI && !addend &&
+  auto *cieRefTarget = verifyOrAddReference(cieAddress,
+                                            handler.unwindRefToCIEKind(),
+                                            cieFieldInFDE, false);
+  const MachODefinedAtom *cie = dyn_cast<MachODefinedAtom>(cieRefTarget);
+  assert(cie && cie->contentType() == DefinedAtom::typeCFI &&
          "FDE's CIE field does not point at the start of a CIE.");
 
   const CIEInfo &cieInfo = cieInfos.find(cie)->second;
 
   // Linker needs to fixup reference from the FDE to the function it's
   // describing. FIXME: there are actually different ways to do this, and the
   // particular method used is specified in the CIE's augmentation fields
   // (hopefully)
   uint64_t rangeFieldInFDE = cieFieldInFDE + sizeof(uint32_t);
 
   int64_t functionFromFDE = readSPtr(is64, isBig,
                                      frameData + rangeFieldInFDE);
   uint64_t rangeStart = ehFrameSection->address + offset + rangeFieldInFDE;
   rangeStart += functionFromFDE;
 
-  const Atom *func =
-    findAtomCoveringAddress(normalizedFile, file, rangeStart, &addend);
-  atom->addReference(Reference::KindNamespace::mach_o, handler.kindArch(),
-                     handler.unwindRefToFunctionKind(), rangeFieldInFDE, func,
-                     addend);
+  verifyOrAddReference(rangeStart,
+                       handler.unwindRefToFunctionKind(),
+                       rangeFieldInFDE, true);
 
   // Handle the augmentation data if there is any.
   if (cieInfo._augmentationDataPresent) {
     // First process the augmentation data length field.
     uint64_t augmentationDataLengthFieldInFDE =
       rangeFieldInFDE + 2 * (is64 ? sizeof(uint64_t) : sizeof(uint32_t));
     unsigned lengthFieldSize = 0;
     uint64_t augmentationDataLength =
       llvm::decodeULEB128(frameData + augmentationDataLengthFieldInFDE,
                           &lengthFieldSize);
 
-    if (cieInfo._mayHaveLSDA && augmentationDataLength > 0) {
+    if (cieInfo._offsetOfLSDA != ~0U && augmentationDataLength > 0) {
 
       // Look at the augmentation data field.
       uint64_t augmentationDataFieldInFDE =
         augmentationDataLengthFieldInFDE + lengthFieldSize;
 
       int64_t lsdaFromFDE = readSPtr(is64, isBig,
                                      frameData + augmentationDataFieldInFDE);
       uint64_t lsdaStart =
         ehFrameSection->address + offset + augmentationDataFieldInFDE +
         lsdaFromFDE;
-      const Atom *lsda =
-        findAtomCoveringAddress(normalizedFile, file, lsdaStart, &addend);
-      atom->addReference(Reference::KindNamespace::mach_o, handler.kindArch(),
+
+      verifyOrAddReference(lsdaStart,
                            handler.unwindRefToFunctionKind(),
-                         augmentationDataFieldInFDE, lsda, addend);
+                           augmentationDataFieldInFDE, true);
     }
   }
 
   return std::error_code();
 }
 
 std::error_code addEHFrameReferences(const NormalizedFile &normalizedFile,
                                      MachOFile &file,
file.eachAtomInSection(*ehFrameSection,
     assert(atom->contentType() == DefinedAtom::typeCFI);
 
     // Bail out if we've encountered an error.
     if (ehFrameErr)
       return;
 
     const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
     if (ArchHandler::isDwarfCIE(isBig, atom))
-      ehFrameErr = processCIE(normalizedFile, atom, cieInfos);
+      ehFrameErr = processCIE(normalizedFile, file, handler, ehFrameSection,
+                              atom, offset, cieInfos);
     else
       ehFrameErr = processFDE(normalizedFile, file, handler, ehFrameSection,
                               atom, offset, cieInfos);
   });
 
   return ehFrameErr;
 }
 

lld/trunk/test/mach-o/do-not-emit-unwind-fde-arm64.yaml

sections:
   - segment:         __TEXT
     section:         __eh_frame
     type:            S_COALESCED
     attributes:      [  ]
     alignment:       8
     address:         0x0000000000000050
     content:         [ 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x01, 0x7A, 0x50, 0x4C, 0x52, 0x00, 0x01, 0x78,
-                       0x1E, 0x0B, 0x00, 0xED, 0xFF, 0xFF, 0xFF, 0xFF,
+                       0x1E, 0x07, 0x00, 0x9D, 0xFF, 0xFF, 0xFF, 0xFF,
                        0xFF, 0xFF, 0xFF, 0x00, 0x10, 0x0C, 0x1F, 0x00,
                        0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
                        0x88, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x08, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x00, 0x48, 0x0E, 0x10, 0x9E, 0x01, 0x9D, 0x02 ]
   - segment:         __TEXT
     section:         __gcc_except_tab

 # CHECK:   - ref-name:        L{{[0-9]*}}
 # CHECK:     scope:           hidden
 # CHECK:     type:            c-string
 # CHECK:     content:         [ 48, 65, 6C, 6C, 6F, 20, 77, 6F, 72, 6C, 64, 00 ]
 # CHECK:     merge:           by-content
 # CHECK:   - ref-name:        L{{[0-9]*}}
 # CHECK:     type:            unwind-cfi
 # CHECK:     content:         [ 1C, 00, 00, 00, 00, 00, 00, 00, 01, 7A, 50, 4C,
-# CHECK:                        52, 00, 01, 78, 1E, 0B, 00, ED, FF, FF, FF, FF,
-# CHECK:                        FF, FF, FF, 00, 10, 0C, 1F, 00 ]
+# CHECK:                        52, 00, 01, 78, 1E, 07, 00, {{..}}, {{..}}, {{..}}, {{..}}, {{..}},
+# CHECK:                        {{..}}, {{..}}, {{..}}, 00, 10, 0C, 1F, 00 ]
 # CHECK:   - type:            unwind-cfi
 # CHECK:     content:         [ 24, 00, 00, 00, 24, 00, 00, 00, {{..}}, {{..}}, {{..}}, {{..}},
 # CHECK:                        {{..}}, {{..}}, {{..}}, {{..}}, 20, 00, 00, 00, 00, 00, 00, 00,
 # CHECK:                        08, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, 48, 0E, 10,
 # CHECK:                        9E, 01, 9D, 02 ]
 # CHECK:     references:
 # CHECK:       - kind:            negDelta32
 # CHECK:         offset:          4

 # CODE-NOT: RELOCATION RECORDS FOR [__eh_frame]
 
 # Also make sure the reloc for the FDE->function is the correct offset
 # It should be the offset from the fixup location back to the address
 # of the function we are referencing
 # CODE: Contents of section __eh_frame:
 # This is the CIE:
 # CODE-NEXT: {{[0-9abcdef]*}} 1c000000 00000000 017a504c 52000178
-# CODE-NEXT: {{[0-9abcdef]*}} 1e0b00ed ffffffff ffffff00 100c1f00
+# CODE-NEXT: {{[0-9abcdef]*}} 1e0700bd ffffffff ffffff00 100c1f00
 # This is the FDE:
 # CODE-NEXT: {{[0-9abcdef]*}} 24000000 24000000 a8ffffff ffffffff
 # This is the important offset for FDE->func    ^~~~~~~~ ~~~~~~~~
 
 # CODE-NEXT: {{[0-9abcdef]*}} 20000000 00000000 08c3ffff ffffffff
 # And this is the offset for FDE->lsda            ^~~~~~~~ ~~~~~~
 # CODE-NEXT: {{[0-9abcdef]*}} ff480e10 9e019d02
 # And this byte               ^~

lld/trunk/test/mach-o/eh-frame-relocs-arm64.yaml

+# RUN: lld -flavor darwin -arch arm64 -r -print_atoms %s -o %t | FileCheck %s
+# RUN: lld -flavor darwin -arch arm64 -r -print_atoms %t -o %t2 | FileCheck %s
+# RUN: llvm-objdump -r -s -section="__eh_frame" -macho %t | FileCheck -check-prefix=CODE %s
+# RUN: llvm-objdump -r -s -section="__eh_frame" -macho %t2 | FileCheck -check-prefix=CODE %s
+
+
+--- !mach-o
+arch:            arm64
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+compat-version:  0.0
+current-version: 0.0
+has-UUID:        false
+OS:              unknown
+sections:        
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS ]
+    alignment:       4
+    address:         0x0000000000000000
+    content:         [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0xC0, 0x03, 0x5F, 0xD6, 0xC0, 0x03, 0x5F, 0xD6, 
+                       0xC0, 0x03, 0x5F, 0xD6 ]
+  - segment:         __TEXT
+    section:         __gcc_except_tab
+    type:            S_REGULAR
+    attributes:      [  ]
+    address:         0x0000000000000014
+    content:         [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]
+  - segment:         __DATA
+    section:         __data
+    type:            S_REGULAR
+    attributes:      [  ]
+    address:         0x000000000000001C
+    content:         [ 0x00, 0x00, 0x00, 0x00 ]
+  - segment:         __LD
+    section:         __compact_unwind
+    type:            S_REGULAR
+    attributes:      [  ]
+    alignment:       8
+    address:         0x0000000000000020
+    content:         [ 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ]
+    relocations:     
+      - offset:          0x00000020
+        type:            ARM64_RELOC_UNSIGNED
+        length:          3
+        pc-rel:          false
+        extern:          false
+        symbol:          1
+      - offset:          0x00000000
+        type:            ARM64_RELOC_UNSIGNED
+        length:          3
+        pc-rel:          false
+        extern:          false
+        symbol:          1
+  - segment:         __TEXT
+    section:         __eh_frame
+    type:            S_COALESCED
+    attributes:      [  ]
+    alignment:       8
+    address:         0x0000000000000060
+    content:         [ 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x03, 0x7A, 0x50, 0x4C, 0x52, 0x00, 0x01, 0x78, 
+                       0x1E, 0x07, 0x9B, 0xED, 0xFF, 0xFF, 0xFF, 0x10, 
+                       0x10, 0x0C, 0x1F, 0x00, 0x28, 0x00, 0x00, 0x00, 
+                       0x20, 0x00, 0x00, 0x00, 0xDC, 0xFF, 0xFF, 0xFF, 
+                       0xFF, 0xFF, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 
+                       0x00, 0x00, 0x00, 0x00, 0x08, 0xCB, 0xFF, 0xFF, 
+                       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0E, 0x10, 0x9E, 
+                       0x01, 0x9D, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+                       0x03, 0x7A, 0x50, 0x4C, 0x52, 0x00, 0x01, 0x78, 
+                       0x1E, 0x07, 0x9B, 0xA9, 0xFF, 0xFF, 0xFF, 0x10, 
+                       0x10, 0x0C, 0x1F, 0x00, 0x28, 0x00, 0x00, 0x00, 
+                       0x20, 0x00, 0x00, 0x00, 0x94, 0xFF, 0xFF, 0xFF, 
+                       0xFF, 0xFF, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 
+                       0x00, 0x00, 0x00, 0x00, 0x08, 0x83, 0xFF, 0xFF, 
+                       0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0E, 0x10, 0x9E, 
+                       0x01, 0x9D, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 ]
+    relocations:     
+      - offset:          0x0000007D
+        type:            ARM64_RELOC_SUBTRACTOR
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          6
+      - offset:          0x0000007D
+        type:            ARM64_RELOC_UNSIGNED
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          3
+      - offset:          0x0000006C
+        type:            ARM64_RELOC_SUBTRACTOR
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          6
+      - offset:          0x0000006C
+        type:            ARM64_RELOC_UNSIGNED
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          8
+      - offset:          0x0000005B
+        type:            ARM64_RELOC_POINTER_TO_GOT
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          10
+      - offset:          0x00000035
+        type:            ARM64_RELOC_SUBTRACTOR
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          6
+      - offset:          0x00000035
+        type:            ARM64_RELOC_UNSIGNED
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          2
+      - offset:          0x00000024
+        type:            ARM64_RELOC_SUBTRACTOR
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          6
+      - offset:          0x00000024
+        type:            ARM64_RELOC_UNSIGNED
+        length:          3
+        pc-rel:          false
+        extern:          true
+        symbol:          7
+      - offset:          0x00000013
+        type:            ARM64_RELOC_POINTER_TO_GOT
+        length:          2
+        pc-rel:          true
+        extern:          true
+        symbol:          9
+local-symbols:   
+  - name:            ltmp0
+    type:            N_SECT
+    sect:            1
+    value:           0x0000000000000000
+  - name:            ltmp1
+    type:            N_SECT
+    sect:            2
+    value:           0x0000000000000014
+  - name:            _bar1
+    type:            N_SECT
+    sect:            2
+    value:           0x0000000000000014
+  - name:            _bar2
+    type:            N_SECT
+    sect:            2
+    value:           0x0000000000000018
+  - name:            ltmp12
+    type:            N_SECT
+    sect:            3
+    value:           0x000000000000001C
+  - name:            ltmp13
+    type:            N_SECT
+    sect:            4
+    value:           0x0000000000000020
+  - name:            ltmp16
+    type:            N_SECT
+    sect:            5
+    value:           0x0000000000000060
+global-symbols:  
+  - name:            __Z3fooi
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000008
+  - name:            __Z4foo2i
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x000000000000000C
+  - name:            __gxx_personality_v0
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000000
+  - name:            __gxx_personality_v1
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000004
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000010
+  - name:            _someData
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            3
+    value:           0x000000000000001C
+page-size:       0x00000000
+...
+
+# CHECK: --- !native
+# CHECK: path:            '<linker-internal>'
+# CHECK: defined-atoms:   
+# CHECK:   - ref-name:        L000
+# CHECK:     type:            unwind-cfi
+# CHECK:     content:         [ 18, 00, 00, 00, 00, 00, 00, 00, 03, 7A, 50, 4C, 
+# CHECK:                        52, 00, 01, 78, 1E, 07, 9B, {{..}}, {{..}}, {{..}}, {{..}}, 10, 
+# CHECK:                        10, 0C, 1F, 00 ]
+# CHECK:     alignment:       8
+# CHECK:     references:      
+# CHECK:       - kind:            unwindCIEToPersonalityFunction
+# CHECK:         offset:          19
+# CHECK:         target:          __gxx_personality_v0
+# CHECK:   - type:            unwind-cfi
+# CHECK:     content:         [ 28, 00, 00, 00, 20, 00, 00, 00, {{..}}, {{..}}, {{..}}, {{..}}, 
+# CHECK:                        {{..}}, {{..}}, {{..}}, {{..}}, 04, 00, 00, 00, 00, 00, 00, 00, 
+# CHECK:                        08, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, 0E, 10, 9E, 
+# CHECK:                        01, 9D, 02, 00, 00, 00, 00, 00 ]
+# CHECK:     alignment:       4 mod 8
+# CHECK:     references:      
+# CHECK:       - kind:            negDelta32
+# CHECK:         offset:          4
+# CHECK:         target:          L000
+# CHECK:       - kind:            unwindFDEToFunction
+# CHECK:         offset:          8
+# CHECK:         target:          __Z3fooi
+# CHECK:       - kind:            unwindFDEToFunction
+# CHECK:         offset:          25
+# CHECK:         target:          _bar1
+# CHECK:   - ref-name:        L001
+# CHECK:     type:            unwind-cfi
+# CHECK:     content:         [ 18, 00, 00, 00, 00, 00, 00, 00, 03, 7A, 50, 4C, 
+# CHECK:                        52, 00, 01, 78, 1E, 07, 9B, {{..}}, {{..}}, {{..}}, {{..}}, 10, 
+# CHECK:                        10, 0C, 1F, 00 ]
+# CHECK:     alignment:       8
+# CHECK:     references:      
+# CHECK:       - kind:            unwindCIEToPersonalityFunction
+# CHECK:         offset:          19
+# CHECK:         target:          __gxx_personality_v1
+# CHECK:   - type:            unwind-cfi
+# CHECK:     content:         [ 28, 00, 00, 00, 20, 00, 00, 00, {{..}}, {{..}}, {{..}}, {{..}}, 
+# CHECK:                        {{..}}, {{..}}, {{..}}, {{..}}, 04, 00, 00, 00, 00, 00, 00, 00, 
+# CHECK:                        08, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, {{..}}, 0E, 10, 9E, 
+# CHECK:                        01, 9D, 02, 00, 00, 00, 00, 00 ]
+# CHECK:     alignment:       4 mod 8
+# CHECK:     references:      
+# CHECK:       - kind:            negDelta32
+# CHECK:         offset:          4
+# CHECK:         target:          L001
+# CHECK:       - kind:            unwindFDEToFunction
+# CHECK:         offset:          8
+# CHECK:         target:          __Z4foo2i
+# CHECK:       - kind:            unwindFDEToFunction
+# CHECK:         offset:          25
+# CHECK:         target:          _bar2
+# CHECK:   - name:            _bar1
+# CHECK:     type:            unwind-lsda
+# CHECK:     content:         [ 00, 00, 00, 00 ]
+# CHECK:   - name:            _bar2
+# CHECK:     type:            unwind-lsda
+# CHECK:     content:         [ 00, 00, 00, 00 ]
+# CHECK:   - name:            _someData
+# CHECK:     scope:           global
+# CHECK:     type:            data
+# CHECK:     content:         [ 00, 00, 00, 00 ]
+# CHECK:   - name:            __gxx_personality_v0
+# CHECK:     scope:           global
+# CHECK:     content:         [ 00, 00, 00, 00 ]
+# CHECK:     alignment:       4
+# CHECK:   - name:            __gxx_personality_v1
+# CHECK:     scope:           global
+# CHECK:     content:         [ 00, 00, 00, 00 ]
+# CHECK:     alignment:       4
+# CHECK:   - name:            __Z3fooi
+# CHECK:     scope:           global
+# CHECK:     content:         [ C0, 03, 5F, D6 ]
+# CHECK:     alignment:       4
+# CHECK:   - name:            __Z4foo2i
+# CHECK:     scope:           global
+# CHECK:     content:         [ C0, 03, 5F, D6 ]
+# CHECK:     alignment:       4
+# CHECK:   - name:            _main
+# CHECK:     scope:           global
+# CHECK:     content:         [ C0, 03, 5F, D6 ]
+# CHECK:     alignment:       4
+# CHECK: ...
+
+# # Make sure we don't have any relocations in the __eh_frame section
+# CODE-NOT: RELOCATION RECORDS FOR [__eh_frame]
+
+# Also make sure the reloc for the CIE->personality function is the
+# correct offset
+# It should be the offset from the fixup location back to the address
+# of the function we are referencing
+# CODE: Contents of section __eh_frame:
+# This is the CIE:
+# CODE-NEXT: {{[0-9abcdef]*}} 18000000 00000000 037a504c 52000178
+# CODE-NEXT: {{[0-9abcdef]*}} 1e079bd1 ffffff10 100c1f00 28000000
+# This is the important offset for CIE->pfunc
+#                                   ^~~~~~~~~
+# Then we have an FDE starting from 28000000 above
+# CODE-NEXT: {{[0-9abcdef]*}} 20000000 c8ffffff ffffffff 04000000
+# CODE-NEXT: {{[0-9abcdef]*}} 00000000 08c3ffff ffffffff ff0e109e
+# And a new CIE starts at this 00000018 right below here
+# CODE-NEXT: {{[0-9abcdef]*}} 019d0200 00000000 18000000 00000000
+# CODE-NEXT: {{[0-9abcdef]*}} 037a504c 52000178 1e079b8d ffffff10
+# This is the important offset for its CIE->pfunc     ^~~~~~~~~
 No newline at end of file