[JITLink][ELF/AARCH64] Implement R_AARCH64_ADR_GOT_PAGE and R_AARCH64_LD64_GOT_LO12_NC

[sunho]

Summary

This patch implements two most commonly used Global Offset Table relocations in ELF/AARCH64: R_AARCH64_ADR_GOT_PAGE and R_AARCH64_LD64_GOT_LO12_NC. It implements the GOT table manager by extending the existing PerGraphGOTAndPLTStubsBuilder. I brought a lot of code from Macho/ARM64 backend's GOT manager and it looks very possible to unify them to generic aarch64 got table manager.

I thought it's better to unify them in the later patch to focus changes on ELF backend, but I can do it in this patch if that's preferred.

[sunho]

Rebase

[sunho]

Fix msvc build

[lhames]

LGTM.

I brought a lot of code from Macho/ARM64 backend's GOT manager and it looks very possible to unify them to generic aarch64 got table manager.

Absolutely -- it would be great to unify these.

I thought it's better to unify them in the later patch to focus changes on ELF backend, but I can do it in this patch if that's preferred.

I think it makes sense to land this as-is, then unify support in a follow-up patch.

llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp

 #include "ELFLinkGraphBuilder.h"
 #include "JITLinkGeneric.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/ExecutionEngine/JITLink/aarch64.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MathExtras.h"
 
+#include "PerGraphGOTAndPLTStubsBuilder.h"
+
 #define DEBUG_TYPE "jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 namespace llvm {
 namespace jitlink {
 
enum ELFAArch64RelocationKind : Edge::Kind {
     ELFAdrPage21,
     ELFAddAbs12,
     ELFLdSt8Abs12,
     ELFLdSt16Abs12,
     ELFLdSt32Abs12,
     ELFLdSt64Abs12,
     ELFLdSt128Abs12,
     ELFAbs64,
+    ELFAdrGOTPage21,
+    ELFLd64GOTLo12,
   };
 
   static Expected<ELFAArch64RelocationKind>
   getRelocationKind(const uint32_t Type) {
     using namespace aarch64;
     switch (Type) {
     case ELF::R_AARCH64_CALL26:
       return ELFCall26;
     case ELF::R_AARCH64_ADR_PREL_PG_HI21:
       return ELFAdrPage21;
     case ELF::R_AARCH64_ADD_ABS_LO12_NC:
       return ELFAddAbs12;
     case ELF::R_AARCH64_LDST8_ABS_LO12_NC:
       return ELFLdSt8Abs12;
     case ELF::R_AARCH64_LDST16_ABS_LO12_NC:
       return ELFLdSt16Abs12;
     case ELF::R_AARCH64_LDST32_ABS_LO12_NC:
       return ELFLdSt32Abs12;
     case ELF::R_AARCH64_LDST64_ABS_LO12_NC:
       return ELFLdSt64Abs12;
     case ELF::R_AARCH64_LDST128_ABS_LO12_NC:
       return ELFLdSt128Abs12;
     case ELF::R_AARCH64_ABS64:
       return ELFAbs64;
+    case ELF::R_AARCH64_ADR_GOT_PAGE:
+      return ELFAdrGOTPage21;
+    case ELF::R_AARCH64_LD64_GOT_LO12_NC:
+      return ELFLd64GOTLo12;
     }
 
     return make_error<JITLinkError>("Unsupported aarch64 relocation:" +
                                     formatv("{0:d}", Type));
   }
 
   Error addRelocations() override {
     LLVM_DEBUG(dbgs() << "Processing relocations:\n");
case ELFLdSt128Abs12: {
 
       Kind = aarch64::PageOffset12;
       break;
     }
     case ELFAbs64: {
       Kind = aarch64::Pointer64;
       break;
     }
+    case ELFAdrGOTPage21: {
+      Kind = aarch64::GOTPage21;
+      break;
+    }
+    case ELFLd64GOTLo12: {
+      Kind = aarch64::GOTPageOffset12;
+      break;
+    }
     };
 
     Edge GE(Kind, Offset, *GraphSymbol, Addend);
     LLVM_DEBUG({
       dbgs() << "    ";
       printEdge(dbgs(), BlockToFix, GE, aarch64::getEdgeKindName(Kind));
       dbgs() << "\n";
     });
const char *getELFAArch64RelocationKindName(Edge::Kind R) {
     case ELFLdSt32Abs12:
       return "ELFLdSt32Abs12";
     case ELFLdSt64Abs12:
       return "ELFLdSt64Abs12";
     case ELFLdSt128Abs12:
       return "ELFLdSt128Abs12";
     case ELFAbs64:
       return "ELFAbs64";
+    case ELFAdrGOTPage21:
+      return "ELFAdrGOTPage21";
+    case ELFLd64GOTLo12:
+      return "ELFLd64GOTLo12";
     default:
       return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
     }
   }
 
 public:
   ELFLinkGraphBuilder_aarch64(StringRef FileName,
                               const object::ELFFile<ELFT> &Obj, const Triple T)
       : ELFLinkGraphBuilder<ELFT>(Obj, std::move(T), FileName,
                                   aarch64::getEdgeKindName) {}
 };
 
+class PerGraphGOTAndPLTStubsBuilder_ELF_arm64
+    : public PerGraphGOTAndPLTStubsBuilder<
+          PerGraphGOTAndPLTStubsBuilder_ELF_arm64> {
+public:
+  using PerGraphGOTAndPLTStubsBuilder<
+      PerGraphGOTAndPLTStubsBuilder_ELF_arm64>::PerGraphGOTAndPLTStubsBuilder;
+
+  bool isGOTEdgeToFix(Edge &E) const {
+    return E.getKind() == aarch64::GOTPage21 ||
+           E.getKind() == aarch64::GOTPageOffset12;
+  }
+
+  Symbol &createGOTEntry(Symbol &Target) {
+    auto &GOTEntryBlock = G.createContentBlock(
+        getGOTSection(), getGOTEntryBlockContent(), orc::ExecutorAddr(), 8, 0);
+    GOTEntryBlock.addEdge(aarch64::Pointer64, 0, Target, 0);
+    return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
+  }
+
+  void fixGOTEdge(Edge &E, Symbol &GOTEntry) {
+    if (E.getKind() == aarch64::GOTPage21) {
+      E.setKind(aarch64::Page21);
+      E.setTarget(GOTEntry);
+    } else if (E.getKind() == aarch64::GOTPageOffset12) {
+      E.setKind(aarch64::PageOffset12);
+      E.setTarget(GOTEntry);
+    } else
+      llvm_unreachable("Not a GOT edge?");
+  }
+
+  bool isExternalBranchEdge(Edge &E) { return false; }
+
+  Symbol &createPLTStub(Symbol &Target) {
+    assert(false && "unimplemetned");
+    return Target;
+  }
+
+  void fixPLTEdge(Edge &E, Symbol &Stub) { assert(false && "unimplemetned"); }
+
+private:
+  Section &getGOTSection() {
+    if (!GOTSection)
+      GOTSection = &G.createSection("$__GOT", MemProt::Read | MemProt::Exec);
+    return *GOTSection;
+  }
+
+  ArrayRef<char> getGOTEntryBlockContent() {
+    return {reinterpret_cast<const char *>(NullGOTEntryContent),
+            sizeof(NullGOTEntryContent)};
+  }
+
+  static const uint8_t NullGOTEntryContent[8];
+  Section *GOTSection = nullptr;
+};
+
+const uint8_t PerGraphGOTAndPLTStubsBuilder_ELF_arm64::NullGOTEntryContent[8] =
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {
     if (auto MarkLive = Ctx->getMarkLivePass(TT))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
   }
+
+  Config.PostPrunePasses.push_back(
+      PerGraphGOTAndPLTStubsBuilder_ELF_arm64::asPass);
+
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
   ELFJITLinker_aarch64::link(std::move(Ctx), std::move(G), std::move(Config));
 }
 
 } // namespace jitlink
 } // namespace llvm

llvm/test/ExecutionEngine/JITLink/AArch64/ELF_aarch64_relocations.s

 # RUN: rm -rf %t && mkdir -p %t
 # RUN: llvm-mc -triple=aarch64-unknown-linux-gnu -relax-relocations=false \
 # RUN:   -position-independent -filetype=obj -o %t/elf_reloc.o %s
-# RUN: llvm-jitlink -noexec -check %s %t/elf_reloc.o
+# RUN: llvm-jitlink -noexec \
+# RUN:              -abs external_data=0xdeadbeef \
+# RUN:              -check %s %t/elf_reloc.o
 
         .text
 
         .globl  main
         .p2align  2
         .type main,@function
 main:
         ret

 #
 # jitlink-check: *{8}local_func_addr_quad = named_func
         .globl  local_func_addr_quad
         .p2align  3
 local_func_addr_quad:
         .xword  named_func
         .size local_func_addr_quad, 8
 
+# Check R_AARCH64_ADR_GOT_PAGE / R_AARCH64_LD64_GOT_LO12_NC handling with a
+# reference to an external symbol. Validate both the reference to the GOT entry,
+# and also the content of the GOT entry.
+#
+# For the ADRP :got: instruction we have the 21-bit delta to the 4k page
+# containing the GOT entry for external_data.
+#
+# For the LDR :got_lo12: instruction we have the 12-bit offset of the entry
+# within the page.
+#
+# jitlink-check: *{8}(got_addr(elf_reloc.o, external_data)) = external_data
+# jitlink-check: decode_operand(test_adr_gotpage_external, 1) = \
+# jitlink-check:     (got_addr(elf_reloc.o, external_data)[32:12] - \
+# jitlink-check:        test_adr_gotpage_external[32:12])
+# jitlink-check: decode_operand(test_ld64_gotlo12_external, 2) = \
+# jitlink-check:     got_addr(elf_reloc.o, external_data)[11:3]
+        .globl  test_adr_gotpage_external
+        .p2align  2
+test_adr_gotpage_external:
+        adrp  x0, :got:external_data
+        .size test_adr_gotpage_external, .-test_adr_gotpage_external
+
+        .globl  test_ld64_gotlo12_external
+        .p2align  2
+test_ld64_gotlo12_external:
+        ldr   x0, [x0, :got_lo12:external_data]
+        .size test_ld64_gotlo12_external, .-test_ld64_gotlo12_external
+
         .globl  named_data
         .p2align  4
         .type   named_data,@object
 named_data:
         .quad   0x2222222222222222
         .quad   0x3333333333333333
         .size   named_data, .-named_data
 
         .globl  named_func
         .p2align  2
         .type named_func,@function
 named_func:
         ret
         .size   named_func, .-named_func