[ELF] - Change how -Ttext/-Tdata/-Tbss works.

[grimar]

Summary

Previously user was unable to set -Ttext=0x0 for example,
it is PR31295. Result was a crash because of wrong calculation of file offsets offsets.
bfd sets the section address in that case, gold the segment address.

Patch implements bfd behavior, it places sections specified by -T* to be first in the load.
That way we can start assinging addresses from their VA and do not intersect with other sections.
Testcase shows what I mean.

[ruiu]

ELF/Driver.cpp

584–588

I do not get the meaning of this code. Can you give me an example?

ELF/Writer.cpp

1299–1308

What does this code do? Needs explanation.

1310

You shouldn't compute the same value twice. Use the previous result instead.

1353–1357

This seems too tricky. Is there any better way?

[grimar]

• Addressed review comments.

ELF/Driver.cpp

584–588

Sure, simplified from testcases, imagine we have next code:

.text
.globl _start
_start:
 nop

.section .rodata,"a"
 .quad 0

We have next loads then: R (headers, .rodata), RX(.text), RW(.data).
In that case if user gives -Ttext=0x0 we want to set .text VA to that value.
gnu linkers does not apply -rosegment by default how we do.
We want to do that It think because otherwise there is no easy way to make .text to have -Ttext VA.

After applying my lines we have: RX (headers, .rodata, .text), RO(.data). So We can place .text
to be first section and assign VA starting from it.

ELF/Writer.cpp

1299–1308

Moved to getImageBase(), added comment.

1353–1357

Correctness of that place is under discussions in llvm-mails at this moment, I leaved it as is for now.
If we deside to leave this logic, I can suggest just to move it upper as a "better way":

if (!Config->SectionStartMap.empty())
  return Off;

That is a bit simpler though does not align file offset for data segment. I do not know if that is important.
bfd ignores aligning for text segment, I guess we can do the same for .data as well then.

Another way can probably be:

if (First->Addr > Sec->Addr)
  return Off;
return First->Offset + Sec->Addr - First->Addr;

That should keep consistency with bfd here.

[grimar]

r290136 committed instead.

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   // create special-purpose programs such as boot loaders. It doesn't
   // make sense to create PT_GNU_RELRO for such executables.
   if (Config->OMagic)
     Config->ZRelro = false;
 
   if (!Config->Relocatable)
     Config->Strip = getStripOption(Args);
 
+  // When user gives -Ttext/-Tdata/-Tbss GNU linkers either set addresses
+  // of corresponding sections or addressed for PT_LOADs. That means we want
+  // to have "text segment" to work with. It includes RO sections as well.
+  if (!Config->SectionStartMap.empty())
+    Config->SingleRoRx = true;
+
   // Config->Pic is true if we are generating position-independent code.
   Config->Pic = Config->Pie || Config->Shared;
 
   if (auto *Arg = Args.getLastArg(OPT_hash_style)) {
     StringRef S = Arg->getValue();
     if (S == "gnu") {
       Config->GnuHash = true;
       Config->SysvHash = false;
uint64_t Val =
       getZOptionValue(Args, "max-page-size", Target->DefaultMaxPageSize);
   if (!isPowerOf2_64(Val))
     error("max-page-size: value isn't a power of 2");
   return Val;
 }
 
 // Parses -image-base option.
 static uint64_t getImageBase(opt::InputArgList &Args) {
+  // When -T<section> option is specified, lowest VA value
+  // becomes the image base address.
+  if (!Config->SectionStartMap.empty()) {
+    uint64_t VA = (uint64_t)-1;
+    for (auto I = Config->SectionStartMap.begin();
+         I != Config->SectionStartMap.end(); ++I) {
+      if (VA > I->second)
+        VA = I->second;
+    }
+    return VA;
+  }
+
   // Use default if no -image-base option is given.
   // Because we are using "Target" here, this function
   // has to be called after the variable is initialized.
   auto *Arg = Args.getLastArg(OPT_image_base);
   if (!Arg)
     return Config->Pic ? 0 : Target->DefaultImageBase;
 
   StringRef S = Arg->getValue();

ELF/Writer.cpp

static bool compareSectionsNonScript(const OutputSectionBase *A,
   // them is a p_memsz that is larger than p_filesz. Seeing that it
   // zeros the end of the PT_LOAD, so that has to correspond to the
   // nobits sections.
   bool AIsNoBits = A->Type == SHT_NOBITS;
   bool BIsNoBits = B->Type == SHT_NOBITS;
   if (AIsNoBits != BIsNoBits)
     return BIsNoBits;
 
+  // We want to put section specified by -T option first, so we
+  // can start assigning VA starting from them later.
+  bool AHasAddrSet = Config->SectionStartMap.count(A->getName());
+  bool BHasAddrSet = Config->SectionStartMap.count(B->getName());
+  if (AHasAddrSet != BHasAddrSet)
+    return AHasAddrSet;
+
   // We place RelRo section before plain r/w ones.
   bool AIsRelRo = isRelroSection<ELFT>(A);
   bool BIsRelRo = isRelroSection<ELFT>(B);
   if (AIsRelRo != BIsRelRo)
     return AIsRelRo;
 
   // Some architectures have additional ordering restrictions for sections
   // within the same PT_LOAD.
if (needsPtLoad<ELFT>(Sec))
       Sec->PageAlign = true;
   }
 }
 
 // We should set file offsets and VAs for elf header and program headers
 // sections. These are special, we do not include them into output sections
 // list, but have them to simplify the code.
 template <class ELFT> void Writer<ELFT>::fixHeaders() {
   Out<ELFT>::ProgramHeaders->Size = sizeof(Elf_Phdr) * Phdrs.size();
   // If the script has SECTIONS, assignAddresses will compute the values.
   if (ScriptConfig->HasSections)
     return;
   uintX_t BaseVA = Config->ImageBase;
   Out<ELFT>::ElfHeader->Addr = BaseVA;
   Out<ELFT>::ProgramHeaders->Addr = BaseVA + Out<ELFT>::ElfHeader->Size;
 }
 
 // Assign VAs (addresses at run-time) to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = Config->ImageBase + getHeaderSize<ELFT>();
   uintX_t ThreadBssOffset = 0;
   for (OutputSectionBase *Sec : OutputSections) {
     uintX_t Alignment = Sec->Addralign;
     if (Sec->PageAlign)
       Alignment = std::max<uintX_t>(Alignment, Config->MaxPageSize);
 
     auto I = Config->SectionStartMap.find(Sec->getName());
     if (I != Config->SectionStartMap.end())
static uintX_t getFileAlignment(uintX_t Off, OutputSectionBase *Sec) {
 
   // The first section in a PT_LOAD has to have congruent offset and address
   // module the page size.
   if (Sec == First)
     return alignTo(Off, Config->MaxPageSize, Sec->Addr);
 
   // If two sections share the same PT_LOAD the file offset is calculated
   // using this formula: Off2 = Off1 + (VA2 - VA1).
-  return First->Offset + Sec->Addr - First->Addr;
+  // We take max value here for case when user set VA of section using -T
+  // below address of headers. We do not align offsets then, that is
+  // consistent with bfd behavior.
+  return std::max<uintX_t>(Off, First->Offset + Sec->Addr - First->Addr);
 }
 
 template <class ELFT, class uintX_t>
 void setOffset(OutputSectionBase *Sec, uintX_t &Off) {
   if (Sec->Type == SHT_NOBITS) {
     Sec->Offset = Off;
     return;
   }
 

test/ELF/ttext-tdata-tbss.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## Show what regular output gives to us.
+# RUN: ld.lld %t -o %t1
+# 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 .rodata       00000008 0000000000200158 DATA
+# CHECK-NEXT:   2 .text         00000001 0000000000201000 TEXT DATA
+# CHECK-NEXT:   3 .aw           00000008 0000000000202000 DATA
+# CHECK-NEXT:   4 .data         00000008 0000000000202008 DATA
+# CHECK-NEXT:   5 .bss          00000008 0000000000202010 BSS
+
+## Check that user can assing addressed for sections using -T option.
+# RUN: ld.lld -Ttext 0x0 -Tdata 0x2000 -Tbss 0x4000 %t -o %t1
+# RUN: llvm-objdump -section-headers %t1 | FileCheck %s --check-prefix=USERADDR
+# USERADDR:      Sections:
+# USERADDR-NEXT: Idx Name          Size      Address          Type
+# USERADDR-NEXT:   0               00000000 0000000000000000
+# USERADDR-NEXT:   1 .text         00000001 0000000000000000 TEXT DATA
+# USERADDR-NEXT:   2 .rodata       00000008 0000000000000001 DATA
+# USERADDR-NEXT:   3 .data         00000008 0000000000002000 DATA
+# USERADDR-NEXT:   4 .aw           00000008 0000000000002008 DATA
+# USERADDR-NEXT:   5 .bss          00000008 0000000000004000 BSS
+
+.text
+.globl _start
+_start:
+ nop
+
+.section .rodata,"a"
+ .quad 0
+
+.section .aw,"aw"
+ .quad 0
+
+.section .data,"aw"
+ .quad 0
+
+.section .bss,"",@nobits
+ .quad 0