[ELF] Move R_*_IRELATIVE from .rel[a].plt to .rel[a].dyn unless --pack-dyn-relocs=android[+relr]

[MaskRay]

Summary

An R_*_IRELATIVE represents the address of a STT_GNU_IFUNC symbol
(redirected at runtime) which is non-preemptable and is not associated
with a canonical PLT (associated with a symbol with a section index of
SHN_UNDEF but a non-zero st_value).

.rel[a].plt [DT_JMPREL, DT_JMPREL+DT_JMPRELSZ) contains relocations that
can be lazily resolved. R_*_IRELATIVE are always eagerly resolved, so
conceptually they do not belong to .rela.plt. "iplt" is mostly a misnomer.

glibc powerpc and powerpc64 do not resolve R_*_IRELATIVE if they are in .rela.plt.

// a.o - synthesized PLT call stub has an R_*_IRELATIVE
void ifunc(); int main() { ifunc(); }
// b.o
static void real() {}
asm (".type ifunc, %gnu_indirect_function");
void *ifunc() { return ℜ }

The lld-linked executable crashes. ld.bfd places R_*_IRELATIVE in
.rela.dyn and the executable works.

glibc i386, x86_64, and aarch64 have logic
(glibc/sysdeps/*/dl-machine.h:elf_machine_lazy_rel) to eagerly resolve
R_*_IRELATIVE in .rel[a].plt so the lld-linked executable works.

Move R_*_IRELATIVE from .rel[a].plt to .rel[a].dyn to fix the crashes on
glibc powerpc/powerpc64. This also helps simplifying ifunc
implementation in FreeBSD rtld-elf powerpc64.

If --pack-dyn-relocs=android[+relr] is specified, the Android packed
dynamic relocation format is used for .rela.dyn. We cannot name
in.relaIplt ".rela.dyn" because the output section will have mixed
formats. This can be improved in the future.

[MaskRay]

Ready

[pcc]

With this dynamic loaders will now need to be able to understand IRELATIVE relocations in .rela.dyn. Have you checked whether we can reasonably expect this to be universal or does this need to be done on a per-architecture basis?

ELF/Writer.cpp

507

Update comment

1071

Update comment

[MaskRay]

Have you checked whether we can reasonably expect this to be universal or does this need to be done on a per-architecture basis?

On non-Android, it is universal to place R_*_IRELATIVE in .rel[a].dyn :) __glibc_unlikely suggests it is not a good idea to have R_*_IRELATIVE in .rel[a].plt:

sysdeps/aarch64/dl-machine.h
444:  else if (__glibc_unlikely (r_type == AARCH64_R(IRELATIVE)))

sysdeps/x86_64/dl-machine.h
574:  else if (__glibc_unlikely (r_type == R_X86_64_IRELATIVE))

On Android (--pack-dyn-relocs=android[+relr]), because there is already one ".rela.dyn" used for the packed format. We cannot create another ".rela.dyn". So I mentioned in the description this should be improved. Either synthetic section should be renamed to not have an output section with mixed formats.

Once this is accepted, I'll rename in.relaIplt to in.relaIdyn.

[MaskRay]

Update comments

[pcc]

In D65651#1612547, @MaskRay wrote:

Have you checked whether we can reasonably expect this to be universal or does this need to be done on a per-architecture basis?

On non-Android, it is universal to place R_*_IRELATIVE in .rel[a].dyn :)

Are you saying that that's the behaviour of an existing linker? If so, this change is fine with me. Otherwise we need to be careful because if there is a dynamic loader out there that only supports R_*_IRELATIVE in .rel[a].plt and not in .rel[a].dyn on some architecture (basically the inverse of the situation that you discovered), your change would break that dynamic loader on that architecture.

[MaskRay]

In D65651#1612576, @pcc wrote:

In D65651#1612547, @MaskRay wrote:

Have you checked whether we can reasonably expect this to be universal or does this need to be done on a per-architecture basis?

On non-Android, it is universal to place R_*_IRELATIVE in .rel[a].dyn :)

Are you saying that that's the behaviour of an existing linker? If so, this change is fine with me. Otherwise we need to be careful because if there is a dynamic loader out there that only supports R_*_IRELATIVE in .rel[a].plt and not in .rel[a].dyn on some architecture (basically the inverse of the situation that you discovered), your change would break that dynamic loader on that architecture.

• arm (non-Android and Android): no-op
• i386/x86_64/aarch64: .rela.plt -> .rela.dyn (either works). R_*_IRELATIVE in .rel[a].plt is discouraged by __glibc_unlikely... A glibc aarch64 maintainer says on aarch64, R_*_IRELATIVE can appear in both .rela.plt and .rela.dyn, but he wants to *fix the problem* by using .rela.dyn exclusively.
• powerpc: .rela.plt -> .rela.dyn (fixes a crash)
• powerpc64:.rela.plt -> .rela.dyn (fixes a crash)
• mips: binutils/glibc don't support ifunc

Chatted with @luporl. They are still bringing up FreeBSD powerpc64. Moving from .rela.plt to .rela.dyn will save their rtld-elf trouble..

(On glibc powerpc/powerpc64, without the change, we can use -z now or LD_BIND_NOW=1 to fix the crash.)

Does the summary look good?

[MaskRay]

Update summary. This doesn't fix PR42759 (FreeBSD rtld-elf powerpc64). It still helps their implementation, though.

[pcc]

In D65651#1613261, @MaskRay wrote:

In D65651#1612576, @pcc wrote:

In D65651#1612547, @MaskRay wrote:

Have you checked whether we can reasonably expect this to be universal or does this need to be done on a per-architecture basis?

On non-Android, it is universal to place R_*_IRELATIVE in .rel[a].dyn :)

Are you saying that that's the behaviour of an existing linker? If so, this change is fine with me. Otherwise we need to be careful because if there is a dynamic loader out there that only supports R_*_IRELATIVE in .rel[a].plt and not in .rel[a].dyn on some architecture (basically the inverse of the situation that you discovered), your change would break that dynamic loader on that architecture.

• arm (non-Android and Android): no-op
• i386/x86_64/aarch64: .rela.plt -> .rela.dyn (either works). R_*_IRELATIVE in .rel[a].plt is discouraged by __glibc_unlikely... A glibc aarch64 maintainer says on aarch64, R_*_IRELATIVE can appear in both .rela.plt and .rela.dyn, but he wants to *fix the problem* by using .rela.dyn exclusively.
• powerpc: .rela.plt -> .rela.dyn (fixes a crash)
• powerpc64:.rela.plt -> .rela.dyn (fixes a crash)
• mips: binutils/glibc don't support ifunc

Chatted with @luporl. They are still bringing up FreeBSD powerpc64. Moving from .rela.plt to .rela.dyn will save their rtld-elf trouble..

(On glibc powerpc/powerpc64, without the change, we can use -z now or LD_BIND_NOW=1 to fix the crash.)

Does the summary look good?

Okay, thanks for checking. LGTM

ELF/SyntheticSections.cpp

void DynamicSection<ELFT>::addSize(int32_t tag, OutputSection *sec) {
   entries.push_back({tag, [=] { return sec->size; }});
 }
 
 template <class ELFT>
 void DynamicSection<ELFT>::addSym(int32_t tag, Symbol *sym) {
   entries.push_back({tag, [=] { return sym->getVA(); }});
 }
 
+static std::function<uint64_t()> addRelaSz(RelocationBaseSection *relaDyn) {
+  return [=]() {
+    size_t size = relaDyn->getSize();
+    if (in.relaPlt->getParent() == relaDyn->getParent())
+      size += in.relaPlt->getSize();
+    if (in.relaIplt->getParent() == relaDyn->getParent())
+      size += in.relaIplt->getSize();
+    return size;
+  };
+}
+
 // A Linker script may assign the RELA relocation sections to the same
 // output section. When this occurs we cannot just use the OutputSection
 // Size. Moreover the [DT_JMPREL, DT_JMPREL + DT_PLTRELSZ) is permitted to
 // overlap with the [DT_RELA, DT_RELA + DT_RELASZ).
 static uint64_t addPltRelSz() {
   size_t size = in.relaPlt->getSize();
   if (in.relaIplt->getParent() == in.relaPlt->getParent() &&
       in.relaIplt->name == in.relaPlt->name)
template <class ELFT> void DynamicSection<ELFT>::finalizeContents() {
   // debugger this information. Such systems may choose make .dynamic read-only.
   // If the target is such a system (used -z rodynamic) don't write DT_DEBUG.
   if (!config->shared && !config->relocatable && !config->zRodynamic)
     addInt(DT_DEBUG, 0);
 
   if (OutputSection *sec = part.dynStrTab->getParent())
     this->link = sec->sectionIndex;
 
-  if (part.relaDyn->isNeeded()) {
+  if (part.relaDyn->isNeeded() ||
+      (in.relaIplt->isNeeded() &&
+       part.relaDyn->getParent() == in.relaIplt->getParent())) {
     addInSec(part.relaDyn->dynamicTag, part.relaDyn);
-    addSize(part.relaDyn->sizeDynamicTag, part.relaDyn->getParent());
+    entries.push_back({part.relaDyn->sizeDynamicTag, addRelaSz(part.relaDyn)});
 
     bool isRela = config->isRela;
     addInt(isRela ? DT_RELAENT : DT_RELENT,
            isRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel));
 
     // MIPS dynamic loader does not support RELCOUNT tag.
     // The problem is in the tight relation between dynamic
     // relocations and GOT. So do not emit this tag on MIPS.

ELF/Writer.cpp

if (config->emachine == EM_MIPS) {
     if (auto *sec = MipsAbiFlagsSection<ELFT>::create())
       add(sec);
     if (auto *sec = MipsOptionsSection<ELFT>::create())
       add(sec);
     if (auto *sec = MipsReginfoSection<ELFT>::create())
       add(sec);
   }
 
+  StringRef relaDynName = config->isRela ? ".rela.dyn" : ".rel.dyn";
+
   for (Partition &part : partitions) {
     auto add = [&](InputSectionBase *sec) {
       sec->partition = part.getNumber();
       inputSections.push_back(sec);
     };
 
     if (!part.name.empty()) {
       part.elfHeader = make<PartitionElfHeaderSection<ELFT>>();
       part.elfHeader->name = part.name;
       add(part.elfHeader);
 
       part.programHeaders = make<PartitionProgramHeadersSection<ELFT>>();
       add(part.programHeaders);
     }
 
     if (config->buildId != BuildIdKind::None) {
       part.buildId = make<BuildIdSection>();
       add(part.buildId);
     }
 
     part.dynStrTab = make<StringTableSection>(".dynstr", true);
     part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
     part.dynamic = make<DynamicSection<ELFT>>();
-    if (config->androidPackDynRelocs) {
-      part.relaDyn = make<AndroidPackedRelocationSection<ELFT>>(
-          config->isRela ? ".rela.dyn" : ".rel.dyn");
-    } else {
-      part.relaDyn = make<RelocationSection<ELFT>>(
-          config->isRela ? ".rela.dyn" : ".rel.dyn", config->zCombreloc);
-    }
+    if (config->androidPackDynRelocs)
+      part.relaDyn = make<AndroidPackedRelocationSection<ELFT>>(relaDynName);
+    else
+      part.relaDyn =
+          make<RelocationSection<ELFT>>(relaDynName, config->zCombreloc);
 
     if (needsInterpSection())
       add(createInterpSection());
 
     if (config->hasDynSymTab) {
       part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
       add(part.dynSymTab);
 
if (config->gdbIndex)
     add(GdbIndexSection::create<ELFT>());
 
   // We always need to add rel[a].plt to output if it has entries.
   // Even for static linking it can contain R_[*]_IRELATIVE relocations.
   in.relaPlt = make<RelocationSection<ELFT>>(
       config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false);
   add(in.relaPlt);
 
   // The relaIplt immediately follows .rel.plt (.rel.dyn for ARM) to ensure
   // that the IRelative relocations are processed last by the dynamic loader.
   // We cannot place the iplt section in .rel.dyn when Android relocation
   // packing is enabled because that would cause a section type mismatch.
   // However, because the Android dynamic loader reads .rel.plt after .rel.dyn,
   // we can get the desired behaviour by placing the iplt section in .rel.plt.
   in.relaIplt = make<RelocationSection<ELFT>>(
-      (config->emachine == EM_ARM && !config->androidPackDynRelocs)
-          ? ".rel.dyn"
-          : in.relaPlt->name,
+      config->androidPackDynRelocs ? in.relaPlt->name : relaDynName,
       /*sort=*/false);
   add(in.relaIplt);
 
   in.plt = make<PltSection>(false);
   add(in.plt);
   in.iplt = make<PltSection>(true);
   add(in.iplt);
 
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;
   }
 
   // .rela_iplt_{start,end} mark the start and the end of .rela.plt section.
   if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) {
     ElfSym::relaIpltStart->section = in.relaIplt;
     ElfSym::relaIpltEnd->section = in.relaIplt;
     ElfSym::relaIpltEnd->value = in.relaIplt->getSize();
   }
 
   PhdrEntry *last = nullptr;
   PhdrEntry *lastRO = nullptr;

test/ELF/aarch64-gnu-ifunc-nonpreemptable.s

 ## page(.got.plt) - page(0x210010) = 65536
 # PDE-NEXT:   210010: adrp    x16, #65536
 # PDE-NEXT:   210014: ldr     x17, [x16]
 # PDE-NEXT:   210018: add     x16, x16, #0
 # PDE-NEXT:   21001c: br      x17
 
 ## The adrp to myfunc should generate a PLT entry and a GOT entry with an
 ## irelative relocation.
-# PDE-RELOC:      .rela.plt {
+# PDE-RELOC:      .rela.dyn {
 # PDE-RELOC-NEXT:   0x220000 R_AARCH64_IRELATIVE - 0x210000
 # PDE-RELOC-NEXT: }
 
 # PIE:      myfunc_resolver:
 # PIE-NEXT:    10000: ret
 # PIE:      main:
 # PIE-NEXT:    10004: adrp    x8, #0
 # PIE-NEXT:    10008: add     x8, x8, #16
 # PIE-NEXT:    1000c: ret
 # PIE-EMPTY:
 # PIE-NEXT: Disassembly of section .plt:
 # PIE-EMPTY:
 # PIE-NEXT: myfunc:
 # PIE-NEXT:    10010: adrp    x16, #131072
 # PIE-NEXT:    10014: ldr     x17, [x16]
 # PIE-NEXT:    10018: add     x16, x16, #0
 # PIE-NEXT:    1001c: br      x17
 
-# PIE-RELOC:      .rela.plt {
+# PIE-RELOC:      .rela.dyn {
 # PIE-RELOC-NEXT:   0x30000 R_AARCH64_IRELATIVE - 0x10000
 # PIE-RELOC-NEXT: }

test/ELF/aarch64-gnu-ifunc-plt.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %S/Inputs/shared2.s -o %t1.o
 // RUN: ld.lld %t1.o --shared --soname=t.so -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -d --no-show-raw-insn %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r --dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
-// CHECK-NEXT:   Section (4) .rela.plt {
-// CHECK:     0x230018 R_AARCH64_JUMP_SLOT bar2 0x0
-// CHECK-NEXT:     0x230020 R_AARCH64_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:   Section (4) .rela.dyn {
 // CHECK-NEXT:     0x230028 R_AARCH64_IRELATIVE - 0x210000
 // CHECK-NEXT:     0x230030 R_AARCH64_IRELATIVE - 0x210004
 // CHECK-NEXT:   }
+// CHECK-NEXT:   Section (5) .rela.plt {
+// CHECK-NEXT:     0x230018 R_AARCH64_JUMP_SLOT bar2 0x0
+// CHECK-NEXT:     0x230020 R_AARCH64_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Check that .got.plt entries point back to PLT header
 // GOTPLT: Contents of section .got.plt:
 // GOTPLT-NEXT:  230000 00000000 00000000 00000000 00000000
 // GOTPLT-NEXT:  230010 00000000 00000000 20002100 00000000
 // GOTPLT-NEXT:  230020 20002100 00000000 20002100 00000000
 // GOTPLT-NEXT:  230030 20002100 00000000
 
-// Check that the PLTRELSZ tag includes the IRELATIVE relocations
+// Check that the PLTRELSZ tag does not include the IRELATIVE relocations
 // CHECK: DynamicSection [
-// CHECK:   0x0000000000000002 PLTRELSZ             96 (bytes)
+// CHECK:   0x0000000000000008 RELASZ               48 (bytes)
+// CHECK:   0x0000000000000002 PLTRELSZ             48 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    210000: ret
 // DISASM:      bar:
 // DISASM-NEXT:    210004: ret

test/ELF/aarch64-gnu-ifunc.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 // RUN: ld.lld -static %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r --symbols --sections %tout | FileCheck %s
 
 // CHECK:      Sections [
 // CHECK:       Section {
 // CHECK:       Index: 1
-// CHECK-NEXT:  Name: .rela.plt
+// CHECK-NEXT:  Name: .rela.dyn
 // CHECK-NEXT:  Type: SHT_RELA
 // CHECK-NEXT:  Flags [
 // CHECK-NEXT:    SHF_ALLOC
 // CHECK-NEXT:  ]
 // CHECK-NEXT:  Address: [[RELA:.*]]
 // CHECK-NEXT:  Offset: 0x158
 // CHECK-NEXT:  Size: 48
 // CHECK-NEXT:  Link: 0
 // CHECK-NEXT:  Info: 4
 // CHECK-NEXT:  AddressAlignment: 8
 // CHECK-NEXT:  EntrySize: 24
 // CHECK-NEXT: }
 // CHECK:      Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x220000 R_AARCH64_IRELATIVE
 // CHECK-NEXT:     0x220008 R_AARCH64_IRELATIVE
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 // CHECK:      Symbols [
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name:
 // CHECK-NEXT:    Value: 0x0

 // CHECK-NEXT:    Name: __rela_iplt_end
 // CHECK-NEXT:    Value: 0x200188
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Section: .rela.plt
+// CHECK-NEXT:    Section: .rela.dyn
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: __rela_iplt_start
 // CHECK-NEXT:    Value: 0x200158
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Section: .rela.plt
+// CHECK-NEXT:    Section: .rela.dyn
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: _start
 // CHECK-NEXT:    Value: 0x210008
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other: 0

test/ELF/aarch64-gnu-ifunc2.s

 # CHECK-NEXT:   210010: adrp    x16, #65536
 # CHECK-NEXT:   210014: ldr     x17, [x16]
 # CHECK-NEXT:   210018: add     x16, x16, #0
 # CHECK-NEXT:   21001c: br      x17
 
 # SEC: .got.plt PROGBITS 0000000000220000 020000 000008 00 WA 0 0 8
 
 # RELOC:      Relocations [
-# RELOC-NEXT:   Section {{.*}} .rela.plt {
+# RELOC-NEXT:   Section {{.*}} .rela.dyn {
 # RELOC-NEXT:     0x220000 R_AARCH64_IRELATIVE - 0x210000
 # RELOC-NEXT:   }
 # RELOC-NEXT: ]
 
 .text
 .globl myfunc
 .type myfunc,@gnu_indirect_function
 myfunc:

test/ELF/gnu-ifunc-canon.s

 // RUN: llvm-readobj -r %t10 | FileCheck --check-prefix=IREL1-REL3 %s
 // RUN: ld.lld %t-ro-pcrel.o %t.o -o %t11 -pie
 // RUN: llvm-readobj -r %t11 | FileCheck --check-prefix=IREL1-REL2 %s
 // RUN: ld.lld %t-rw-addend.o %t.o -o %t12 -pie
 // RUN: llvm-readobj -r %t12 | FileCheck --check-prefix=IREL1-REL3 %s
 
 // Two relocs, one for the GOT and the other for .data.
 // IREL2-NOT: R_X86_64_
-// IREL2: .rela.plt
+// IREL2: .rela.dyn
 // IREL2-NEXT: R_X86_64_IRELATIVE
 // IREL2-NEXT: R_X86_64_IRELATIVE
 // IREL2-NOT: R_X86_64_
 
 // One reloc for the canonical PLT.
 // IREL1-NOT: R_X86_64_
-// IREL1: .rela.plt
+// IREL1: .rela.dyn
 // IREL1-NEXT: R_X86_64_IRELATIVE
 // IREL1-NOT: R_X86_64_
 
 // One reloc for the canonical PLT and two RELATIVE relocations pointing to it,
 // one in the GOT and one in .data.
 // IREL1-REL2-NOT: R_X86_64_
 // IREL1-REL2: .rela.dyn
 // IREL1-REL2-NEXT: R_X86_64_RELATIVE
 // IREL1-REL2-NEXT: R_X86_64_RELATIVE
-// IREL1-REL2: .rela.plt
 // IREL1-REL2-NEXT: R_X86_64_IRELATIVE
 // IREL1-REL2-NOT: R_X86_64_
 
 // One reloc for the canonical PLT and three RELATIVE relocations pointing to it,
 // one in the GOT and two in .data.
 // IREL1-REL3-NOT: R_X86_64_
 // IREL1-REL3: .rela.dyn
 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
-// IREL1-REL3: .rela.plt
 // IREL1-REL3-NEXT: R_X86_64_IRELATIVE
 // IREL1-REL3-NOT: R_X86_64_
 
 // Make sure the static relocations look right, both with and without headers.
 // DUMP: Contents of section .plt:
 // DUMP-NEXT: 201010
 // DUMP: Contents of section .got:
 // DUMP-NEXT: 202000 10102000 00000000

test/ELF/gnu-ifunc-dyntags.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -pie %t.o -o %tout
 # RUN: llvm-objdump -section-headers %tout | FileCheck %s
 # RUN: llvm-readobj --dynamic-table -r %tout | FileCheck %s --check-prefix=TAGS
 
 ## Check we produce DT_PLTREL/DT_JMPREL/DT_PLTGOT and DT_PLTRELSZ tags
 ## when there are no other relocations except R_*_IRELATIVE.
 
 # CHECK:  Name          Size   VMA
-# CHECK:  .rela.plt   00000030 0000000000000248
+# CHECK:  .rela.dyn   00000030 0000000000000248
 # CHECK:  .got.plt    00000010 0000000000003000
 
 # TAGS:      Relocations [
-# TAGS-NEXT:   Section {{.*}} .rela.plt {
+# TAGS-NEXT:   Section {{.*}} .rela.dyn {
 # TAGS-NEXT:     R_X86_64_IRELATIVE
 # TAGS-NEXT:     R_X86_64_IRELATIVE
 # TAGS-NEXT:   }
 # TAGS-NEXT: ]
 
 # TAGS:   Tag                Type                 Name/Value
-# TAGS:   0x0000000000000017 JMPREL               0x248
-# TAGS:   0x0000000000000002 PLTRELSZ             48
+# TAGS:   0x0000000000000007 RELA                 0x248
+# TAGS:   0x0000000000000008 RELASZ               48 (bytes)
+# TAGS:   0x0000000000000017 JMPREL               0x0
+# TAGS:   0x0000000000000002 PLTRELSZ             0 (bytes)
 # TAGS:   0x0000000000000003 PLTGOT               0x3000
 # TAGS:   0x0000000000000014 PLTREL               RELA
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret

test/ELF/gnu-ifunc-i386.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld -static %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r --symbols --sections %tout | FileCheck %s
 
 // CHECK:      Sections [
 // CHECK:       Section {
 // CHECK:       Index: 1
-// CHECK-NEXT:  Name: .rel.plt
+// CHECK-NEXT:  Name: .rel.dyn
 // CHECK-NEXT:  Type: SHT_REL
 // CHECK-NEXT:  Flags [
 // CHECK-NEXT:    SHF_ALLOC
 // CHECK-NEXT:  ]
 // CHECK-NEXT:  Address: [[RELA:.*]]
 // CHECK-NEXT:  Offset: 0xD4
 // CHECK-NEXT:  Size: 16
 // CHECK-NEXT:  Link: 0
 // CHECK-NEXT:  Info: 4
 // CHECK-NEXT:  AddressAlignment: 4
 // CHECK-NEXT:  EntrySize: 8
 // CHECK-NEXT: }
 // CHECK:     Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rel.plt {
+// CHECK-NEXT:   Section ({{.*}}) .rel.dyn {
 // CHECK-NEXT:     0x402000 R_386_IRELATIVE
 // CHECK-NEXT:     0x402004 R_386_IRELATIVE
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name:
 // CHECK-NEXT:   Value: 0x0
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other: 0
 // CHECK-NEXT:   Section: Undefined
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __rel_iplt_end
 // CHECK-NEXT:   Value: 0x4000E4
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
-// CHECK-NEXT:   Section: .rel.plt
+// CHECK-NEXT:   Section: .rel.dyn
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __rel_iplt_start
 // CHECK-NEXT:   Value: [[RELA]]
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
-// CHECK-NEXT:   Section: .rel.plt
+// CHECK-NEXT:   Section: .rel.dyn
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: _start
 // CHECK-NEXT:   Value: 0x401002
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Global
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other: 0

test/ELF/gnu-ifunc-plt-i386.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %S/Inputs/shared2-x86-64.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r --dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
-// CHECK-NEXT:   Section (4) .rel.plt {
-// CHECK-NEXT:     0x40300C R_386_JUMP_SLOT bar2
-// CHECK-NEXT:     0x403010 R_386_JUMP_SLOT zed2
+// CHECK-NEXT:   Section (4) .rel.dyn {
 // CHECK-NEXT:     0x403014 R_386_IRELATIVE
 // CHECK-NEXT:     0x403018 R_386_IRELATIVE
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section (5) .rel.plt {
+// CHECK-NEXT:     0x40300C R_386_JUMP_SLOT bar2
+// CHECK-NEXT:     0x403010 R_386_JUMP_SLOT zed2
+// CHECK-NEXT:   }
 
 // Check that IRELATIVE .got.plt entries point to ifunc resolver and not
 // back to the plt entry + 6.
 // GOTPLT: Contents of section .got.plt:
 // GOTPLT:       403000 00204000 00000000 00000000 36104000
 // GOTPLT-NEXT:  403010 46104000 00104000 01104000
 
-// Check that the PLTRELSZ tag includes the IRELATIVE relocations
+// Check that the PLTRELSZ tag does not include the IRELATIVE relocations
 // CHECK: DynamicSection [
-// CHECK:  0x00000002 PLTRELSZ             32 (bytes)
+// CHECK:  0x00000012 RELSZ                16 (bytes)
+// CHECK:  0x00000002 PLTRELSZ             16 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    401000:       c3      retl
 // DISASM:      bar:
 // DISASM-NEXT:    401001:       c3      retl

test/ELF/gnu-ifunc-plt.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/shared2-x86-64.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r --dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
-// CHECK-NEXT:   Section (4) .rela.plt {
-// CHECK-NEXT:     0x203018 R_X86_64_JUMP_SLOT bar2 0x0
-// CHECK-NEXT:     0x203020 R_X86_64_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:   Section (4) .rela.dyn {
 // CHECK-NEXT:     0x203028 R_X86_64_IRELATIVE - 0x201000
 // CHECK-NEXT:     0x203030 R_X86_64_IRELATIVE - 0x201001
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section (5) .rela.plt {
+// CHECK-NEXT:     0x203018 R_X86_64_JUMP_SLOT bar2 0x0
+// CHECK-NEXT:     0x203020 R_X86_64_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:   }
 
 // Check that .got.plt entries point back to PLT header
 // GOTPLT: Contents of section .got.plt:
 // GOTPLT-NEXT:  203000 00202000 00000000 00000000 00000000
 // GOTPLT-NEXT:  203010 00000000 00000000 36102000 00000000
 // GOTPLT-NEXT:  203020 46102000 00000000 56102000 00000000
 // GOTPLT-NEXT:  203030 66102000 00000000
 
-// Check that the PLTRELSZ tag includes the IRELATIVE relocations
+// Check that the PLTRELSZ tag does not include the IRELATIVE relocations
 // CHECK: DynamicSection [
-// CHECK:   0x0000000000000002 PLTRELSZ             96 (bytes)
+// CHECK:   0x0000000000000008 RELASZ               48 (bytes)
+// CHECK:   0x0000000000000002 PLTRELSZ             48 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:   201000:       c3      retq
 // DISASM:      bar:
 // DISASM-NEXT:   201001:       c3      retq

test/ELF/gnu-ifunc-relative.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld --strip-all %t.o -o %t
 // RUN: llvm-readobj -r %t | FileCheck %s
 // RUN: ld.lld %t.o -o %t
 // RUN: llvm-readobj -r --symbols %t | FileCheck %s --check-prefixes=CHECK,SYM
 
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .globl _start
 _start:
  call foo
 
-// CHECK:      Section ({{.*}}) .rela.plt {
+// CHECK:      Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:   R_X86_64_IRELATIVE - 0x[[ADDR:.*]]
 // CHECK-NEXT: }
 
 // SYM:      Name: foo
 // SYM-NEXT: Value: 0x[[ADDR]]
 // SYM-NEXT: Size: 0
 // SYM-NEXT: Binding: Global
 // SYM-NEXT: Type: GNU_IFunc

test/ELF/gnu-ifunc-shared.s

 // DISASM-NEXT:     1040:       ff 25 da 1f 00 00       jmpq    *8154(%rip)
 // DISASM-NEXT:     1046:       68 01 00 00 00          pushq   $1
 // DISASM-NEXT:     104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
 // DISASM-NEXT:     1050:       ff 25 d2 1f 00 00       jmpq    *8146(%rip)
 // DISASM-NEXT:     1056:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:     105b:       e9 e0 ff ff ff          jmp     -32 <f2@plt>
 
 // CHECK: Relocations [
-// CHECK-NEXT:   Section (4) .rela.plt {
+// CHECK-NEXT:   Section (4) .rela.dyn {
+// CHECK-NEXT:     0x3028 R_X86_64_IRELATIVE - 0x1000
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Section (5) .rela.plt {
 // CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT fct2 0x0
 // CHECK-NEXT:     0x3020 R_X86_64_JUMP_SLOT f2 0x0
-// CHECK-NEXT:     0x3028 R_X86_64_IRELATIVE - 0x1000
+// CHECK-NEXT:   }
 
  // Hidden expect IRELATIVE
  .globl fct
  .hidden fct
  .type  fct, STT_GNU_IFUNC
 fct:
  ret
 

test/ELF/gnu-ifunc.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld -static %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r --symbols --sections %tout | FileCheck %s
 
 // CHECK:      Sections [
 // CHECK:       Section {
 // CHECK:       Index: 1
-// CHECK-NEXT:  Name: .rela.plt
+// CHECK-NEXT:  Name: .rela.dyn
 // CHECK-NEXT:  Type: SHT_RELA
 // CHECK-NEXT:  Flags [
 // CHECK-NEXT:    SHF_ALLOC
 // CHECK-NEXT:  ]
 // CHECK-NEXT:  Address: [[RELA:.*]]
 // CHECK-NEXT:  Offset: 0x158
 // CHECK-NEXT:  Size: 48
 // CHECK-NEXT:  Link: 0
 // CHECK-NEXT:  Info: [[GOTPLT:.*]]
 // CHECK-NEXT:  AddressAlignment: 8
 // CHECK-NEXT:  EntrySize: 24
 // CHECK-NEXT: }
 // CHECK:      Index: [[GOTPLT]]
 // CHECK-NEXT: Name: .got.plt
 // CHECK:      Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x202000 R_X86_64_IRELATIVE
 // CHECK-NEXT:     0x202008 R_X86_64_IRELATIVE
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 // CHECK:      Symbols [
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name:
 // CHECK-NEXT:    Value: 0x0
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: Undefined
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: __rela_iplt_end
 // CHECK-NEXT:    Value: 0x200188
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Section: .rela.plt
+// CHECK-NEXT:    Section: .rela.dyn
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: __rela_iplt_start
 // CHECK-NEXT:    Value: [[RELA]]
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Section: .rela.plt
+// CHECK-NEXT:    Section: .rela.dyn
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: _start
 // CHECK-NEXT:    Value: 0x201002
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other: 0

test/ELF/linkerscript/orphan-report.s

 # REPORT-NEXT: <internal>:(.dynamic) is being placed in '.dynamic'
 # REPORT-NEXT: <internal>:(.dynstr) is being placed in '.dynstr'
 # REPORT-NEXT: <internal>:(.rela.dyn) is being placed in '.rela.dyn'
 # REPORT-NEXT: <internal>:(.eh_frame) is being placed in '.eh_frame'
 # REPORT-NEXT: <internal>:(.got) is being placed in '.got'
 # REPORT-NEXT: <internal>:(.got.plt) is being placed in '.got.plt'
 # REPORT-NEXT: <internal>:(.got.plt) is being placed in '.got.plt'
 # REPORT-NEXT: <internal>:(.rela.plt) is being placed in '.rela.plt'
-# REPORT-NEXT: <internal>:(.rela.plt) is being placed in '.rela.plt'
+# REPORT-NEXT: <internal>:(.rela.dyn) is being placed in '.rela.dyn'
 # REPORT-NEXT: <internal>:(.plt) is being placed in '.plt'
 # REPORT-NEXT: <internal>:(.plt) is being placed in '.plt'
 # REPORT-NEXT: <internal>:(.symtab) is being placed in '.symtab'
 # REPORT-NEXT: <internal>:(.symtab_shndx) is being placed in '.symtab_shndx'
 # REPORT-NEXT: <internal>:(.shstrtab) is being placed in '.shstrtab'
 # REPORT-NEXT: <internal>:(.strtab) is being placed in '.strtab'
 
 ## Check --orphan-handling=warn reports warnings about orphans.

test/ELF/ppc32-gnu-ifunc-nonpreemptable.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=RELOC %s
 # RUN: llvm-readelf -s %t | FileCheck --check-prefix=SYM %s
 # RUN: llvm-readelf -x .got2 %t | FileCheck --check-prefix=HEX %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
-# RELOC:      .rela.plt {
+# RELOC:      .rela.dyn {
 # RELOC-NEXT:   0x10020004 R_PPC_IRELATIVE - 0x10010000
 # RELOC-NEXT: }
 
 # SYM: 10010020 0 FUNC GLOBAL DEFAULT {{.*}} func
 # HEX: 0x10020000 10010020
 
 .section .got2,"aw"
 .long func

test/ELF/ppc32-gnu-ifunc.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-readobj -r %t | FileCheck --check-prefix=RELOC %s
 # RUN: llvm-readelf -S -s %t | FileCheck --check-prefixes=SEC,SYM %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
 
-# RELOC:      .rela.plt {
+# RELOC:      .rela.dyn {
 # RELOC-NEXT:   0x10020000 R_PPC_IRELATIVE - 0x10010000
 # RELOC-NEXT: }
 
-# SEC: .rela.plt RELA 100000d4 0000d4 00000c
+# SEC: .rela.dyn RELA 100000d4 0000d4 00000c
 # SYM: 10010000 0 FUNC GLOBAL DEFAULT {{.*}} func
 
 # CHECK:      func_resolver:
 # CHECK-NEXT:   10010000:
 # CHECK:      _start:
 # CHECK-NEXT:   bl .+20
 ## .rela.plt = 0x100000d4 = 65536*4096+212
 ## end(.rela.plt) = 0x100000d4+0xc = 65536*4096+224