Do not patch FDE symbols in RuntimeDyld, on targets that use non-absolute symbol relocations in .eh_frame

Since processFDE adds a delta to the values in the FDE, it assumes that the relocations for the .eh_frame section have not been applied by RuntimeDyld. It expects instead that only the relocation addend has been written to the symbol locations, and that the section-to-section offset needs to be added.

However, there are platform differences that interfere with this:
1) X86-64 has DwarfFDESymbolsUseAbsDiff enabled in its AsmInfo, causing an absolute symbol to be emitted for the FDE pcStart.  Absolute symbols are skipped as a relocation by RuntimeDyld, so the processFDE function in RuntimeDyldMachO.cpp calculates the relocation correctly.
2) AArch64 has DwarfFDESymbolsUseAbsDiff disabled, so a relocation is emitted in the eh_frame section. Since this isn't absolute, the relocation is applied by RuntimeDyld. This means that processFDE ends up adding an additional section-to-section offset to the pcStart field, generating an incorrect FDE

Differential Revision: https://reviews.llvm.org/D103052

Author: Cody Tapscott

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp

@@ -272,9 +272,9 @@ RuntimeDyldMachOCRTPBase<Impl>::finalizeLoad(const ObjectFile &Obj,
 }
 
 template <typename Impl>
-unsigned char *RuntimeDyldMachOCRTPBase<Impl>::processFDE(uint8_t *P,
-                                                          int64_t DeltaForText,
-                                                          int64_t DeltaForEH) {
+unsigned char *RuntimeDyldMachOCRTPBase<Impl>::patchFDERelocations(uint8_t *P,
+                                                                   int64_t DeltaForText,
+                                                                   int64_t DeltaForEH) {
   typedef typename Impl::TargetPtrT TargetPtrT;
 
   LLVM_DEBUG(dbgs() << "Processing FDE: Delta for text: " << DeltaForText
@@ -324,19 +324,24 @@ void RuntimeDyldMachOCRTPBase<Impl>::registerEHFrames() {
       continue;
     SectionEntry *Text = &Sections[SectionInfo.TextSID];
     SectionEntry *EHFrame = &Sections[SectionInfo.EHFrameSID];
-    SectionEntry *ExceptTab = nullptr;
-    if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID)
-      ExceptTab = &Sections[SectionInfo.ExceptTabSID];
-
-    int64_t DeltaForText = computeDelta(Text, EHFrame);
-    int64_t DeltaForEH = 0;
-    if (ExceptTab)
-      DeltaForEH = computeDelta(ExceptTab, EHFrame);
-
-    uint8_t *P = EHFrame->getAddress();
-    uint8_t *End = P + EHFrame->getSize();
-    while (P != End) {
-      P = processFDE(P, DeltaForText, DeltaForEH);
+
+    // If the FDE includes absolute symbol relocations (not supported
+    // by RuntimeDyld), we need to manually patch-up the values
+    if (doDwarfFDESymbolsUseAbsDiff()) {
+      SectionEntry *ExceptTab = nullptr;
+      if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID)
+        ExceptTab = &Sections[SectionInfo.ExceptTabSID];
+
+      int64_t DeltaForText = computeDelta(Text, EHFrame);
+      int64_t DeltaForEH = 0;
+      if (ExceptTab)
+        DeltaForEH = computeDelta(ExceptTab, EHFrame);
+
+      uint8_t *P = EHFrame->getAddress();
+      uint8_t *End = P + EHFrame->getSize();
+      while (P != End) {
+        P = patchFDERelocations(P, DeltaForText, DeltaForEH);
+      }
     }
 
     MemMgr.registerEHFrames(EHFrame->getAddress(), EHFrame->getLoadAddress(),

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.h

@@ -43,6 +43,10 @@ class RuntimeDyldMachO : public RuntimeDyldImpl {
     SID ExceptTabSID;
   };
 
+  // Returns true if the FDE section includes absolute symbol relocations
+  // on this platform.
+  virtual bool doDwarfFDESymbolsUseAbsDiff() = 0;
+
   // When a module is loaded we save the SectionID of the EH frame section
   // in a table until we receive a request to register all unregistered
   // EH frame sections with the memory manager.
@@ -147,8 +151,8 @@ class RuntimeDyldMachOCRTPBase : public RuntimeDyldMachO {
   Impl &impl() { return static_cast<Impl &>(*this); }
   const Impl &impl() const { return static_cast<const Impl &>(*this); }
 
-  unsigned char *processFDE(uint8_t *P, int64_t DeltaForText,
-                            int64_t DeltaForEH);
+  unsigned char *patchFDERelocations(uint8_t *P, int64_t DeltaForText,
+                                     int64_t DeltaForEH);
 
 public:
   RuntimeDyldMachOCRTPBase(RuntimeDyld::MemoryManager &MemMgr,

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h

@@ -30,6 +30,8 @@ class RuntimeDyldMachOAArch64
 
   unsigned getStubAlignment() override { return 8; }
 
+  bool doDwarfFDESymbolsUseAbsDiff() override { return false; }
+  
   /// Extract the addend encoded in the instruction / memory location.
   Expected<int64_t> decodeAddend(const RelocationEntry &RE) const {
     const SectionEntry &Section = Sections[RE.SectionID];

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h

@@ -33,6 +33,8 @@ class RuntimeDyldMachOARM
 
   unsigned getStubAlignment() override { return 4; }
 
+  bool doDwarfFDESymbolsUseAbsDiff() override { return false; }
+
   Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
     auto Flags = RuntimeDyldImpl::getJITSymbolFlags(SR);
     if (!Flags)

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOI386.h

@@ -30,6 +30,8 @@ class RuntimeDyldMachOI386
 
   unsigned getStubAlignment() override { return 1; }
 
+  bool doDwarfFDESymbolsUseAbsDiff() override { return true; }
+
   Expected<relocation_iterator>
   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
                        const ObjectFile &BaseObjT,

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOX86_64.h

@@ -30,6 +30,8 @@ class RuntimeDyldMachOX86_64
 
   unsigned getStubAlignment() override { return 8; }
 
+  bool doDwarfFDESymbolsUseAbsDiff() override { return true; }
+
   Expected<relocation_iterator>
   processRelocationRef(unsigned SectionID, relocation_iterator RelI,
                        const ObjectFile &BaseObjT,