[ELF] - Produce relocation section name consistent with output section name when --emit-reloc used with linker script.

[grimar]

Summary

This is for "Bug 35474 - --emit-relocs produces wrongly-named reloc sections".

LLD currently for scripts like:

.text.boot : { *(.text.boot) }

emits relocation section with name .rela.text because does not take
redefined name of output section into account and builds section name
using rules for non-scripted case. Patch fixes this oddness.

[ruiu]

ELF/Writer.cpp

91 ↗

(On Diff #124935)

This saves only two characters. Just use S->Name instead of Name.

104–105 ↗

(On Diff #124935)

Is it possible that a section is a synthetic section and has type of SHT_REL[A]?

[ruiu]

LGTM given that you will name Name S->Name in a follow-up patch.

[mcgrathr]

This change as is fixes my real-world case.
Thanks! Now I'm just blocked on --just-symbols...

[grimar]

ELF/Writer.cpp

104–105 ↗

(On Diff #124935)

Yes, .rela.dyn/.rela.plt for example.

btw, I was thinking about wrapping this whole block in if (Config->EmitRelocs).
It should not affect logic, but probably can make code more readable because reader not need
to read code for --emit-relocs usually. With explicit if statement it can be skipped.
But we usually do not do excessive checks for readability I think, so did not do that.

lld/trunk/ELF/LinkerScript.cpp

void LinkerScript::addOrphanSections() {
   unsigned End = SectionCommands.size();
   StringMap<OutputSection *> Map;
 
   std::vector<OutputSection *> V;
   for (InputSectionBase *S : InputSections) {
     if (!S->Live || S->Parent)
       continue;
 
-    StringRef Name = getOutputSectionName(S->Name);
+    StringRef Name = getOutputSectionName(S);
 
     if (Config->OrphanHandling == OrphanHandlingPolicy::Error)
       error(toString(S) + " is being placed in '" + Name + "'");
     else if (Config->OrphanHandling == OrphanHandlingPolicy::Warn)
       warn(toString(S) + " is being placed in '" + Name + "'");
 
     if (OutputSection *Sec =
             findByName(makeArrayRef(SectionCommands).slice(0, End), Name)) {

lld/trunk/ELF/SyntheticSections.cpp

for (InputSectionBase *&S : InputSections) {
     if (!MS)
       continue;
 
     // We do not want to handle sections that are not alive, so just remove
     // them instead of trying to merge.
     if (!MS->Live)
       continue;
 
-    StringRef OutsecName = getOutputSectionName(MS->Name);
+    StringRef OutsecName = getOutputSectionName(MS);
     uint32_t Alignment = std::max<uint32_t>(MS->Alignment, MS->Entsize);
 
     auto I = llvm::find_if(MergeSections, [=](MergeSyntheticSection *Sec) {
       // While we could create a single synthetic section for two different
       // values of Entsize, it is better to take Entsize into consideration.
       //
       // With a single synthetic section no two pieces with different Entsize
       // could be equal, so we may as well have two sections.

lld/trunk/ELF/Writer.h

struct PhdrEntry {
   uint32_t p_type = 0;
   uint32_t p_flags = 0;
 
   OutputSection *FirstSec = nullptr;
   OutputSection *LastSec = nullptr;
   bool HasLMA = false;
 };
 
-llvm::StringRef getOutputSectionName(llvm::StringRef Name);
+llvm::StringRef getOutputSectionName(InputSectionBase *S);
 
 template <class ELFT> uint32_t calcMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
 bool isMicroMips();
 bool isMipsR6();
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Writer.cpp

private:
 
   uint64_t FileSize;
   uint64_t SectionHeaderOff;
 
   bool HasGotBaseSym = false;
 };
 } // anonymous namespace
 
-StringRef elf::getOutputSectionName(StringRef Name) {
+StringRef elf::getOutputSectionName(InputSectionBase *S) {
+  StringRef Name = S->Name;
+
   // ".zdebug_" is a prefix for ZLIB-compressed sections.
   // Because we decompressed input sections, we want to remove 'z'.
   if (Name.startswith(".zdebug_"))
     return Saver.save("." + Name.substr(2));
 
   if (Config->Relocatable)
     return Name;
 
-  // This is for --emit-relocs. If .text.foo is emitted as .text, we want to
-  // emit .rela.text.foo as .rel.text for consistency (this is not technically
-  // required, but not doing it is odd). This code guarantees that.
-  if (Name.startswith(".rel."))
-    return Saver.save(".rel" + getOutputSectionName(Name.substr(4)));
-  if (Name.startswith(".rela."))
-    return Saver.save(".rela" + getOutputSectionName(Name.substr(5)));
+  // This is for --emit-relocs. If .text.foo is emitted as .text.bar, we want
+  // to emit .rela.text.foo as .rela.text.bar for consistency (this is not
+  // technically required, but not doing it is odd). This code guarantees that.
+  if ((S->Type == SHT_REL || S->Type == SHT_RELA) &&
+      !isa<SyntheticSection>(S)) {
+    OutputSection *Out =
+        cast<InputSection>(S)->getRelocatedSection()->getOutputSection();
+    if (S->Type == SHT_RELA)
+      return Saver.save(".rela" + Out->Name);
+    return Saver.save(".rel" + Out->Name);
+  }
 
   for (StringRef V :
        {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.rel.ro.",
         ".bss.", ".init_array.", ".fini_array.", ".ctors.", ".dtors.", ".tbss.",
         ".gcc_except_table.", ".tdata.", ".ARM.exidx.", ".ARM.extab."}) {
     StringRef Prefix = V.drop_back();
     if (Name.startswith(V) || Name == Prefix)
       return Prefix;

lld/trunk/test/ELF/linkerscript/emit-reloc-section-names.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: echo "SECTIONS { .text.zed : { *(.text.foo) } \
+# RUN:                  .text.qux : { *(.text.bar) } }" > %t.script
+# RUN: ld.lld -T %t.script --emit-relocs %t.o -o %t
+# RUN: llvm-objdump -section-headers %t | FileCheck %s
+
+## Check we name relocation sections in according to
+## their target sections names.
+
+# CHECK: .text.zed
+# CHECK: .text.qux
+# CHECK: .rela.text.zed
+# CHECK: .rela.text.qux
+
+.section .text.foo,"ax"
+foo:
+ mov $bar, %rax
+
+.section .text.bar,"ax"
+bar:
+ mov $foo, %rax

lld/trunk/test/ELF/linkerscript/emit-relocs-multiple.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .zed : { *(.foo) *(.bar) } }" > %t.script
 # RUN: ld.lld --emit-relocs --script %t.script %t.o -o %t1
 # RUN: llvm-readobj -r %t1 | FileCheck %s
 
 # CHECK:      Relocations [
-# CHECK-NEXT:   Section {{.*}} .rela.foo {
+# CHECK-NEXT:   Section {{.*}} .rela.zed {
 # CHECK-NEXT:     0x1 R_X86_64_32 .zed 0x0
 # CHECK-NEXT:     0x6 R_X86_64_32 .zed 0x5
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 .section .foo,"ax",@progbits
 aaa:
   movl $aaa, %edx
 
 .section .bar,"ax",@progbits
 bbb:
   movl $bbb, %edx