[ELF] - Don't create PT_LOAD's when linking script is used.

[grimar]

Summary

Actually patch is more about that we should not align the PT_LOAD's created
if we use linker script. That is the main aim of this patch.
(we dont want to touch the location counter when we use script)

I don't have strong opinion about creating PT_LOAD's as ld and gold do diffterent things that
both looks ok for me.
Please see below:

Consider the next code and empty linker script file..
main.s:

.globl _start;
_start:
nop

.section .data
.quad 0

llvm-mc -filetype=obj -triple=x86_64-pc-linux main.s -o main.o
gold main.o -script empty.script -o test

produces 2 Loads without allignment of VA's:

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x00000000000000b1 0x00000000000000b1  R E    1000
  LOAD           0x00000000000000b1 0x00000000004010b1 0x00000000004010b1
                 0x0000000000000008 0x0000000000000008  RW     1000

GNU ld has another output here:
ld main.o -script empty.script -o test
Program Headers:

Type           Offset             VirtAddr           PhysAddr
               FileSiz            MemSiz              Flags  Align
LOAD           0x0000000000200000 0x0000000000000000 0x0000000000000000
               0x0000000000000009 0x0000000000000009  RWE    200000

So there is a single PT_LOAD with flags combined.

This patch implements the same behavior as ld do.

[ruiu]

I think this patch implemented an edge case of the linker script. The general case is that, if a linker script is given, then section layout needs to be determined by the script. Once we implement the linker script support, I don't think it would execute this code path because we would have a different code path for the linker script. In that sense this patch does not solve a problem or prepare for the linker script support.

[grimar]

In D18317#379575, @ruiu wrote:

I think this patch implemented an edge case of the linker script. The general case is that, if a linker script is given, then section layout needs to be determined by the script. Once we implement the linker script support, I don't think it would execute this code path because we would have a different code path for the linker script. In that sense this patch does not solve a problem or prepare for the linker script support.

Well, I don't want argue with that now. I hope tomorrow will post a patch for initial location counter support (from linker script). Lets then return back to this after that.

[grimar]

In D18317#379575, @ruiu wrote:

I think this patch implemented an edge case of the linker script. The general case is that, if a linker script is given, then section layout needs to be determined by the script. Once we implement the linker script support, I don't think it would execute this code path because we would have a different code path for the linker script. In that sense this patch does not solve a problem or prepare for the linker script support.

So sorry, I am a bit late with that, but I finally posted a patch implementing few ideas about initial location counter support and this one is a dependency :)
(http://reviews.llvm.org/D18499)

[grimar]

This one not correct, we *should* create PT_LOADs. What we want is not to change VA (align to PT_LOAD etc) when using linkerscript still, I'll post different version for that.

ELF/LinkerScript.h

public:
   void read(MemoryBufferRef MB);
 
   template <class ELFT> StringRef getOutputSection(InputSectionBase<ELFT> *S);
   ArrayRef<uint8_t> getFiller(StringRef Name);
   template <class ELFT> bool isDiscarded(InputSectionBase<ELFT> *S);
   template <class ELFT> bool shouldKeep(InputSectionBase<ELFT> *S);
   int compareSections(StringRef A, StringRef B);
 
+  bool Exist = false;
+
 private:
   template <class ELFT> SectionRule *find(InputSectionBase<ELFT> *S);
 
   // SECTIONS commands.
   std::vector<SectionRule> Sections;
 
   // Output sections are sorted by this order.
   std::vector<StringRef> SectionOrder;

ELF/LinkerScript.cpp

if (sys::fs::equivalent(Config->Sysroot, Path))
       return true;
   return false;
 }
 
 // Entry point. The other functions or classes are private to this file.
 void LinkerScript::read(MemoryBufferRef MB) {
   StringRef Path = MB.getBufferIdentifier();
   ScriptParser(&Alloc, MB.getBuffer(), isUnderSysroot(Path)).run();
+  Exist = true;
 }
 
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF32LE> *);
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF32BE> *);
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF64LE> *);
 template StringRef LinkerScript::getOutputSection(InputSectionBase<ELF64BE> *);
 
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF32LE> *);
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF32BE> *);
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF64LE> *);
 template bool LinkerScript::isDiscarded(InputSectionBase<ELF64BE> *);
 
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF32LE> *);
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF32BE> *);
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF64LE> *);
 template bool LinkerScript::shouldKeep(InputSectionBase<ELF64BE> *);

ELF/Writer.cpp

for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     // assign addresses.
     if (Sec->getFlags() & SHF_TLS)
       AddSec(TlsHdr, Sec);
 
     if (!needsPtLoad<ELFT>(Sec))
       continue;
 
     // If flags changed then we want new load segment.
+    // If we have linker script then we don't do that, because
+    // it is script writer responsibility to assign VA's.
     uintX_t NewFlags = toPhdrFlags(Sec->getFlags());
     if (Flags != NewFlags) {
+      if (Script->Exist) {
+        Load->H.p_flags |= NewFlags;
+      } else {
         Load = AddHdr(PT_LOAD, NewFlags);
         Flags = NewFlags;
       }
+    }
 
     AddSec(*Load, Sec);
 
     if (isRelroSection(Sec))
       AddSec(RelRo, Sec);
     if (Sec->getType() == SHT_NOTE)
       AddSec(Note, Sec);
   }

test/ELF/end.s

 
 // NOBSS: Sections [
 // NOBSS:     Name: .data
 // NOBSS-NEXT:     Type:
 // NOBSS-NEXT:     Flags [
 // NOBSS-NEXT:       SHF_ALLOC
 // NOBSS-NEXT:       SHF_WRITE
 // NOBSS-NEXT:     ]
-// NOBSS-NEXT:     Address: 0x12000
+// NOBSS-NEXT:     Address: 0x100E9
 // NOBSS-NEXT:     Offset:
 // NOBSS-NEXT:     Size: 2
 // NOBSS: ]
 // NOBSS: Symbols [
 // NOBSS:     Name: _end
-// NOBSS-NEXT:     Value: 0x12002
+// NOBSS-NEXT:     Value: 0x100EB
 // NOBSS: ]
 
 // If the layout of the sections is changed, "_end" should point to the end of allocated address space.
 // RUN: echo "SECTIONS { \
 // RUN:          .bss : { *(.bss) } \
 // RUN:          .data : { *(.data) } \
 // RUN:          .text : { *(.text) } }" > %t.script
 // RUN: ld.lld %t.o --script %t.script -o %t
 // RUN: llvm-readobj -sections -symbols %t | FileCheck %s --check-prefix=TEXTATEND
 
 // TEXTATEND: Sections [
 // TEXTATEND:     Name: .text
 // TEXTATEND-NEXT:     Type:
 // TEXTATEND-NEXT:     Flags [
 // TEXTATEND-NEXT:       SHF_ALLOC
 // TEXTATEND-NEXT:       SHF_EXECINSTR
 // TEXTATEND-NEXT:     ]
-// TEXTATEND-NEXT:     Address: 0x12000
+// TEXTATEND-NEXT:     Address: 0x100F0
 // TEXTATEND-NEXT:     Offset:
 // TEXTATEND-NEXT:     Size: 1
 // TEXTATEND: ]
 // TEXTATEND: Symbols [
 // TEXTATEND:     Name: _end
-// TEXTATEND-NEXT:     Value: 0x12001
+// TEXTATEND-NEXT:     Value: 0x100F1
 // TEXTATEND: ]
 
 .global _start,_end
 .text
 _start:
     nop
 .data
     .word 1
 .bss
     .space 6

test/ELF/linkerscript-oneload.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "" > %t.script
+# RUN: ld.lld %t --script %t.script -o %t2
+# RUN: llvm-readobj -program-headers -symbols %t2 | FileCheck %s
+
+.globl _start;
+_start:
+  nop
+
+## Check that only one PT_LOAD is created with empty linker script.
+# CHECK:      ProgramHeaders [
+# CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_PHDR
+# CHECK-NEXT:     Offset: 0x40
+# CHECK-NEXT:     VirtualAddress: 0x10040
+# CHECK-NEXT:     PhysicalAddress: 0x10040
+# CHECK-NEXT:     FileSize: 168
+# CHECK-NEXT:     MemSize: 168
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       PF_R
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment: 8
+# CHECK-NEXT:   }
+# CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_LOAD
+# CHECK-NEXT:     Offset: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x10000
+# CHECK-NEXT:     PhysicalAddress: 0x10000
+# CHECK-NEXT:     FileSize: 233
+# CHECK-NEXT:     MemSize: 233
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       PF_R
+# CHECK-NEXT:       PF_X
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment: 4096
+# CHECK-NEXT:   }
+# CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_GNU_STACK
+# CHECK-NEXT:     Offset: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     FileSize: 0
+# CHECK-NEXT:     MemSize: 0
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       PF_R
+# CHECK-NEXT:       PF_W
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]

test/ELF/linkerscript-sections-keep.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## First check that section "keep" is garbage collected without using KEEP
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { *(.keep) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=SECGC %s
 # SECGC:      Sections:
 # SECGC-NEXT: Idx Name          Size      Address          Type
 # SECGC-NEXT:   0               00000000 0000000000000000
-# SECGC-NEXT:   1 .text         00000007 0000000000011000 TEXT DATA
-# SECGC-NEXT:   2 .temp         00000004 0000000000012000 DATA
+# SECGC-NEXT:   1 .text         00000007 00000000000100e8 TEXT DATA
+# SECGC-NEXT:   2 .temp         00000004 00000000000100ef DATA
 
 ## Now apply KEEP command to preserve the section.
 # RUN: echo "SECTIONS { \
 # RUN:  .text : { *(.text) } \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .temp : { *(.temp) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=SECNOGC %s
 # SECNOGC:      Sections:
 # SECNOGC-NEXT: Idx Name          Size      Address          Type
 # SECNOGC-NEXT:   0               00000000 0000000000000000
-# SECNOGC-NEXT:   1 .text         00000007 0000000000011000 TEXT DATA
-# SECNOGC-NEXT:   2 .keep         00000004 0000000000012000 DATA
-# SECNOGC-NEXT:   3 .temp         00000004 0000000000012004 DATA
+# SECNOGC-NEXT:   1 .text         00000007 00000000000100e8 TEXT DATA
+# SECNOGC-NEXT:   2 .keep         00000004 00000000000100ef DATA
+# SECNOGC-NEXT:   3 .temp         00000004 00000000000100f3 DATA
 
 ## A section name matches two entries in the SECTIONS directive. The
 ## first one doesn't have KEEP, the second one does. If section that have
 ## KEEP is the first in order then section is NOT collected.
 # RUN: echo "SECTIONS { \
 # RUN:  .keep : { KEEP(*(.keep)) } \
 # RUN:  .nokeep : { *(.keep) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=KEEP-AT-FIRST %s
 # KEEP-AT-FIRST:      Sections:
 # KEEP-AT-FIRST-NEXT:  Idx Name          Size      Address         Type
 # KEEP-AT-FIRST-NEXT:   0               00000000 0000000000000000
-# KEEP-AT-FIRST-NEXT:   1 .keep         00000004 0000000000010120 DATA
-# KEEP-AT-FIRST-NEXT:   2 .temp         00000004 0000000000010124 DATA
-# KEEP-AT-FIRST-NEXT:   3 .text         00000007 0000000000011000 TEXT DATA
+# KEEP-AT-FIRST-NEXT:   1 .keep         00000004 00000000000100e8 DATA
+# KEEP-AT-FIRST-NEXT:   2 .temp         00000004 00000000000100ec DATA
+# KEEP-AT-FIRST-NEXT:   3 .text         00000007 00000000000100f0 TEXT DATA
 # KEEP-AT-FIRST-NEXT:   4 .symtab       00000060 0000000000000000
 # KEEP-AT-FIRST-NEXT:   5 .shstrtab     0000002d 0000000000000000
 # KEEP-AT-FIRST-NEXT:   6 .strtab       00000012 0000000000000000
 
 ## The same, but now section without KEEP is at first place.
 ## It will be collected then.
 ## This test checks that lld behavior is equal to gold linker.
 ## ld.bfd has different behavior, it prevents the section .keep
 ## from collecting in this case either.
 # RUN: echo "SECTIONS { \
 # RUN:  .nokeep : { *(.keep) } \
 # RUN:  .keep : { KEEP(*(.keep)) }}" > %t.script
 # RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | \
 # RUN:   FileCheck -check-prefix=KEEP-AT-SECOND %s
 # KEEP-AT-SECOND:      Sections:
 # KEEP-AT-SECOND-NEXT:  Idx Name          Size      Address         Type
 # KEEP-AT-SECOND-NEXT:   0               00000000 0000000000000000
-# KEEP-AT-SECOND-NEXT:   1 .temp         00000004 0000000000010120 DATA
-# KEEP-AT-SECOND-NEXT:   2 .text         00000007 0000000000011000 TEXT DATA
+# KEEP-AT-SECOND-NEXT:   1 .temp         00000004 00000000000100e8 DATA
+# KEEP-AT-SECOND-NEXT:   2 .text         00000007 00000000000100ec TEXT DATA
 # KEEP-AT-SECOND-NEXT:   3 .symtab       00000048 0000000000000000
 # KEEP-AT-SECOND-NEXT:   4 .shstrtab     00000027 0000000000000000
 # KEEP-AT-SECOND-NEXT:   5 .strtab       0000000d 0000000000000000
 
 .global _start
 _start:
  mov temp, %eax
 
 .section .keep, "a"
 keep:
  .long 1
 
 .section .temp, "a"
 temp:
  .long 2

test/ELF/linkerscript-sections-padding.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Check that padding value works:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x112233445566778899 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: hexdump -C %t.out | FileCheck -check-prefix=YES %s
-# YES: 00000120  66 22 33 44 55 66 77 88 99 11 22 33 44 55 66 77
+# YES: 000000f0  66 22 33 44 55 66 77 88 99 11 22 33 44 55 66 77
 
 ## Confirming that address was correct:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =0x998877665544332211 }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: hexdump -C %t.out | FileCheck -check-prefix=YES2 %s
-# YES2: 00000120  66 88 77 66 55 44 33 22 11 99 88 77 66 55 44
+# YES2: 000000f0  66 88 77 66 55 44 33 22 11 99 88 77 66 55 44
 
 ## Default padding value is 0x00:
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: hexdump -C %t.out | FileCheck -check-prefix=NO %s
-# NO: 00000120  66 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# NO: 000000f0  66 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 
 ## Filler should be a hex value (1):
 # RUN: echo "SECTIONS { .mysec : { *(.mysec*) } =99 }" > %t.script
 # RUN: not ld.lld -o %t.out --script %t.script %t 2>&1 \
 # RUN:   | FileCheck --check-prefix=ERR %s
 # ERR: filler should be a hexadecimal value
 
 ## Filler should be a hex value (2):

test/ELF/wildcards.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 ## Default case: abc and abx included in text.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .abx) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 # SEC-DEFAULT:      Sections:
 # SEC-DEFAULT-NEXT: Idx Name          Size      Address          Type
 # SEC-DEFAULT-NEXT:   0               00000000 0000000000000000
-# SEC-DEFAULT-NEXT:   1 .text         00000008 0000000000011000 TEXT DATA
-# SEC-DEFAULT-NEXT:   2 .abcd         00000004 0000000000011008 TEXT DATA
-# SEC-DEFAULT-NEXT:   3 .ad           00000004 000000000001100c TEXT DATA 
-# SEC-DEFAULT-NEXT:   4 .ag           00000004 0000000000011010 TEXT DATA 
-# SEC-DEFAULT-NEXT:   5 .symtab       00000030 0000000000000000 
-# SEC-DEFAULT-NEXT:   6 .shstrtab     0000002f 0000000000000000 
-# SEC-DEFAULT-NEXT:   7 .strtab       00000008 0000000000000000 
+# SEC-DEFAULT-NEXT:   1 .text         00000008 00000000000100e8 TEXT DATA
+# SEC-DEFAULT-NEXT:   2 .abcd         00000004 00000000000100f0 TEXT DATA
+# SEC-DEFAULT-NEXT:   3 .ad           00000004 00000000000100f4 TEXT DATA
+# SEC-DEFAULT-NEXT:   4 .ag           00000004 00000000000100f8 TEXT DATA
+# SEC-DEFAULT-NEXT:   5 .symtab       00000030 0000000000000000
+# SEC-DEFAULT-NEXT:   6 .shstrtab     0000002f 0000000000000000
+# SEC-DEFAULT-NEXT:   7 .strtab       00000008 0000000000000000
 
 ## Now replace the symbol with '?' and check that results are the same.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab?) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-DEFAULT %s
 
 ## Now see how replacing '?' with '*' will consume whole abcd.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.abc .ab*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-ALL %s
 # SEC-ALL:      Sections:
 # SEC-ALL-NEXT: Idx Name          Size      Address          Type
 # SEC-ALL-NEXT:   0               00000000 0000000000000000
-# SEC-ALL-NEXT:   1 .text         0000000c 0000000000011000 TEXT DATA
-# SEC-ALL-NEXT:   2 .ad           00000004 000000000001100c TEXT DATA 
-# SEC-ALL-NEXT:   3 .ag           00000004 0000000000011010 TEXT DATA 
-# SEC-ALL-NEXT:   4 .symtab       00000030 0000000000000000 
-# SEC-ALL-NEXT:   5 .shstrtab     00000029 0000000000000000 
-# SEC-ALL-NEXT:   6 .strtab       00000008 0000000000000000 
+# SEC-ALL-NEXT:   1 .text         0000000c 00000000000100e8 TEXT DATA
+# SEC-ALL-NEXT:   2 .ad           00000004 00000000000100f4 TEXT DATA
+# SEC-ALL-NEXT:   3 .ag           00000004 00000000000100f8 TEXT DATA
+# SEC-ALL-NEXT:   4 .symtab       00000030 0000000000000000
+# SEC-ALL-NEXT:   5 .shstrtab     00000029 0000000000000000
+# SEC-ALL-NEXT:   6 .strtab       00000008 0000000000000000
 
 ## All sections started with .a are merged.
 # RUN: echo "SECTIONS { \
 # RUN:      .text : { *(.a*) } }" > %t.script
 # RUN: ld.lld -o %t.out --script %t.script %t
 # RUN: llvm-objdump -section-headers %t.out | \
 # RUN:   FileCheck -check-prefix=SEC-NO %s
 # SEC-NO: Sections:
 # SEC-NO-NEXT: Idx Name          Size      Address          Type
-# SEC-NO-NEXT:   0               00000000 0000000000000000 
-# SEC-NO-NEXT:   1 .text         00000014 0000000000011000 TEXT DATA 
-# SEC-NO-NEXT:   2 .symtab       00000030 0000000000000000 
-# SEC-NO-NEXT:   3 .shstrtab     00000021 0000000000000000 
-# SEC-NO-NEXT:   4 .strtab       00000008 0000000000000000 
+# SEC-NO-NEXT:   0               00000000 0000000000000000
+# SEC-NO-NEXT:   1 .text         00000014 00000000000100e8 TEXT DATA
+# SEC-NO-NEXT:   2 .symtab       00000030 0000000000000000
+# SEC-NO-NEXT:   3 .shstrtab     00000021 0000000000000000
+# SEC-NO-NEXT:   4 .strtab       00000008 0000000000000000
 
 .text
 .section .abc,"ax",@progbits
 .long 0
 
 .text
 .section .abx,"ax",@progbits
 .long 0