[ELF2] - Implemented R_X86_64_PLT32 rellocation.

[grimar]

Summary

Note: There is sometimes no need to generate rellocation via PLT.
Example - when symbol is not undefined and we are not creating shared library. Then we can create relative relocation instead of referencing and creating PLT records.
That is how ld behaves I believe.

[ruiu]

ELF/Target.cpp

314–316

Your test does not seem to cover this code. (I just run your test without applying this code, and it didn't die with "unrecognized reloc" error defined below, so a relocation with R_x86_64_PLT32 did not reach this function.)

[grimar]

ELF/Target.cpp

314–316

Without applying this code this relocations are handled in another branch and consumed by:

void InputSection<ELFT>::relocate(
....

if (Target->relocNeedsPlt(Type, Body)) {                <--- here
  SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
  Type = Target->getPLTRefReloc(Type);
}

but since my case does not need plt then execution moves forward to relocateOne() and fails there without R_X86_64_PLT32 handler.

[grimar]

ELF/Target.cpp

314–316

Does not need PLT for _start I mean.

[ruiu]

LGTM with a nit.

Please update the test by adding a PLT32 relocation referring a symbol which is resolved within the same file, like this.

.global _start, foo
_start:
  jmp bar@PLT
  jmp bar@PLT
  jmp zed@PLT
  jmp foo@PLT
  jmp _start@plt
foo:

[grimar]

This looks to break self hosting for me. r250578 works fine, but this (r250584) leads to test fails during check-clang.

[• rafael]

The problem seems to be in the linking of lib64/libclang.so.3..

[• rafael]

I think the bug is just that we produce unnecessary relocations:

callq atexit@PLT
atexit:

will create a dynamic relocation.

I will fix it early tomorrow.

[• rafael]

r250682 might have fixed it.

[grimar]

In D13835#269952, @rafael wrote:

r250682 might have fixed it.

Great, it works, thanks a lot ! That gives a chance for lazy relocations patch: http://reviews.llvm.org/D13856

ELF/Target.cpp

case R_X86_64_PC32:
     // dynamic linker resolves the symbol to the value of the symbol we created.
     // This is true even for got entries, so pointer equality is maintained.
     // To avoid an infinite loop, the only entry that points to the
     // real function is a dedicated got entry used by the plt. That is
     // identified by special relocation types (R_X86_64_JUMP_SLOT,
     // R_386_JMP_SLOT, etc).
     return S.isShared();
   case R_X86_64_PLT32:
-    return true;
+    return canBePreempted(&S, true);
   }
 }
 
 bool X86_64TargetInfo::isRelRelative(uint32_t Type) const {
   switch (Type) {
   default:
     return false;
   case R_X86_64_PC64:
void X86_64TargetInfo::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
   case R_X86_64_32S:
     if (Type == R_X86_64_32 && !isUInt<32>(SA))
       error("R_X86_64_32 out of range");
     else if (!isInt<32>(SA))
       error("R_X86_64_32S out of range");
     write32le(Loc, SA);
     break;
   }
+  case R_X86_64_PLT32:
+    write32le(Loc, SA - BaseAddr - Offset);
+    break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi

test/elf2/plt.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld2 -shared %t2.o -o %t2.so
 // RUN: ld.lld2 -shared %t.o %t2.so -o %t
+// RUN: ld.lld2 %t.o %t2.so -o %t3
 // RUN: llvm-readobj -s -r %t | FileCheck %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
+// RUN: llvm-readobj -s -r %t3 | FileCheck --check-prefix=CHECK2 %s
+// RUN: llvm-objdump -d %t3 | FileCheck --check-prefix=DISASM2 %s
+
 // REQUIRES: x86
 
 // CHECK:      Name: .plt
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x1020
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 24
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x20A0 R_X86_64_GLOB_DAT bar 0x0
 // CHECK-NEXT:     0x20A8 R_X86_64_GLOB_DAT zed 0x0
 // CHECK-NEXT:     0x20B0 R_X86_64_GLOB_DAT _start 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
+// CHECK2:      Name: .plt
+// CHECK2-NEXT: Type: SHT_PROGBITS
+// CHECK2-NEXT: Flags [
+// CHECK2-NEXT:   SHF_ALLOC
+// CHECK2-NEXT:   SHF_EXECINSTR
+// CHECK2-NEXT: ]
+// CHECK2-NEXT: Address: 0x11020
+// CHECK2-NEXT: Offset:
+// CHECK2-NEXT: Size: 16
+// CHECK2-NEXT: Link: 0
+// CHECK2-NEXT: Info: 0
+// CHECK2-NEXT: AddressAlignment: 16
+
+// CHECK2:      Relocations [
+// CHECK2-NEXT:   Section ({{.*}}) .rela.dyn {
+// CHECK2-NEXT:     0x120A0 R_X86_64_GLOB_DAT bar 0x0
+// CHECK2-NEXT:     0x120A8 R_X86_64_GLOB_DAT zed 0x0
+// CHECK2-NEXT:   }
+// CHECK2-NEXT: ]
+
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
-// 0x11020 - (0x11000 + 1) - 4 = 27
-// 0x11020 - (0x11005 + 1) - 4 = 22
-// 0x11028 - (0x1100a + 1) - 4 = 25
+// 0x1020 - (0x1000 + 1) - 4 = 27
+// 0x1020 - (0x1005 + 1) - 4 = 22
+// 0x1028 - (0x100a + 1) - 4 = 25
+// 0x1030 - (0x100f + 1) - 4 = 28
 
 // DISASM:      _start:
 // DISASM-NEXT:   1000:  e9 {{.*}}       jmp  27
 // DISASM-NEXT:   1005:  e9 {{.*}}       jmp  22
 // DISASM-NEXT:   100a:  e9 {{.*}}       jmp  25
+// DISASM-NEXT:   100f:  e9 {{.*}}       jmp  28
 
-// 0x120A0 - 0x11026  = 4218
-// 0x120A8 - 0x1102e  = 4218
+// 0x20A0 - 0x1026  = 4218
+// 0x20A8 - 0x102e  = 4218
+// 0x20B0 - 0x1036  = 4218
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:   1020:  ff 25 {{.*}}       jmpq *4218(%rip)
 // DISASM-NEXT:   1026:  90                 nop
 // DISASM-NEXT:   1027:  90                 nop
 // DISASM-NEXT:   1028:  ff 25 {{.*}}       jmpq *4218(%rip)
 // DISASM-NEXT:   102e:  90                 nop
 // DISASM-NEXT:   102f:  90                 nop
+// DISASM-NEXT:   1030:  ff 25 {{.*}}       jmpq *4218(%rip)
+// DISASM-NEXT:   1036:  90                 nop
+// DISASM-NEXT:   1037:  90                 nop
+
+// 0x11020 - (0x11000 + 1) - 4 = 27
+// 0x11020 - (0x11005 + 1) - 4 = 22
+// 0x11028 - (0x1100a + 1) - 4 = 25
+// 0x11000 - (0x1100f + 1) - 4 = -20
+
+// DISASM2:      _start:
+// DISASM2-NEXT:   11000:  e9 {{.*}}     jmp  27
+// DISASM2-NEXT:   11005:  e9 {{.*}}     jmp  22
+// DISASM2-NEXT:   1100a:  e9 {{.*}}     jmp  25
+// DISASM2-NEXT:   1100f:  e9 {{.*}}     jmp  -20
+
+// DISASM2:      Disassembly of section .plt:
+// DISASM2-NEXT: .plt:
+// DISASM2-NEXT:     11020:  ff 25 7a 10 00 00 jmpq *4218(%rip)
+// DISASM2-NEXT:     11026:  90                nop
+// DISASM2-NEXT:     11027:  90                nop
+// DISASM2-NEXT:     11028:  ff 25 7a 10 00 00 jmpq *4218(%rip)
+// DISASM2-NEXT:     1102e:  90                nop
+// DISASM2-NEXT:     1102f:  90                nop
+// DISASM2-NEXT-NOT: 110C0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt