Do not emit a corrupt symbol table entry for .rela_iplt_{start,end}.

[ruiu]

Summary

If .rela.iplt does not exist, we used to emit a corrupt symbol table
that contains two symbols, .rela_iplt_{start,end}, pointing to a
nonexisting section.

This patch fixes the issue by setting section index 0 to the symbols
if .rel.iplt section does not exist.

[grimar]

lld/ELF/Writer.cpp

961

Will it be better to do in the same way we do for ElfSym::GlobalOffsetTable (lines 943-950 right above).
ElfSym::GlobalOffsetTable is created with Out::ElfHeader initially and then the appropriate section is set,
it seems to be a bit more convenient/simple way. So the code would be something like:

  ElfSym::RelaIpltStart =
      addOptionalRegular(S, **Out::ElfHeader**, 0, STV_HIDDEN, STB_WEAK);
...
  ElfSym::RelaIpltEnd =
      addOptionalRegular(S, **Out::ElfHeader**, 0, STV_HIDDEN, STB_WEAK);

if (ElfSym::RelaIpltStart && !In.RelaIplt->empty()) {
  ElfSym::RelaIpltStart->Section = In.RelaIplt;
  ElfSym::RelaIpltEnd->Section = In.RelaIplt;
  ElfSym::RelaIpltEnd->Value = In.RelaIplt->getSize();
}

[ruiu]

• apply code review suggestion

[ruiu]

lld/ELF/Writer.cpp

961

Thanks. I applied that suggested change.

[grimar]

LGTM.

lld/ELF/Symbols.h

struct ElfSym {
   // the end of the .got.
   static Defined *GlobalOffsetTable;
 
   // _gp, _gp_disp and __gnu_local_gp symbols. Only for MIPS.
   static Defined *MipsGp;
   static Defined *MipsGpDisp;
   static Defined *MipsLocalGp;
 
-  // __rela_iplt_end or __rel_iplt_end
+  // __rel{,a}_iplt_{start,end} symbols.
+  static Defined *RelaIpltStart;
   static Defined *RelaIpltEnd;
 };
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(Defined) char A[sizeof(Defined)];

lld/ELF/Symbols.cpp

 Defined *ElfSym::Edata1;
 Defined *ElfSym::Edata2;
 Defined *ElfSym::End1;
 Defined *ElfSym::End2;
 Defined *ElfSym::GlobalOffsetTable;
 Defined *ElfSym::MipsGp;
 Defined *ElfSym::MipsGpDisp;
 Defined *ElfSym::MipsLocalGp;
+Defined *ElfSym::RelaIpltStart;
 Defined *ElfSym::RelaIpltEnd;
 
 static uint64_t getSymVA(const Symbol &Sym, int64_t &Addend) {
   switch (Sym.kind()) {
   case Symbol::DefinedKind: {
     auto &D = cast<Defined>(Sym);
     SectionBase *IS = D.Section;
 

lld/ELF/Writer.cpp

 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.
 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
   if (Config->Relocatable || needsInterpSection())
     return;
   StringRef S = Config->IsRela ? "__rela_iplt_start" : "__rel_iplt_start";
+  ElfSym::RelaIpltStart =
       addOptionalRegular(S, In.RelaIplt, 0, STV_HIDDEN, STB_WEAK);
 
   S = Config->IsRela ? "__rela_iplt_end" : "__rel_iplt_end";
   ElfSym::RelaIpltEnd =
       addOptionalRegular(S, In.RelaIplt, 0, STV_HIDDEN, STB_WEAK);
 }
 
 template <class ELFT>
 void Writer<ELFT>::forEachRelSec(
if (ElfSym::GlobalOffsetTable) {
     // to the start of the .got or .got.plt section.
     InputSection *GotSection = In.GotPlt;
     if (!Target->GotBaseSymInGotPlt)
       GotSection = In.MipsGot ? cast<InputSection>(In.MipsGot)
                               : cast<InputSection>(In.Got);
     ElfSym::GlobalOffsetTable->Section = GotSection;
   }
 
-  if (ElfSym::RelaIpltEnd)
-    ElfSym::RelaIpltEnd->Value = In.RelaIplt->getSize();
+  // .rela_iplt_{start,end} mark the start and the end of .rela.plt section.
+  if (ElfSym::RelaIpltStart) {
+    uint64_t Size = In.RelaIplt->getSize();
+    ElfSym::RelaIpltEnd->Value = Size;
+
+    // If .rela.plt does not exist, use a dummy section value. The loader
+    // reads data between the start and the end symbols, so as long as the two
+    // symbols point to the same location, their actual locations don't matter.
+    if (Size == 0) {
+      ElfSym::RelaIpltStart->Section = Out::ElfHeader;
+      ElfSym::RelaIpltEnd->Section = Out::ElfHeader;
+    }
+  }
 
   PhdrEntry *Last = nullptr;
   PhdrEntry *LastRO = nullptr;
 
   for (PhdrEntry *P : Phdrs) {
     if (P->p_type != PT_LOAD)
       continue;
     Last = P;

lld/test/ELF/gnu-ifunc-empty.s

+// REQUIRES: x86
+
+// Verifies that .rela_iplt_{start,end} point to a dummy section
+// if .rela.iplt does not exist.
+
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld -static %t.o -o %t.exe
+// RUN: llvm-objdump -syms %t.exe | FileCheck %s
+
+// CHECK: 0000000000200000 .text 00000000 .hidden __rela_iplt_end
+// CHECK: 0000000000200000 .text 00000000 .hidden __rela_iplt_start
+
+.globl _start
+_start:
+ movl $__rela_iplt_start, %edx
+ movl $__rela_iplt_end, %edx