[ELF/AArch64] Add support for R_AARCH64_ADR_GOT_PAGE and R_AARCH64_LD64_GOT_LO12_NC.

[ikudrin]

Summary

With these relocations, I'm able to build a simple "hello world" program for AArch64 Debian.

[davide]

ELF/Target.cpp

678

cant' this just be a one-liner?
something like
return R_AARCH64_ADR_GOT_PAGE || R_AARCH64_LD64_GOT_LO12_NC || relocNeedsPlt();

740–741

Please convert to the new overflow checker helper once you commit that.

[ikudrin]

ELF/Target.cpp

678

We may have more GOT relocations in the near future, like R_AARCH64_*_GOTOFF_*, R_AARCH64_GOT_LD_PREL19, R_AARCH64_LD64_GOTPAGE_LO15.

740–741

Sure.

[davide]

ELF/Target.cpp

678

If we'll get there, we can switch over. I'm for simplicity until we need something more complicated.

[ikudrin]

• Rebase to the top.
• Remove the switch statement in the AArch64TargetInfo::relocNeedsGot() method.

[davide]

Looks good, thank you!

[ruiu]

LGTM with a nit.

ELF/Target.cpp

672–673

Remove ()s. (We can assume that everybody knows that == takes precedence over ||.)

ELF/InputSection.cpp

for (const RelType &RI : Rels) {
     }
 
     uintX_t SymVA = getSymVA<ELFT>(Body);
     if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
       Type = Target->getPltRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
-      Type = Body.isTLS() ? Target->getTlsGotReloc() : Target->getGotRefReloc();
+      Type = Body.isTLS() ? Target->getTlsGotReloc()
+                          : Target->getGotRefReloc(Type);
     } else if (Target->relocPointsToGot(Type)) {
       SymVA = Out<ELFT>::Got->getVA();
       Type = Target->getPCRelReloc();
     } else if (!Target->relocNeedsCopy(Type, Body) &&
                isa<SharedSymbol<ELFT>>(Body)) {
       continue;
     }
     Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,

ELF/Target.h

 class TargetInfo {
 public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const;
   unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getPCRelReloc() const { return PCRelReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
-  unsigned getGotRefReloc() const { return GotRefReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
   unsigned getTlsGotReloc() const { return TlsGotReloc; }
   unsigned getTlsPcRelGotReloc() const { return TlsPcRelGotReloc; }
   bool isTlsLocalDynamicReloc(unsigned Type) const {
     return Type == TlsLocalDynamicReloc;
   }
   bool isTlsGlobalDynamicReloc(unsigned Type) const {
     return Type == TlsGlobalDynamicReloc;
   }
   unsigned getTlsModuleIndexReloc() const { return TlsModuleIndexReloc; }
   unsigned getTlsOffsetReloc() const { return TlsOffsetReloc; }
   unsigned getPltZeroEntrySize() const { return PltZeroEntrySize; }
   unsigned getPltEntrySize() const { return PltEntrySize; }
   bool supportsLazyRelocations() const { return LazyRelocations; }
   unsigned getGotHeaderEntriesNum() const { return GotHeaderEntriesNum; }
   unsigned getGotPltHeaderEntriesNum() const { return GotPltHeaderEntriesNum; }
+  virtual unsigned getGotRefReloc(unsigned Type) const;
   virtual unsigned getPltRefReloc(unsigned Type) const;
   virtual void writeGotHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
   virtual void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                  uint64_t PltEntryAddr) const = 0;
   virtual void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                              uint64_t PltEntryAddr, int32_t Index) const = 0;

ELF/Target.cpp

public:
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
+  unsigned getGotRefReloc(unsigned Type) const override;
   unsigned getPltRefReloc(unsigned Type) const override;
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
   void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;

 TargetInfo::~TargetInfo() {}
 
 uint64_t TargetInfo::getVAStart() const { return Config->Shared ? 0 : VAStart; }
 
 bool TargetInfo::relocNeedsCopy(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 
+unsigned TargetInfo::getGotRefReloc(unsigned Type) const { return GotRefReloc; }
+
 unsigned TargetInfo::getPltRefReloc(unsigned Type) const { return PCRelReloc; }
 
 bool TargetInfo::relocPointsToGot(uint32_t Type) const { return false; }
 
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
 void TargetInfo::writeGotHeaderEntries(uint8_t *Buf) const {}
 
case R_PPC64_TOC:
     write64be(Loc, SA);
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
+  GotReloc = R_AARCH64_GLOB_DAT;
   PltReloc = R_AARCH64_JUMP_SLOT;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 32;
 }
 
+unsigned AArch64TargetInfo::getGotRefReloc(unsigned Type) const { return Type; }
+
 unsigned AArch64TargetInfo::getPltRefReloc(unsigned Type) const { return Type; }
 
 void AArch64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
   write64le(Buf, Out<ELF64LE>::Plt->getVA());
 }
 
 void AArch64TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                           uint64_t PltEntryAddr) const {
void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
   relocateOne(Buf + 4, Buf + 8, R_AARCH64_LDST64_ABS_LO12_NC, PltEntryAddr + 4,
               GotEntryAddr);
   relocateOne(Buf + 8, Buf + 12, R_AARCH64_ADD_ABS_LO12_NC, PltEntryAddr + 8,
               GotEntryAddr);
 }
 
 bool AArch64TargetInfo::relocNeedsGot(uint32_t Type,
                                       const SymbolBody &S) const {
-  return relocNeedsPlt(Type, S);
+  return (Type == R_AARCH64_ADR_GOT_PAGE) ||
+         (Type == R_AARCH64_LD64_GOT_LO12_NC) || relocNeedsPlt(Type, S);
 }
 
 bool AArch64TargetInfo::relocNeedsPlt(uint32_t Type,
                                       const SymbolBody &S) const {
   switch (Type) {
   default:
     return false;
   case R_AARCH64_JUMP26:
   case R_AARCH64_CALL26:
     return canBePreempted(&S, true);
   }
 }
 
case R_AARCH64_ADD_ABS_LO12_NC:
     or32le(Loc, (SA & 0xFFF) << 10);
     break;
   case R_AARCH64_ADR_PREL_LO21: {
     uint64_t X = SA - P;
     checkAArch64OutOfRange<21>(X, Type);
     updateAArch64Adr(Loc, X & 0x1FFFFF);
     break;
   }
+  case R_AARCH64_ADR_GOT_PAGE:
   case R_AARCH64_ADR_PREL_PG_HI21: {
     uint64_t X = getAArch64Page(SA) - getAArch64Page(P);
     checkAArch64OutOfRange<33>(X, Type);
     updateAArch64Adr(Loc, (X >> 12) & 0x1FFFFF); // X[32:12]
     break;
   }
   case R_AARCH64_JUMP26:
   case R_AARCH64_CALL26: {
     uint64_t X = SA - P;
     checkAArch64OutOfRange<28>(X, Type);
     or32le(Loc, (X & 0x0FFFFFFC) >> 2);
     break;
   }
   case R_AARCH64_LDST32_ABS_LO12_NC:
     // No overflow check needed.
     or32le(Loc, (SA & 0xFFC) << 8);
     break;
+  case R_AARCH64_LD64_GOT_LO12_NC:
+    if (SA & 0x7)
+      error("Relocation R_AARCH64_LD64_GOT_LO12_NC not aligned");
+    // No overflow check needed.
+    or32le(Loc, (SA & 0xFF8) << 7);
+    break;
   case R_AARCH64_LDST64_ABS_LO12_NC:
     // No overflow check needed.
     or32le(Loc, (SA & 0xFF8) << 7);
     break;
   case R_AARCH64_LDST8_ABS_LO12_NC:
     // No overflow check needed.
     or32le(Loc, (SA & 0xFFF) << 10);
     break;

test/ELF/got-aarch64.s

+// RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %s -o %t.o
+// RUN: ld.lld -shared %t.o -o %t.so
+// RUN: llvm-readobj -s -r %t.so | FileCheck %s
+// RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
+// REQUIRES: aarch64
+
+// CHECK:      Name: .got
+// CHECK-NEXT: Type: SHT_PROGBITS
+// CHECK-NEXT: Flags [
+// CHECK-NEXT:   SHF_ALLOC
+// CHECK-NEXT:   SHF_WRITE
+// CHECK-NEXT: ]
+// CHECK-NEXT: Address: 0x2098
+// CHECK-NEXT: Offset:
+// CHECK-NEXT: Size: 8
+// CHECK-NEXT: Link: 0
+// CHECK-NEXT: Info: 0
+// CHECK-NEXT: AddressAlignment: 8
+
+// CHECK:      Relocations [
+// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
+// CHECK-NEXT:     0x2098 R_AARCH64_GLOB_DAT dat 0x0
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+
+// Page(0x2098) - Page(0x1000) = 0x1000 = 4096
+// 0x2098 & 0xff8 = 0x98 = 152
+
+// DISASM: main:
+// DISASM-NEXT:     1000: {{.*}} adrp x0, #4096
+// DISASM-NEXT:     1004: {{.*}} ldr x0, [x0, #152]
+
+.global main,foo,dat
+.text
+main:
+    adrp x0, :got:dat
+    ldr x0, [x0, :got_lo12:dat]
+.data
+dat:
+    .word 42