[ELF/AArch64] Add support for the R_AARCH64_COPY relocation.

[ikudrin]

Summary

Generate the R_AARCH64_COPY relocation for non-GOT relocations,
which reference object symbols from shared libraries.

[ruiu]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

These are GOT-relative relocations. Do you need to create copy relocations for them?

[ikudrin]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

They are in the same table "4-6, Data relocations" and in the same section "4.6.5 Static Data relocations" as R_AARCH64_ABS* in the following spec: http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf.

Can you hint me for some other specs?

[ruiu]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

I'm sorry if that's not clear, I pointed out PREL relocations. (I selected these three lines on Phab, but Phab includes plus/minus one lines to the diff in addition to the selection I made on the web UI.)

[ikudrin]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

Yes, I've commented the same lines, about _PREL* relocs. I have to admit that I haven't found a real sample to check all of them. I filled the list basing mostly on my understanding of specs. I'll really appreciate any hints and samples.

[ruiu]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

Since they are GOT-relative, all code that uses these relocations should always reference data through GOT, so no need to create copy relocations. Gold doesn't create copy relocations for them too.

[ikudrin]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

The spec says that they are position-relative, not GOT-relative. http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf.
Am I wrong? Do you have the other spec?

[ruiu]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

Hm, I may have misread the spec. But could you take a look at gold? It seems to me that they do not create copy relocations for them.

[ikudrin]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

Gold doesn't produce COPY relocations in that case. It only makes PLT entry if some conditions met. And they have a comment "This is used to fill the GOT absolute address".

[ruiu]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

Doesn't that mean we shouldn't create COPY relocations for PREL relocations, no? Or, are we different from gold?

[ikudrin]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

I've not finished my investigations with gold yet. I don't feel like we should just copy their behavior, I prefer to understand it first.

[ruiu]

ELF/Target.cpp

917–919 ↗

(On Diff #41303)

I completely agree.

[ikudrin]

• Removed R_AARCH64_PREL{16,32,64} relocations from the list of sources for COPY relocation.
• Sorted relocation codes.

[ruiu]

What was the conclusion on PREL relocations?

[ikudrin]

In D15043#299593, @ruiu wrote:

What was the conclusion on PREL relocations?

• Neither ld, nor gold create a COPY relocation for a source PREL relocation.
• For me, it's hard to imagine using a PREL relocation against an external preemtible object symbol.

So, nobody probably will suffer.

We have another difference from gold, concerning ABS relocations. They don't generate a COPY relocation if an ABS relocation targets a r/w segment; in this case, they just preserve the original relocation. Everything works fine because the dynamic linker from glibc supports ABS{32,64} relocations in addition to the standard dynamic relocations. I am not sure about other dynamic linkers, in particular, on FreeBSD, and anyway ld generates COPY relocations in that situation. Thus, I decided to generate COPY relocations in that case.

[ruiu]

LGTM. Thank you for investigating!

[ikudrin]

• Add check for the type of the output because COPY relocations shouldn't be created for shared objects.

[ruiu]

LGTM

ELF/Target.cpp

942–943 ↗

(On Diff #41632)

You may want to move this at beginning of this function?

lld/trunk/ELF/Target.cpp

public:
   AArch64TargetInfo();
   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 GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
+  bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint8_t *PairedLoc = nullptr) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
case R_PPC64_TOC:
     write64be(Loc, SA);
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
+  CopyReloc = R_AARCH64_COPY;
   GotReloc = R_AARCH64_GLOB_DAT;
   PltReloc = R_AARCH64_JUMP_SLOT;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 32;
 }
 
 unsigned AArch64TargetInfo::getPltRefReloc(unsigned Type) const { return Type; }
void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotAddr,
   relocateOne(Buf, Buf + 4, R_AARCH64_ADR_PREL_PG_HI21, PltEntryAddr,
               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::relocNeedsCopy(uint32_t Type,
+                                       const SymbolBody &S) const {
+  if (Config->Shared)
+    return false;
+  switch (Type) {
+  default:
+    return false;
+  case R_AARCH64_ABS16:
+  case R_AARCH64_ABS32:
+  case R_AARCH64_ABS64:
+  case R_AARCH64_ADD_ABS_LO12_NC:
+  case R_AARCH64_ADR_PREL_LO21:
+  case R_AARCH64_ADR_PREL_PG_HI21:
+  case R_AARCH64_LDST8_ABS_LO12_NC:
+  case R_AARCH64_LDST32_ABS_LO12_NC:
+  case R_AARCH64_LDST64_ABS_LO12_NC:
+    if (auto *SS = dyn_cast<SharedSymbol<ELF64LE>>(&S))
+      return SS->Sym.getType() == STT_OBJECT;
+    return false;
+  }
+}
+
 bool AArch64TargetInfo::relocNeedsGot(uint32_t Type,
                                       const SymbolBody &S) const {
   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 {

lld/trunk/test/ELF/Inputs/relocation-copy.s

 .bss
 
 .type x,@object
 .globl x
-.align 16
+.balign 16
 x:
 .long 0
 .size x, 4
 
 .type y,@object
 .globl y
-.align 16
+.balign 16
 y:
 .long 0
 .size y, 4
 
 .type z,@object
 .globl z
-.align 4
+.balign 4
 z:
 .long 0
 .size z, 4

lld/trunk/test/ELF/aarch64-copy.s

+// REQUIRES: aarch64
+// RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=aarch64-pc-freebsd %p/Inputs/relocation-copy.s -o %t2.o
+// RUN: ld.lld -shared %t2.o -o %t2.so
+// RUN: ld.lld %t.o %t2.so -o %t3
+// RUN: llvm-readobj -s -r --expand-relocs -symbols %t3 | FileCheck %s
+// RUN: llvm-objdump -d %t3 | FileCheck -check-prefix=CODE %s
+// RUN: llvm-objdump -s -section=.data %t3 | FileCheck -check-prefix=DATA %s
+
+.text
+.globl _start
+_start:
+    adr x1, x
+    adrp x2, y
+    add x2, x2, :lo12:y
+.data
+    .word z
+
+// CHECK:     Name: .bss
+// CHECK-NEXT:     Type: SHT_NOBITS
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       SHF_ALLOC
+// CHECK-NEXT:       SHF_WRITE
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x120B0
+// CHECK-NEXT:     Offset:
+// CHECK-NEXT:     Size: 24
+// CHECK-NEXT:     Link:
+// CHECK-NEXT:     Info:
+// CHECK-NEXT:     AddressAlignment: 16
+
+// CHECK: Relocations [
+// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset: 0x120B0
+// CHECK-NEXT:       Type: R_AARCH64_COPY
+// CHECK-NEXT:       Symbol: x
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset: 0x120C0
+// CHECK-NEXT:       Type: R_AARCH64_COPY
+// CHECK-NEXT:       Symbol: y
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset: 0x120C4
+// CHECK-NEXT:       Type: R_AARCH64_COPY
+// CHECK-NEXT:       Symbol: z
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+
+// CHECK: Symbols [
+// CHECK:     Name: x
+// CHECK-NEXT:     Value: 0x120B0
+// CHECK-NEXT:     Size: 4
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: Object
+// CHECK-NEXT:     Other:
+// CHECK-NEXT:     Section: .bss
+// CHECK:     Name: y
+// CHECK-NEXT:     Value: 0x120C0
+// CHECK-NEXT:     Size: 4
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: Object
+// CHECK-NEXT:     Other:
+// CHECK-NEXT:     Section: .bss
+// CHECK:     Name: z
+// CHECK-NEXT:     Value: 0x120C4
+// CHECK-NEXT:     Size: 4
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: Object
+// CHECK-NEXT:     Other:
+// CHECK-NEXT:     Section: .bss
+// CHECK: ]
+
+// CODE: Disassembly of section .text:
+// CODE-NEXT: _start:
+// S(x) = 0x120B0, A = 0, P = 0x11000
+// S + A - P = 0x10B0 = 4272
+// CODE-NEXT:  11000: {{.*}} adr  x1, #4272
+// S(y) = 0x120C0, A = 0, P = 0x11004
+// Page(S + A) - Page(P) = 0x12000 - 0x11000 = 0x1000 - 4096
+// CODE-NEXT:  11004: {{.*}} adrp x2, #4096
+// S(y) = 0x120C0, A = 0
+// (S + A) & 0xFFF = 0xC0 = 192
+// CODE-NEXT:  11008: {{.*}} add  x2, x2, #192
+
+// DATA: Contents of section .data:
+// S(z) = 0x120c4
+// DATA-NEXT:  120a0 c4200100