[ELF] - Separate assignAddressesScript method

[grimar]

Summary

This adds assignAddressesScript method as separate one.
It is used when script is present.

[grimar]

ELF/Writer.cpp

1465

What is changed here in compare with assignAddresses() is:

1. There is no PageAlign relative stuff
2. uintX_t VA = 0

[ruiu]

The new code is mostly copy of the old code, so it would make the situation worse. The common part needs to be factored out instead of copying it.

[grimar]

• Trying to address review comments :)

[grimar]

In D18591#387126, @ruiu wrote:

The new code is mostly copy of the old code, so it would make the situation worse. The common part needs to be factored out instead of copying it.

Something like that ?

[ruiu]

ELF/Writer.cpp

1413–1423

This default behavior needs to be removed because all addresses are given by a linker script, no?

1430–1432

This is duplicate.

1434

Move this function call to Writer::run().

[grimar]

ELF/Writer.cpp

1413–1423

That abstract Script->getSectionVA(Sec->getName()) function we discussed earlier today not exist yet, no ?
So this logic like a stub now.

If we remove it now then all VA will be 0 ? Do you mean do that for now ?

1430–1432

I know that is. Create one more method to move next code out ?

// Add space for section headers.
  SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
  FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);

  // Update "_end" and "end" symbols so that they
  // point to the end of the data segment.
  ElfSym<ELFT>::End.st_value = VA;

I did not moved it out to assignPhdrs() because assignPhdrs is not a good name for that IMO.

[ruiu]

ELF/Writer.cpp

1413–1423

You are not going to submit this without the other patches, right? I'd update this patch so that if I apply all patches to my local repository, I'd get the new code of the final form.

1430–1432

Is there any way to move this piece of code to fixAbsoluteSymbols? I don't think the last address of the image is available only here.

Also, not directly related to this patch, but the comment "they point to the end of the data segment" is incorrect. They point to the end of image in memory.

[grimar]

Will do several little patches instead of this one.

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

private:
   void scanRelocs(InputSectionBase<ELFT> &C,
                   iterator_range<const RelTy *> Rels);
 
   void scanRelocs(InputSection<ELFT> &C);
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
   void createPhdrs();
   void assignAddresses();
   void assignAddressesRelocatable();
+  void assignAddressesScript();
+
+  void assignPhdrs();
+
   void fixAbsoluteSymbols();
   bool openFile();
   void writeHeader();
   void writeSections();
   void writeBuildId();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
   StringRef getOutputSectionName(InputSectionBase<ELFT> *S) const;
   bool needsInterpSection() const {

 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   addReservedSymbols();
   if (!createSections())
     return;
-  if (!Config->Relocatable) {
+
+  if (!Config->Relocatable)
     createPhdrs();
-    assignAddresses();
-  } else {
+
+  if (Script->Exist)
+    assignAddressesScript();
+  else if (Config->Relocatable)
     assignAddressesRelocatable();
-  }
+  else
+    assignAddresses();
+
   fixAbsoluteSymbols();
   if (!openFile())
     return;
   writeHeader();
   writeSections();
   writeBuildId();
   if (HasError)
     return;
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   // Add space for section headers.
   SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 
   // Update "_end" and "end" symbols so that they
   // point to the end of the data segment.
   ElfSym<ELFT>::End.st_value = VA;
 
+  assignPhdrs();
+}
+
+template <class ELFT> void Writer<ELFT>::assignAddressesScript() {
+  Out<ELFT>::ElfHeader->setSize(sizeof(Elf_Ehdr));
+  size_t PhdrSize = sizeof(Elf_Phdr) * Phdrs.size();
+  Out<ELFT>::ProgramHeaders->setSize(PhdrSize);
+
+  uintX_t ThreadBssOffset = 0;
+  uintX_t VA = 0;
+  uintX_t FileOff = 0;
+
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    uintX_t Align = Sec->getAlign();
+    if (Sec->getType() != SHT_NOBITS)
+      FileOff = alignTo(FileOff, Align);
+    Sec->setFileOffset(FileOff);
+    if (Sec->getType() != SHT_NOBITS)
+      FileOff += Sec->getSize();
+
+    // We only assign VAs to allocated sections.
+    if (needsPtLoad<ELFT>(Sec)) {
+      VA = alignTo(VA, Align);
+      Sec->setVA(VA);
+      VA += Sec->getSize();
+    } else if (Sec->getFlags() & SHF_TLS && Sec->getType() == SHT_NOBITS) {
+      uintX_t TVA = VA + ThreadBssOffset;
+      TVA = alignTo(TVA, Align);
+      Sec->setVA(TVA);
+      ThreadBssOffset = TVA - VA + Sec->getSize();
+    }
+  }
+
+  // Add space for section headers.
+  SectionHeaderOff = alignTo(FileOff, sizeof(uintX_t));
+  FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
+
+  // Update "_end" and "end" symbols so that they
+  // point to the end of the data segment.
+  ElfSym<ELFT>::End.st_value = VA;
+
+  assignPhdrs();
+}
+
+template <class ELFT> void Writer<ELFT>::assignPhdrs() {
   for (Phdr &PHdr : Phdrs) {
     Elf_Phdr &H = PHdr.H;
     if (PHdr.First) {
       OutputSectionBase<ELFT> *Last = PHdr.Last;
       H.p_filesz = Last->getFileOff() - PHdr.First->getFileOff();
       if (Last->getType() != SHT_NOBITS)
         H.p_filesz += Last->getSize();
       H.p_memsz = Last->getVA() + Last->getSize() - PHdr.First->getVA();
for (Phdr &PHdr : Phdrs) {
     if (H.p_type == PT_TLS) {
       Out<ELFT>::TlsPhdr = &H;
       H.p_memsz = alignTo(H.p_memsz, H.p_align);
     }
   }
 }
 
 static uint32_t getMipsEFlags() {
   // FIXME: In fact ELF flags depends on ELF flags of input object files
   // and selected emulation. For now just use hard coded values.
   uint32_t V = EF_MIPS_ABI_O32 | EF_MIPS_CPIC | EF_MIPS_ARCH_32R2;
   if (Config->Shared)
     V |= EF_MIPS_PIC;
   return V;
 }
 
 template <class ELFT> static typename ELFT::uint getEntryAddr() {

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: 0x159
 // NOBSS-NEXT:     Offset:
 // NOBSS-NEXT:     Size: 2
 // NOBSS: ]
 // NOBSS: Symbols [
 // NOBSS:     Name: _end
-// NOBSS-NEXT:     Value: 0x12002
+// NOBSS-NEXT:     Value: 0x15B
 // 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: 0x160
 // TEXTATEND-NEXT:     Offset:
 // TEXTATEND-NEXT:     Size: 1
 // TEXTATEND: ]
 // TEXTATEND: Symbols [
 // TEXTATEND:     Name: _end
-// TEXTATEND-NEXT:     Value: 0x12001
+// TEXTATEND-NEXT:     Value: 0x161
 // TEXTATEND: ]
 
 .global _start,_end
 .text
 _start:
     nop
 .data
     .word 1
 .bss
     .space 6

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 0000000000000158 TEXT DATA
+# SECGC-NEXT:   2 .temp         00000004 000000000000015f 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 0000000000000158 TEXT DATA
+# SECNOGC-NEXT:   2 .keep         00000004 000000000000015f DATA
+# SECNOGC-NEXT:   3 .temp         00000004 0000000000000163 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 0000000000000120 DATA
+# KEEP-AT-FIRST-NEXT:   2 .temp         00000004 0000000000000124 DATA
+# KEEP-AT-FIRST-NEXT:   3 .text         00000007 0000000000000128 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 0000000000000120 DATA
+# KEEP-AT-SECOND-NEXT:   2 .text         00000007 0000000000000124 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-va.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -section-headers %t1 | FileCheck %s
+# CHECK:      Sections:
+# CHECK-NEXT: Idx Name          Size      Address          Type
+# CHECK-NEXT:   0               00000000 0000000000000000
+# CHECK-NEXT:   1 .foo          00000004 0000000000000120 DATA
+# CHECK-NEXT:   2 .boo          00000004 0000000000000124 DATA
+# CHECK-NEXT:   3 .text         00000001 0000000000000128 TEXT DATA
+
+.global _start
+_start:
+ nop
+
+.section .foo, "a"
+foo:
+ .long 0
+
+.section .boo, "a"
+boo:
+ .long 0

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:   1 .text         00000008 0000000000000120 TEXT DATA
+# SEC-DEFAULT-NEXT:   2 .abcd         00000004 0000000000000128 TEXT DATA
+# SEC-DEFAULT-NEXT:   3 .ad           00000004 000000000000012c TEXT DATA
+# SEC-DEFAULT-NEXT:   4 .ag           00000004 0000000000000130 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:   1 .text         0000000c 0000000000000120 TEXT DATA
+# SEC-ALL-NEXT:   2 .ad           00000004 000000000000012c TEXT DATA
+# SEC-ALL-NEXT:   3 .ag           00000004 0000000000000130 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:   1 .text         00000014 0000000000000120 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