[LLD][ELF] - Do not produce an invalid dynamic relocation order with --shuffle-sections.

[grimar]

Summary

Normally (when not on android with android relocation packing enabled),
we put IRelative relocations to ".rel[a].dyn", after other relocations,
to ensure that IRelatives are processed last by the dynamic loader.

To achieve that we add the in.relaIplt after the part.relaDyn:
https://github.com/llvm/llvm-project/blob/master/lld/ELF/Writer.cpp#L540

The problem is that --shuffle-sections might break the sections order.
This patch fixes it.

Fixes https://bugs.llvm.org/show_bug.cgi?id=47056.

[psmith]

Looks good to me. Will be worth seeing if MaskRay has any comments.

lld/ELF/Writer.cpp

1443

typo: "to an output section" should be "in an output section"

[grimar]

• Addressed Peter's comment (fixed typo).
• Rebased after landing parent revision.

lld/ELF/Writer.cpp

1443

Thanks!

[MaskRay]

Looks great!

lld/ELF/Writer.cpp

 static void sortSection(OutputSection *sec,
                         const DenseMap<const InputSectionBase *, int> &order) {
   StringRef name = sec->name;
 
   // Never sort these.
   if (name == ".init" || name == ".fini")
     return;
 
+  // IRelative relocations that usually live in the .rel[a].dyn section should
+  // be proccessed last by the dynamic loader. To achieve that we add synthetic
+  // sections in the required order from the begining so that the in.relaIplt
+  // section is placed last in an output section. Here we just do not apply
+  // sorting for an output section which holds the in.relaIplt section.
+  if (in.relaIplt->getParent() == sec)
+    return;
+
   // Sort input sections by priority using the list provided by
   // --symbol-ordering-file or --shuffle-sections=. This is a least significant
   // digit radix sort. The sections may be sorted stably again by a more
   // significant key.
   if (!order.empty())
     for (BaseCommand *b : sec->sectionCommands)
       if (auto *isd = dyn_cast<InputSectionDescription>(b))
         sortISDBySectionOrder(isd, order);

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

 // DISASM-NEXT: <.iplt>:
 // DISASM-NEXT:   201370:       jmpq    *0x213a(%rip)
 // DISASM-NEXT:   201376:       pushq   $0x0
 // DISASM-NEXT:   20137b:       jmp     0x201340 <.plt>
 // DISASM-NEXT:   201380:       jmpq    *0x2132(%rip)
 // DISASM-NEXT:   201386:       pushq   $0x1
 // DISASM-NEXT:   20138b:       jmp     0x201340 <.plt>
 
+// Test that --shuffle-sections does not affect the order of relocations and that
+// we still place IRELATIVE relocations last. Check both random seed (0) and an
+// arbitrary seed that was known to break the order of relocations previously (3).
+// RUN: ld.lld --shuffle-sections=3 %t.so %t.o -o %tout2
+// RUN: llvm-readobj --relocations %tout2 | FileCheck %s --check-prefix=SHUFFLE
+// RUN: ld.lld --shuffle-sections=0 %t.so %t.o -o %tout3
+// RUN: llvm-readobj --relocations %tout3 | FileCheck %s --check-prefix=SHUFFLE
+
+// SHUFFLE:      Section {{.*}} .rela.dyn {
+// SHUFFLE-NEXT:   R_X86_64_GLOB_DAT
+// SHUFFLE-NEXT:   R_X86_64_IRELATIVE
+// SHUFFLE-NEXT:   R_X86_64_IRELATIVE
+// SHUFFLE-NEXT: }
+
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 
 .type bar STT_GNU_IFUNC
 .globl bar