[ELF] Write IPLT header in -static -z retpolineplt mode

[MaskRay]

Summary

This fixes PR39711: -static -z retpolineplt does not produce retpoline header as IPLT header.
-z now is not relevant.

Statically linked executable does not have PLT, but may have IPLT with no header. When -z retpolineplt is specified, however, the repoline header should still be emitted.

I've checked that this fixes (the program prints "Hi" rather than SIGSEGV) the FreeBSD reproduce in PR39711 and a Linux program linked against glibc.

getPltEntryOffset may look dirty after this patch, but it can be cleaned up later.

[MaskRay]

Add test

[MaskRay]

.

[MaskRay]

.

[emaste]

Confirmed this fixes my bug.

ELF/SyntheticSections.cpp

2283–2284

At first this seemed slightly confusing to me vs. the test at line 2294; maybe the test could be the same?
!IsIplt || Config->ZRetpolineplt ? Target->PltHeaderSize : 0

2292

Perhaps update the comment too? e.g. beginning of PLT but not non-retpoline IPLT, although we're basically just repeating the code. Not sure of a succinct way to express this.

[MaskRay]

Address comment and use

if (HeaderSize > 0)
  Target->writePltHeader(Buf);

[MaskRay]

Comment

[MaskRay]

Sorry I didn't know how to use arc diff --verbatim ...

[ruiu]

lld/trunk/ELF/Symbols.cpp

148–149 ↗

(On Diff #174949)

This is nontrivial code, which needs a comment.

ELF/Symbols.cpp

 }
 
 uint64_t Symbol::getPPC64LongBranchOffset() const {
   assert(PPC64BranchltIndex != 0xffff);
   return PPC64BranchltIndex * Target->GotPltEntrySize;
 }
 
 uint64_t Symbol::getPltVA() const {
-  if (this->IsInIplt)
+  if (this->IsInIplt) {
+    if (Config->ZRetpolineplt)
+      return In.Iplt->getVA() + Target->getPltEntryOffset(PltIndex);
     return In.Iplt->getVA() + PltIndex * Target->PltEntrySize;
+  }
   return In.Plt->getVA() + Target->getPltEntryOffset(PltIndex);
 }
 
 uint64_t Symbol::getPltOffset() const {
   assert(!this->IsInIplt);
   return Target->getPltEntryOffset(PltIndex);
 }
 

ELF/SyntheticSections.cpp

void HashTableSection::writeTo(uint8_t *Buf) {
   }
 }
 
 // On PowerPC64 the lazy symbol resolvers go into the `global linkage table`
 // in the .glink section, rather then the typical .plt section.
 PltSection::PltSection(bool IsIplt)
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16,
                        Config->EMachine == EM_PPC64 ? ".glink" : ".plt"),
-      HeaderSize(IsIplt ? 0 : Target->PltHeaderSize), IsIplt(IsIplt) {
+      HeaderSize(!IsIplt || Config->ZRetpolineplt ? Target->PltHeaderSize : 0),
+      IsIplt(IsIplt) {
   // The PLT needs to be writable on SPARC as the dynamic linker will
   // modify the instructions in the PLT entries.
   if (Config->EMachine == EM_SPARCV9)
     this->Flags |= SHF_WRITE;
 }
 
 void PltSection::writeTo(uint8_t *Buf) {
   // At beginning of PLT but not the IPLT, we have code to call the dynamic
   // linker to resolve dynsyms at runtime. Write such code.
-  if (!IsIplt)
+  if (HeaderSize > 0)
     Target->writePltHeader(Buf);
   size_t Off = HeaderSize;
   // The IPlt is immediately after the Plt, account for this in RelOff
   unsigned PltOff = getPltRelocOff();
 
   for (auto &I : Entries) {
     const Symbol *B = I.first;
     unsigned RelOff = I.second + PltOff;

test/ELF/x86-64-retpoline-znow-static-iplt.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld -z retpolineplt -z now %t.o -o %t
+# RUN: llvm-objdump -d -no-show-raw-insn %t | FileCheck %s
+
+#0x201001+5 + 42 = 0x201030 (foo@plt)
+# CHECK:      _start:
+# CHECK-NEXT:  201001:       callq   42
+
+#Static IPLT header due to -z retpolineplt
+# CHECK:      {{^}}.plt:
+# CHECK-NEXT:  201010:       callq   11 <.plt+0x10>
+# CHECK-NEXT:  201015:       pause
+# CHECK-NEXT:  201017:       lfence
+#foo@plt
+# CHECK:       201030:       movq    4041(%rip), %r11
+# CHECK-NEXT:  201037:       jmp     -44 <.plt>
+
+.type foo STT_GNU_IFUNC
+.globl foo
+foo:
+  ret
+
+.globl _start
+_start:
+  call foo