[ELF] Keep orphan section names (.rodata.foo .text.foo) unchanged if !hasSectionsCommand

[MaskRay]

Summary

This behavior matches GNU ld and seems reasonable.

// If a SECTIONS command is not specified
.text.* -> .text
.rodata.* -> .rodata
.init_array.* -> .init_array

A proposed Linux feature CONFIG_FG_KASLR may depend on the GNU ld behavior.

Reword a comment about -z keep-text-section-prefix.

[grimar]

lld/ELF/Writer.cpp

136

2 questions regarding the current code.

1. Seems we always rename COMMON to .bss. Does not look right for the non-linker script case?
2. If (1) is true, what about doing in the following way?

if (script->hasSectionsCommand) {
  // CommonSection is identified as "COMMON" in linker scripts.
  // By default, it should go to .bss section.
  if (s->name == "COMMON")
    return ".bss";
  return s->name;
}

// When no SECTIONS is specified, emulate GNU ld's internal linker scripts...
<code>

lld/test/ELF/text-section-prefix.s

20

Do you need -z keep-text-section-prefix? Seems both ld.bfd and ld.gold produce the same output without this option.

[psmith]

I'm happy to make the change, although orphan section placement is documented to be linker's choice it will help people needing support in ld.bfd and lld if we have similar rules.

[MaskRay]

lld/ELF/Writer.cpp

136

1. "COMMON" sections are created this way: auto *bss = make<BssSection>("COMMON", s->size, s->alignment); With a linker script without mentioning an input section description COMMON, GNU ld can still place COMMON in .bss The logic here is compatible with GNU ld.

2. I feel that an early return pattern here does not improve readability.

lld/test/ELF/text-section-prefix.s

20

This is to emphasize that a SECTIONS command overrides -z keep-text-section-prefix.

[kees]

.text.* -> .text

This is not accurate: ld.bfd will keep the .text.$foo names, but place them all after the .text (it does not merge them into .text). Currently, ld.lld seems to merge them into .text. FGKASLR depends on the non-merging behavior.

[MaskRay]

In D75225#1895813, @kees wrote:

.text.* -> .text

This is not accurate: ld.bfd will keep the .text.$foo names, but place them all after the .text (it does not merge them into .text). Currently, ld.lld seems to merge them into .text. FGKASLR depends on the non-merging behavior.

I think the description is correct. I have a line // If a SECTIONS command is not specified in the code block.

Here is GNU ld's internal linker script:

.text           :
{
  *(.text.unlikely .text.*_unlikely .text.unlikely.*)
  *(.text.exit .text.exit.*)
  *(.text.startup .text.startup.*)
  *(.text.hot .text.hot.*)
  *(.text .stub .text.* .gnu.linkonce.t.*)
  /* .gnu.warning sections are handled specially by elf32.em.  */
  *(.gnu.warning)
}

(As you can see, -z keep-text-section-prefix does less than what GNU ld does. One issue with GNU ld's internal linker script is that -ffunction-sections (typical when building a libc) will cause the function exit to be reordered before others...)

[MaskRay]

LG? 😷

[kees]

In D75225#1896066, @MaskRay wrote:

In D75225#1895813, @kees wrote:

.text.* -> .text

This is not accurate: ld.bfd will keep the .text.$foo names, but place them all after the .text (it does not merge them into .text). Currently, ld.lld seems to merge them into .text. FGKASLR depends on the non-merging behavior.

I think the description is correct. I have a line // If a SECTIONS command is not specified in the code block.

Here is GNU ld's internal linker script:

.text           :
{
  *(.text.unlikely .text.*_unlikely .text.unlikely.*)
  *(.text.exit .text.exit.*)
  *(.text.startup .text.startup.*)
  *(.text.hot .text.hot.*)
  *(.text .stub .text.* .gnu.linkonce.t.*)
  /* .gnu.warning sections are handled specially by elf32.em.  */
  *(.gnu.warning)
}

(As you can see, -z keep-text-section-prefix does less than what GNU ld does. One issue with GNU ld's internal linker script is that -ffunction-sections (typical when building a libc) will cause the function exit to be reordered before others...)

Maybe by default? However, when building the kernel and the linker script has an explicit .text output section without an input .text.* pattern, ld.bfd does not collect them into the output .text section (they are just adjacent).

[grimar]

lld/ELF/Writer.cpp

136

> I feel that an early return pattern here does not improve readability.

A little reordering converts it to the following piece of code without an additional nesting.
Isn't it a bit simpler?

  // CommonSection is identified as "COMMON" in linker scripts.
  // By default, it should go to .bss section.
  if (s->name == "COMMON")
    return ".bss";

  if (script->hasSectionsCommand)
    return s->name;

  // When no SECTIONS is specified, emulate GNU ld's internal linker scripts...
  ...
  return s->name;
}

lld/test/ELF/linkerscript/icf-output-sections.s

31

The comment is outdated.

[MaskRay]

Rebase. Address comments

[grimar]

LGTM

[MaskRay]

Fix a comment about CommonSection. CommonSection was removed long ago.

lld/ELF/Writer.cpp

if (auto *isec = dyn_cast<InputSection>(s)) {
     if (InputSectionBase *rel = isec->getRelocatedSection()) {
       OutputSection *out = rel->getOutputSection();
       if (s->type == SHT_RELA)
         return saver.save(".rela" + out->name);
       return saver.save(".rel" + out->name);
     }
   }
 
-  // This check is for -z keep-text-section-prefix.  This option separates text
-  // sections with prefix ".text.hot", ".text.unlikely", ".text.startup" or
-  // ".text.exit".
-  // When enabled, this allows identifying the hot code region (.text.hot) in
-  // the final binary which can be selectively mapped to huge pages or mlocked,
-  // for instance.
+  if (!script->hasSectionsCommand) {
+    // When no SECTIONS is specified, emulate GNU ld's internal linker scripts
+    // by grouping sections with certain prefixes.
+
+    // GNU ld places text sections with prefix ".text.hot.", ".text.unlikely.",
+    // ".text.startup." or ".text.exit." before others. We provide an option -z
+    // keep-text-section-prefix to group such sections into separate output
+    // sections. This is more flexible. See also sortISDBySectionOrder().
     if (config->zKeepTextSectionPrefix)
       for (StringRef v :
            {".text.hot.", ".text.unlikely.", ".text.startup.", ".text.exit."})
         if (isSectionPrefix(v, s->name))
           return v.drop_back();
 
-  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."})
+    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."})
       if (isSectionPrefix(v, s->name))
         return v.drop_back();
+  }
 
   // CommonSection is identified as "COMMON" in linker scripts.
   // By default, it should go to .bss section.
   if (s->name == "COMMON")
     return ".bss";
 
   return s->name;
 }
 
 static bool needsInterpSection() {
   return !config->relocatable && !config->shared &&
          !config->dynamicLinker.empty() && script->needsInterpSection();
 }

lld/test/ELF/linkerscript/data-commands-gc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { .text : { *(.text*) QUAD(bar) } }" > %t.script
 # RUN: ld.lld --gc-sections -o %t %t.o --script %t.script
 # RUN: llvm-objdump -t %t | FileCheck %s
 
-# CHECK: 0000000000000008         .rodata                 00000000 bar
+# CHECK: 0000000000000008         .rodata.bar                 00000000 bar
 
 .section .rodata.bar
 .quad 0x1122334455667788
 .global bar
 bar:
 
 .section .text
 .global _start
 _start:
   nop

lld/test/ELF/linkerscript/icf-output-sections.s

 # ICF2:      selected section {{.*}}.o:(.text.foo0)
 # ICF2-NEXT:   removing identical section {{.*}}.o:(.text.foo1)
 # ICF2-NEXT: selected section {{.*}}.o:(.text.bar0)
 # ICF2-NEXT:   removing identical section {{.*}}.o:(.text.bar1)
 
 # SEC2:      .text.foo   PROGBITS 0000000000000000 001000 000001
 # SEC2-NEXT: .text.bar   PROGBITS 0000000000000001 001001 000001
 
 ## .text.bar* are orphans that get assigned to .text.
 # RUN: echo 'SECTIONS { .text.foo : {*(.text.foo*)} }' > %t3.script
-# RUN: ld.lld %t.o --script %t3.script --icf=all --print-icf-sections -o %t | FileCheck --check-prefix=ICF2 %s
-# RUN: llvm-readelf -S %t | FileCheck --check-prefix=SEC3 %s
+# RUN: ld.lld %t.o -T %t3.script --icf=all --print-icf-sections -o %t3 | FileCheck --check-prefix=ICF3 %s
+# RUN: llvm-readelf -S %t3 | FileCheck --check-prefix=SEC3 %s
 
+# ICF3:      selected section {{.*}}.o:(.text.foo0)
+# ICF3-NEXT:   removing identical section {{.*}}.o:(.text.foo1)
+
+# SEC3:      Name        Type     Address          Off    Size
 # SEC3:      .text.foo   PROGBITS 0000000000000000 001000 000001
-# SEC3-NEXT: .text       PROGBITS 0000000000000004 001004 000001
+# SEC3-NEXT: .text       PROGBITS 0000000000000004 001004 000000
+# SEC3-NEXT: .text.bar0  PROGBITS 0000000000000004 001004 000001
+# SEC3-NEXT: .text.bar1  PROGBITS 0000000000000005 001005 000001
 
 .section .text.foo0,"ax"
 ret
 .section .text.foo1,"ax"
 ret
 .section .text.bar0,"ax"
 ret
 .section .text.bar1,"ax"
 ret

lld/test/ELF/linkerscript/linkorder.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
-# RUN: echo "SECTIONS { .text : { *(.text.bar) *(.text.foo)  } }" > %t.script
+# RUN: echo "SECTIONS { .rodata : {*(.rodata*)} .text : {*(.text.bar) *(.text.foo)} }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck %s
 
-# RUN: echo "SECTIONS { .text : { *(.text.foo) *(.text.bar) } }" > %t.script
+# RUN: echo "SECTIONS { .rodata : {*(.rodata*)} .text : {*(.text.foo) *(.text.bar)} }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck --check-prefix=INV %s
 
 
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT: 02000000 00000000 01000000 00000000
 # CHECK:      Contents of section .text:
 # CHECK-NEXT: 02000000 00000000 01000000 00000000

lld/test/ELF/linkerscript/linkorder2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
-# RUN: echo "SECTIONS { .text : { *(.text.*) } }" > %t.script
+# RUN: echo 'SECTIONS { .rodata : {*(.rodata.*)} .text : {*(.text.*)} }' > %t.script
 
 # RUN: echo "_bar" > %t.ord
 # RUN: echo "_foo" >> %t.ord
 # RUN: ld.lld --symbol-ordering-file %t.ord -o %t --script %t.script %t.o
 # RUN: llvm-objdump -s %t | FileCheck %s
 
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT: 02000000 00000000 01000000 00000000

lld/test/ELF/linkerscript/memory3.s

 # RUN: llvm-objdump -section-headers %t2 | FileCheck %s
 
 ## Check we place .text into first defined memory region with appropriate flags.
 # CHECK: Sections:
 # CHECK: Idx Name  Size     VMA
 # CHECK:   0       00000000 0000000000000000
 # CHECK:   1 .text 00000001 0000000000001000
 
-.section .text.foo,"ax",%progbits
+.section .text,"ax",%progbits
 foo:
   nop

lld/test/ELF/linkerscript/orphan-report.s

 # RUN: not ld.lld --orphan-handling=error --strip-all -o /dev/null -T %t.script \
 # RUN:   %t.o 2>&1 | FileCheck %s --check-prefix=COMMON
 
 ## -shared enables some .dynsym related sections.
 # RUN: not ld.lld -shared --orphan-handling=error -o /dev/null -T %t.script \
 # RUN:   %t.o 2>&1 | FileCheck %s --check-prefixes=COMMON,DYNSYM,SYMTAB
 
 # COMMON:      {{.*}}.o:(.text) is being placed in '.text'
-# COMMON-NEXT: {{.*}}.o:(.text.2) is being placed in '.text'
+# COMMON-NEXT: {{.*}}.o:(.text.2) is being placed in '.text.2'
 # COMMON-NEXT: <internal>:(.comment) is being placed in '.comment'
 # DYNSYM-NEXT: <internal>:(.dynsym) is being placed in '.dynsym'
 # DYNSYM-NEXT: <internal>:(.gnu.hash) is being placed in '.gnu.hash'
 # DYNSYM-NEXT: <internal>:(.hash) is being placed in '.hash'
 # DYNSYM-NEXT: <internal>:(.dynamic) is being placed in '.dynamic'
 # DYNSYM-NEXT: <internal>:(.dynstr) is being placed in '.dynstr'
 # SYMTAB-NEXT: <internal>:(.symtab) is being placed in '.symtab'
 # COMMON-NEXT: <internal>:(.shstrtab) is being placed in '.shstrtab'

lld/test/ELF/linkerscript/symbol-assign-many-passes2.test

 
 SECTIONS {
   . = SIZEOF_HEADERS;
   .text 0x00011000 : {
     a = b + 1;
     b = c + 1;
     c = d + 1;
     d = e + 1;
-    *(.text);
+    *(.text*);
   }
   e = .;
 }

lld/test/ELF/mips-npic-call-pic-script.s

 # .text.2 sections will be added to .text
 # RUN: echo "SECTIONS { .text 0x20000 : { *(.text) }  }" > %t2.script
 # RUN: ld.lld --script %t2.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t2.exe
 # RUN: llvm-objdump -d --no-show-raw-insn %t2.exe | FileCheck -check-prefix=ORPH1 %s
 
 # ORPH1: Disassembly of section .text:
 # ORPH1-EMPTY:
 # ORPH1-NEXT: __start:
-# ORPH1-NEXT:    20000:       jal     131156 <__LA25Thunk_foo1a>
+# ORPH1-NEXT:    20000:       jal     131168 <__LA25Thunk_foo1a>
 # ORPH1-NEXT:    20004:       nop
-# ORPH1-NEXT:    20008:       jal     131208 <__LA25Thunk_foo2>
+# ORPH1-NEXT:    20008:       jal     131216 <__LA25Thunk_foo2>
 # ORPH1-NEXT:    2000c:       nop
-# ORPH1-NEXT:    20010:       jal     131172 <__LA25Thunk_foo1b>
+# ORPH1-NEXT:    20010:       jal     131184 <__LA25Thunk_foo1b>
 # ORPH1-NEXT:    20014:       nop
-# ORPH1-NEXT:    20018:       jal     131208 <__LA25Thunk_foo2>
+# ORPH1-NEXT:    20018:       jal     131216 <__LA25Thunk_foo2>
 # ORPH1-NEXT:    2001c:       nop
 # ORPH1-NEXT:    20020:       jal     131120 <__LA25Thunk_fpic>
 # ORPH1-NEXT:    20024:       nop
 # ORPH1-NEXT:    20028:       jal     131152 <fnpic>
 # ORPH1-NEXT:    2002c:       nop
 
 # ORPH1: __LA25Thunk_fpic:
 # ORPH1-NEXT:    20030:       lui     $25, 2
 # ORPH1-NEXT:    20034:       j       131136 <fpic>
 # ORPH1-NEXT:    20038:       addiu   $25, $25, 64
 # ORPH1-NEXT:    2003c:       nop
 
 # ORPH1: fpic:
 # ORPH1-NEXT:    20040:       nop
 
 # ORPH1: fnpic:
 # ORPH1-NEXT:    20050:       nop
 
 # ORPH1: __LA25Thunk_foo1a:
-# ORPH1-NEXT:    20054:       lui     $25, 2
-# ORPH1-NEXT:    20058:       j       131200 <foo1a>
-# ORPH1-NEXT:    2005c:       addiu   $25, $25, 128
-# ORPH1-NEXT:    20060:       nop
+# ORPH1-NEXT:    20060:       lui     $25, 2
+# ORPH1-NEXT:                 j       131200 <foo1a>
+# ORPH1-NEXT:                 addiu   $25, $25, 128
+# ORPH1-NEXT:                 nop
 
 # ORPH1: __LA25Thunk_foo1b:
-# ORPH1-NEXT:    20064:       lui     $25, 2
-# ORPH1-NEXT:    20068:       j       131204 <foo1b>
-# ORPH1-NEXT:    2006c:       addiu   $25, $25, 132
-# ORPH1-NEXT:    20070:       nop
+# ORPH1-NEXT:    20070:       lui     $25, 2
+# ORPH1-NEXT:                 j       131204 <foo1b>
+# ORPH1-NEXT:                 addiu   $25, $25, 132
+# ORPH1-NEXT:                 nop
 
 # ORPH1: foo1a:
 # ORPH1-NEXT:    20080:       nop
 
 # ORPH1: foo1b:
 # ORPH1-NEXT:    20084:       nop
 
 # ORPH1: __LA25Thunk_foo2:
-# ORPH1-NEXT:    20088:       lui     $25, 2
-# ORPH1-NEXT:    2008c:       j       131232 <foo2>
-# ORPH1-NEXT:    20090:       addiu   $25, $25, 160
-# ORPH1-NEXT:    20094:       nop
+# ORPH1-NEXT:    20090:       lui     $25, 2
+# ORPH1-NEXT:                 j       131232 <foo2>
+# ORPH1-NEXT:                 addiu   $25, $25, 160
+# ORPH1-NEXT:                 nop
 
 # ORPH1: foo2:
 # ORPH1-NEXT:    200a0:       nop
 
 # Test script with orphans added to new OutputSection, the .text.1 and
 # .text.2 sections will form a new OutputSection .text
-# RUN: echo "SECTIONS { .out 0x20000 : { *(.text) }  }" > %t3.script
+# RUN: echo "SECTIONS { .out 0x20000 : { *(.text) } .text : {*(.text*)} }" > %t3.script
 # RUN: ld.lld --script %t3.script %t-npic.o %t-pic.o %t-sto-pic.o -o %t3.exe
 # RUN: llvm-objdump -d --no-show-raw-insn %t3.exe | FileCheck -check-prefix=ORPH2 %s
 
 # ORPH2: Disassembly of section .out:
 # ORPH2-EMPTY:
 # ORPH2-NEXT: __start:
 # ORPH2-NEXT:    20000:       jal     131168 <__LA25Thunk_foo1a>
 # ORPH2-NEXT:    20004:       nop

lld/test/ELF/shuffle-sections-init-fini.s

 
 # CHECK:      Hex dump of section '.fini_array'
 # CHECK-NEXT: 0x{{[0-9a-f]+}} ff
 # ORDERED-SAME:  000102 03040506 0708090a 0b
 # SHUFFLED-SAME: 090401 070b0003 080a0605 02
 
 ## With a SECTIONS command, SHT_INIT_ARRAY prirotities are ignored.
 ## All .init_array* are shuffled together.
-# RUN: echo 'SECTIONS {}' > %t.script
+# RUN: echo 'SECTIONS { \
+# RUN:   .init_array : { *(.init_array*) } \
+# RUN:   .fini_array : { *(.fini_array*) }}' > %t.script
 # RUN: ld.lld -T %t.script %t.o -o %t2
 # RUN: llvm-readelf -x .init -x .fini -x .init_array -x .fini_array %t2 | \
 # RUN:   FileCheck --check-prefixes=CHECK2,ORDERED2 %s
 # RUN: ld.lld -T %t.script %t.o --shuffle-sections=1 -o %t3
 # RUN: llvm-readelf -x .init -x .fini -x .init_array -x .fini_array %t3 | \
 # RUN:   FileCheck --check-prefixes=CHECK2,SHUFFLED2 %s
 
 # CHECK2:       Hex dump of section '.init_array'

lld/test/ELF/text-section-prefix.s

 # CHECK: .text
 # CHECK: .text.hot
 # CHECK: .text.startup
 # CHECK: .text.exit
 # CHECK: .text.unlikely
 # CHECKNO: .text
 # CHECKNO-NOT: .text.hot
 
+## With a SECTIONS command, no grouping is performed at all.
+# RUN: echo 'SECTIONS {}' > %t.script
+# RUN: ld.lld -T %t.script -z keep-text-section-prefix %t -o %t5
+# RUN: llvm-readelf -S %t5 | FileCheck --check-prefix=SCRIPT %s
+
+# SCRIPT:      .text
+# SCRIPT-NEXT: .text.f
+# SCRIPT-NEXT: .text.hot.f_hot
+# SCRIPT-NEXT: .text.startup.f_startup
+# SCRIPT-NEXT: .text.exit.f_exit
+# SCRIPT-NEXT: .text.unlikely.f_unlikely
+
 _start:
   ret
 
 .section .text.f,"ax"
 f:
   nop
 
 .section .text.hot.f_hot,"ax"