Make .rodata* and .eh_frame* the last of all PROGBITS sections.

[pohlen]

Summary

Some software vendors (such as NVidia) ship proprietary program code for specialized hardware (e.g. GPUs) in vendor-specific PROGBITS sections (e.g. .nv_fatbin). Before this change, these section may have been placed between .rodata and .text, which leads to relocation overflows even when the actual program code is small because these vendor-specific sections can be quite big (e.g. .nv_fatbin can be >1GiB when including support for various GPU architectures).

[MaskRay]

+@tra because of D47396

What types of relocations are from/to .nv_fatbin?

[tra]

In D74339#1867894, @MaskRay wrote:

+@tra because of D47396

What types of relocations are from/to .nv_fatbin?

Normally the only things that refer to the stuff in .nv_* are static data structures in .rodata, so placing .nv_fatbin before that is the right thing to do, as long as it does not get in a way of something else.

[MaskRay]

does an output section have limited-range relocations referring to or from it? If so, move it to the end of the segment

What I am a bit concerned is that relocations in input sections can cause layout changes (a little surprise). The heuristic of output section sizes is similar.

In D74339#1867939, @tra wrote:

In D74339#1867894, @MaskRay wrote:

+@tra because of D47396

What types of relocations are from/to .nv_fatbin?

Normally the only things that refer to the stuff in .nv_* are static data structures in .rodata, so placing .nv_fatbin before that is the right thing to do, as long as it does not get in a way of something else.

A less ad-hoc rule is to implement INSERT BEFORE for orphan sections. It currently only works for a linker script (see test/ELF/linkerscript/insert-before.test). I prefer general INSERT BEFORE and INSERT AFTER because they make the fixed internal linker script logic a bit more flexible.

In GNU ld, INSERT BEFORE is not considered an external linker script. lld currently has script->hasSectionCommands = true; => this should be fixed. INSERT BEFORE provide a quick way for disturbing the section layout. They can be used as a workaround for other relocation overflow problems.

It is difficult to get a working executable with clang -fuse-ld=lld a.c -Wl,-T,a.x, because an application-like linker script needs to create PT_LOAD segment boundaries by explicitly mentioning the first section for each PT_LOAD segment. If such an alignment is omitted => sh_addr of the first section of one PT_LOAD is not correct -> the created PT_LOAD may have overlapping p_vaddr ranges (after modulo maxpagesize at ).

A skeleton linker script which should work with both -no-pie (image base (0x400000) is required and -pie (0x400000 is not required, but it does not hurt):

SECTIONS {
  . = SIZEOF_HEADERS + 0x400000;
  .rodata : { *(.rodata*) }
  .text : { *(.text*) }
  . = ALIGN(CONSTANT(MAXPAGESIZE)) + . % CONSTANT(MAXPAGESIZE);
  .fini_array : { *(.fini_array*) }
  . = ALIGN(CONSTANT(MAXPAGESIZE)) + . % CONSTANT(MAXPAGESIZE);
  .data : { *(.data*) }
}

[MaskRay]

Created D74375 . I think INSERT [AFTER|BEFORE] is a great solution to this kind of problems..

[psmith]

In D74339#1868489, @MaskRay wrote:

Created D74375 . I think INSERT [AFTER|BEFORE] is a great solution to this kind of problems..

I agree with MaskRay that if section layout of non-standard custom sections is important then a linker script, or linker script fragment is a cleaner way to accomplish it.

lld/ELF/Writer.cpp

 // We compute a rank for each section. The rank indicates where the
 // section should be placed in the file.  Instead of using simple
 // numbers (0,1,2...), we use a series of flags. One for each decision
 // point when placing the section.
 // Using flags has two key properties:
 // * It is easy to check if a give branch was taken.
 // * It is easy two see how similar two ranks are (see getRankProximity).
 enum RankFlags {
-  RF_NOT_ADDR_SET = 1 << 27,
-  RF_NOT_ALLOC = 1 << 26,
-  RF_PARTITION = 1 << 18, // Partition number (8 bits)
-  RF_NOT_PART_EHDR = 1 << 17,
-  RF_NOT_PART_PHDR = 1 << 16,
-  RF_NOT_INTERP = 1 << 15,
-  RF_NOT_NOTE = 1 << 14,
-  RF_WRITE = 1 << 13,
-  RF_EXEC_WRITE = 1 << 12,
-  RF_EXEC = 1 << 11,
-  RF_RODATA = 1 << 10,
+  RF_NOT_ADDR_SET = 1 << 28,
+  RF_NOT_ALLOC = 1 << 27,
+  RF_PARTITION = 1 << 19, // Partition number (8 bits)
+  RF_NOT_PART_EHDR = 1 << 18,
+  RF_NOT_PART_PHDR = 1 << 17,
+  RF_NOT_INTERP = 1 << 16,
+  RF_NOT_NOTE = 1 << 15,
+  RF_WRITE = 1 << 14,
+  RF_EXEC_WRITE = 1 << 13,
+  RF_EXEC = 1 << 12,
+  RF_RODATA = 1 << 11,
+  RF_PROGBITS = 1 << 10,
   RF_NOT_RELRO = 1 << 9,
   RF_NOT_TLS = 1 << 8,
   RF_BSS = 1 << 7,
   RF_PPC_NOT_TOCBSS = 1 << 6,
   RF_PPC_TOCL = 1 << 5,
   RF_PPC_TOC = 1 << 4,
   RF_PPC_GOT = 1 << 3,
   RF_PPC_BRANCH_LT = 1 << 2,
static unsigned getSectionRank(const OutputSection *sec) {
   if (isExec) {
     if (isWrite)
       rank |= RF_EXEC_WRITE;
     else
       rank |= RF_EXEC;
   } else if (isWrite) {
     rank |= RF_WRITE;
   } else if (sec->type == SHT_PROGBITS) {
-    // Make non-executable and non-writable PROGBITS sections (e.g .rodata
-    // .eh_frame) closer to .text. They likely contain PC or GOT relative
-    // relocations and there could be relocation overflow if other huge sections
-    // (.dynstr .dynsym) were placed in between.
+    rank |= RF_PROGBITS;
+
+    // Place some non-executable and non-writable PROGBITS sections (i.e .rodata*,
+    // .eh_frame*) closer to .text. They likely contain PC or GOT relative
+    // relocations and there could be relocation overflows if other huge sections
+    // (.dynstr .dynsym, .nv_fatbin) were placed in between.
+    if (sec->name.startswith(".rodata") || sec->name.startswith(".eh_frame")) {
       rank |= RF_RODATA;
     }
+  }
 
   // Place RelRo sections first. After considering SHT_NOBITS below, the
   // ordering is PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss),
   // where | marks where page alignment happens. An alternative ordering is
   // PT_LOAD(.data | PT_GNU_RELRO( .data.rel.ro .bss.rel.ro) | .bss), but it may
   // waste more bytes due to 2 alignment places.
   if (!isRelroSection(sec))
     rank |= RF_NOT_RELRO;

lld/test/ELF/nvidia-sections.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: ld.lld %t -o %tout
+# RUN: llvm-objdump --section-headers  %tout | FileCheck %s
+
+.global _start
+.text
+_start:
+
+.section .text.,"ax"
+.byte 0
+.section .rodata,"a"
+.byte 0
+.section .data,"aw"
+.byte 0
+.section .bss,"aw",@nobits
+.byte 0
+.section .nv_fatbin,"a"
+.byte 0
+.section __nv_relfatbin,"a"
+.byte 0
+.section __nv_module_id,"a"
+.byte 0
+
+// CHECK:  1 .nv_fatbin     00000001
+// CHECK:  2 __nv_relfatbin 00000001
+// CHECK:  3 __nv_module_id 00000001
+// CHECK:  4 .rodata        00000001
+// CHECK:  5 .text          00000001
+// CHECK:  6 .data          00000001
+// CHECK:  7 .bss           00000001
+// CHECK:  8 .comment       00000008
+// CHECK:  9 .symtab        00000030
+// CHECK: 10 .shstrtab      00000066
+// CHECK: 11 .strtab        00000008

lld/test/ELF/section-name.s

 .byte 0
 .section .tbss.foo,"aGwT",@nobits,foo,comdat
 .byte 0
 .section .gcc_except_table.foo,"aG",@progbits,foo,comdat
 .byte 0
 .section .tdata.foo,"aGwT",@progbits,foo,comdat
 .byte 0
 
-// CHECK:  1 .rodata  00000002
-// CHECK:  2 .gcc_except_table 00000001
+// CHECK:  1 .gcc_except_table 00000001
+// CHECK:  2 .rodata       00000002
 // CHECK:  3 .text         00000002
 // CHECK:  4 .tdata        00000001
 // CHECK:  5 .tbss         00000001
 // CHECK:  6 .data.rel.ro  00000004
 // CHECK:  7 .data         00000002
 // CHECK:  8 .foo.a        00000001
 // CHECK:  9 .foo          00000001
 // CHECK: 10 .bss          00000002
 // CHECK: 11 .comment      00000008
 // CHECK: 12 .symtab       00000030
 // CHECK: 13 .shstrtab     00000075
 // CHECK: 14 .strtab       00000008