Fix corner cases of setting the section address

[• rafael]

Summary

This is based on and an alternative to D27613.

It handles all the corner cases if setting a section address:

• If the address is too low, we cannot allocate the program headers.
• If the load address is lowered, we have to do that before finalize

This also shares some code with the linker script since it was already hitting similar cases.

This is used by the freebsd boot loader. It is not clear if we need to support this with a non binary output, but it is not as bad as I was expecting.

[grimar]

I am happy, looks this just works. (with nit)

lld/ELF/Writer.cpp

1729

Please remove argument names here and below:

elf::allocateHeaders<ELF32LE>(MutableArrayRef<PhdrEntry>,
                              ArrayRef<OutputSectionBase *>);

[grimar]

That was already landed in r290136, thanks for doing this patch, Rafael !

lld/ELF/LinkerScript.cpp

void LinkerScript<ELFT>::assignAddresses(std::vector<PhdrEntry> &Phdrs) {
   for (OutputSectionBase *Sec : *OutputSections) {
     if (Sec->Flags & SHF_ALLOC)
       MinVA = std::min<uint64_t>(MinVA, Sec->Addr);
     else
       Sec->Addr = 0;
   }
 
   uintX_t HeaderSize = getHeaderSize();
-  auto FirstPTLoad =
-      std::find_if(Phdrs.begin(), Phdrs.end(),
-                   [](const PhdrEntry &E) { return E.p_type == PT_LOAD; });
-  if (FirstPTLoad == Phdrs.end())
-    return;
-
   // If the linker script doesn't have PHDRS, add ElfHeader and ProgramHeaders
   // now that we know we have space.
-  if (HeaderSize <= MinVA && !hasPhdrsCommands()) {
-    FirstPTLoad->First = Out<ELFT>::ElfHeader;
-    if (!FirstPTLoad->Last)
-      FirstPTLoad->Last = Out<ELFT>::ProgramHeaders;
-  }
+  if (HeaderSize <= MinVA && !hasPhdrsCommands())
+    allocateHeaders<ELFT>(Phdrs, *OutputSections);
 
   // ELF and Program headers need to be right before the first section in
   // memory. Set their addresses accordingly.
   MinVA = alignDown(MinVA - HeaderSize, Config->MaxPageSize);
   Out<ELFT>::ElfHeader->Addr = MinVA;
   Out<ELFT>::ProgramHeaders->Addr = Out<ELFT>::ElfHeader->Size + MinVA;
 }
 

lld/ELF/Writer.h

 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_WRITER_H
 #define LLD_ELF_WRITER_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <memory>
 
 namespace lld {
 namespace elf {
 class InputFile;
 class OutputSectionBase;
struct PhdrEntry {
 
   OutputSectionBase *First = nullptr;
   OutputSectionBase *Last = nullptr;
   bool HasLMA = false;
 };
 
 llvm::StringRef getOutputSectionName(llvm::StringRef Name);
 
+template <class ELFT>
+void allocateHeaders(llvm::MutableArrayRef<PhdrEntry> Phdrs,
+                     llvm::ArrayRef<OutputSectionBase *> OutputSections);
 template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
 std::string getErrorLocation(uint8_t *Loc);
 }
 }
 
 #endif

lld/ELF/Writer.cpp

private:
   void addStartStopSymbols(OutputSectionBase *Sec);
   uintX_t getEntryAddr();
   OutputSectionBase *findSection(StringRef Name);
 
   std::vector<PhdrEntry> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
+  bool AllocateHeader = true;
 };
 } // anonymous namespace
 
 StringRef elf::getOutputSectionName(StringRef Name) {
   if (Config->Relocatable)
     return Name;
 
   for (StringRef V :
template <class ELFT> void Writer<ELFT>::run() {
   // finalizeSections does that.
   finalizeSections();
   if (ErrorCount)
     return;
 
   if (Config->Relocatable) {
     assignFileOffsets();
   } else {
-    // Binary output does not have PHDRS.
-    if (!Config->OFormatBinary) {
-      Phdrs = Script<ELFT>::X->hasPhdrsCommands()
-                  ? Script<ELFT>::X->createPhdrs()
-                  : createPhdrs();
-      addPtArmExid(Phdrs);
-      fixHeaders();
-    }
-
     if (ScriptConfig->HasSections) {
       Script<ELFT>::X->assignAddresses(Phdrs);
     } else {
       fixSectionAlignments();
       assignAddresses();
     }
 
     // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
static bool compareSectionsNonScript(const OutputSectionBase *A,
   if (AIsAlloc != BIsAlloc)
     return AIsAlloc;
 
   // We don't have any special requirements for the relative order of two non
   // allocatable sections.
   if (!AIsAlloc)
     return false;
 
+  // We want to put section specified by -T option first, so we
+  // can start assigning VA starting from them later.
+  auto AAddrSetI = Config->SectionStartMap.find(A->getName());
+  auto BAddrSetI = Config->SectionStartMap.find(B->getName());
+  bool AHasAddrSet = AAddrSetI != Config->SectionStartMap.end();
+  bool BHasAddrSet = BAddrSetI != Config->SectionStartMap.end();
+  if (AHasAddrSet != BHasAddrSet)
+    return AHasAddrSet;
+  if (AHasAddrSet)
+    return AAddrSetI->second < BAddrSetI->second;
+
   // We want the read only sections first so that they go in the PT_LOAD
   // covering the program headers at the start of the file.
   bool AIsWritable = A->Flags & SHF_WRITE;
   bool BIsWritable = B->Flags & SHF_WRITE;
   if (AIsWritable != BIsWritable)
     return BIsWritable;
 
   if (!Config->SingleRoRx) {
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   sortSections();
 
   unsigned I = 1;
   for (OutputSectionBase *Sec : OutputSections) {
     Sec->SectionIndex = I++;
     Sec->ShName = In<ELFT>::ShStrTab->addString(Sec->getName());
   }
 
+  // Binary and relocatable output does not have PHDRS.
+  // The headers have to be created before finalize as that can influence the
+  // image base and the dynamic section on mips includes the image base.
+  if (!Config->Relocatable && !Config->OFormatBinary) {
+    Phdrs = Script<ELFT>::X->hasPhdrsCommands() ? Script<ELFT>::X->createPhdrs()
+                                                : createPhdrs();
+    addPtArmExid(Phdrs);
+    fixHeaders();
+  }
+
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
   for (OutputSectionBase *Sec : OutputSections)
     Sec->finalize();
 
   // Dynamic section must be the last one in this list and dynamic
   // symbol table section (DynSymTab) must be the first one.
template <class ELFT> std::vector<PhdrEntry> Writer<ELFT>::createPhdrs() {
   if (OutputSectionBase *Sec = findSection(".interp")) {
     PhdrEntry &Hdr = *AddHdr(PT_INTERP, Sec->getPhdrFlags());
     Hdr.add(Sec);
   }
 
   // Add the first PT_LOAD segment for regular output sections.
   uintX_t Flags = computeFlags<ELFT>(PF_R);
   PhdrEntry *Load = AddHdr(PT_LOAD, Flags);
-  if (!ScriptConfig->HasSections) {
-    Load->add(Out<ELFT>::ElfHeader);
-    Load->add(Out<ELFT>::ProgramHeaders);
-  }
 
   PhdrEntry TlsHdr(PT_TLS, PF_R);
   PhdrEntry RelRo(PT_GNU_RELRO, PF_R);
   PhdrEntry Note(PT_NOTE, PF_R);
   for (OutputSectionBase *Sec : OutputSections) {
     if (!(Sec->Flags & SHF_ALLOC))
       break;
 
void Writer<ELFT>::addPtArmExid(std::vector<PhdrEntry> &Phdrs) {
   ARMExidx.add(*I);
   Phdrs.push_back(ARMExidx);
 }
 
 // The first section of each PT_LOAD and the first section after PT_GNU_RELRO
 // have to be page aligned so that the dynamic linker can set the permissions.
 template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
   for (const PhdrEntry &P : Phdrs)
-    if (P.p_type == PT_LOAD)
+    if (P.p_type == PT_LOAD && P.First)
       P.First->PageAlign = true;
 
   for (const PhdrEntry &P : Phdrs) {
     if (P.p_type != PT_GNU_RELRO)
       continue;
     // Find the first section after PT_GNU_RELRO. If it is in a PT_LOAD we
     // have to align it to a page.
     auto End = OutputSections.end();
     auto I = std::find(OutputSections.begin(), End, P.Last);
     if (I == End || (I + 1) == End)
       continue;
     OutputSectionBase *Sec = *(I + 1);
     if (needsPtLoad<ELFT>(Sec))
       Sec->PageAlign = true;
   }
 }
 
+template <class ELFT>
+void elf::allocateHeaders(MutableArrayRef<PhdrEntry> Phdrs,
+                          ArrayRef<OutputSectionBase *> OutputSections) {
+  auto FirstPTLoad =
+      std::find_if(Phdrs.begin(), Phdrs.end(),
+                   [](const PhdrEntry &E) { return E.p_type == PT_LOAD; });
+  if (FirstPTLoad == Phdrs.end())
+    return;
+  if (FirstPTLoad->First)
+    for (OutputSectionBase *Sec : OutputSections)
+      if (Sec->FirstInPtLoad == FirstPTLoad->First)
+        Sec->FirstInPtLoad = Out<ELFT>::ElfHeader;
+  FirstPTLoad->First = Out<ELFT>::ElfHeader;
+  if (!FirstPTLoad->Last)
+    FirstPTLoad->Last = Out<ELFT>::ProgramHeaders;
+}
+
 // 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 HeaderSize = getHeaderSize<ELFT>();
+  // When -T<section> option is specified, lower the base to make room for those
+  // sections.
+  if (!Config->SectionStartMap.empty()) {
+    uint64_t Min = -1;
+    for (const auto &P : Config->SectionStartMap)
+      Min = std::min(Min, P.second);
+    if (HeaderSize < Min)
+      Min -= HeaderSize;
+    else
+      AllocateHeader = false;
+    if (Min < Config->ImageBase)
+      Config->ImageBase = alignDown(Min, Config->MaxPageSize);
+  }
+
+  if (AllocateHeader)
+    allocateHeaders<ELFT>(Phdrs, OutputSections);
+
   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 VA = Config->ImageBase;
+  if (AllocateHeader)
+    VA += 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())
std::string elf::getErrorLocation(uint8_t *Loc) {
   }
 }
 
 template void elf::writeResult<ELF32LE>();
 template void elf::writeResult<ELF32BE>();
 template void elf::writeResult<ELF64LE>();
 template void elf::writeResult<ELF64BE>();
 
+template void
+elf::allocateHeaders<ELF32LE>(MutableArrayRef<PhdrEntry> Phdrs,
+                              ArrayRef<OutputSectionBase *> OutputSections);
+template void
+elf::allocateHeaders<ELF32BE>(MutableArrayRef<PhdrEntry> Phdrs,
+                              ArrayRef<OutputSectionBase *> OutputSections);
+template void
+elf::allocateHeaders<ELF64LE>(MutableArrayRef<PhdrEntry> Phdrs,
+                              ArrayRef<OutputSectionBase *> OutputSections);
+template void
+elf::allocateHeaders<ELF64BE>(MutableArrayRef<PhdrEntry> Phdrs,
+                              ArrayRef<OutputSectionBase *> OutputSections);
+
 template bool elf::isRelroSection<ELF32LE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF32BE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF64LE>(const OutputSectionBase *);
 template bool elf::isRelroSection<ELF64BE>(const OutputSectionBase *);
 
 template void elf::reportDiscarded<ELF32LE>(InputSectionBase<ELF32LE> *);
 template void elf::reportDiscarded<ELF32BE>(InputSectionBase<ELF32BE> *);
 template void elf::reportDiscarded<ELF64LE>(InputSectionBase<ELF64LE> *);
 template void elf::reportDiscarded<ELF64BE>(InputSectionBase<ELF64BE> *);

lld/test/ELF/ttext-tdata-tbss.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+
+## Show what regular output gives to us.
+# RUN: ld.lld %t.o -o %t1
+# RUN: llvm-readobj --elf-output-style=GNU -l -s  %t1 | FileCheck %s
+# CHECK:      .rodata   PROGBITS 0000000000200158 000158 000008
+# CHECK-NEXT: .text     PROGBITS 0000000000201000 001000 000001
+# CHECK-NEXT: .aw       PROGBITS 0000000000202000 002000 000008
+# CHECK-NEXT: .data     PROGBITS 0000000000202008 002008 000008
+# CHECK-NEXT: .bss      NOBITS   0000000000202010 002010 000008
+# CHECK:      PHDR
+# CHECK-NEXT: LOAD 0x000000 0x0000000000200000
+
+## With .text at 0 there is no space to allocate the headers.
+# RUN: ld.lld -Ttext 0x0 -Tdata 0x4000 -Tbss 0x8000 %t.o -o %t2
+# RUN: llvm-readobj --elf-output-style=GNU -l -s %t2 | FileCheck %s --check-prefix=USER1
+# USER1:      .text   PROGBITS 0000000000000000 001000 000001
+# USER1-NEXT: .data   PROGBITS 0000000000004000 002000 000008
+# USER1-NEXT: .bss    NOBITS   0000000000008000 002008 000008
+# USER1-NEXT: .rodata PROGBITS 0000000000009000 003000 000008
+# USER1-NEXT: .aw     PROGBITS 000000000000a000 004000 000008
+# USER1:      PHDR
+# USER1-NEXT: LOAD 0x001000 0x0000000000000000
+
+## With .text at 0x1000 there is space to allocate the headers.
+# RUN: ld.lld -Ttext 0x1000 -Tdata 0x4000 -Tbss 0x8000 %t.o -o %t3
+# RUN: llvm-readobj --elf-output-style=GNU -l -s  %t3 | FileCheck %s --check-prefix=USER2
+# USER2:      .text   PROGBITS 0000000000001000 001000 000001
+# USER2-NEXT: .data   PROGBITS 0000000000004000 002000 000008
+# USER2-NEXT: .bss    NOBITS   0000000000008000 002008 000008
+# USER2-NEXT: .rodata PROGBITS 0000000000009000 003000 000008
+# USER2-NEXT: .aw     PROGBITS 000000000000a000 004000 000008
+# USER2:      PHDR
+# USER2-NEXT: LOAD 0x000000 0x0000000000000000
+
+## With .text well above 200000 we don't need to change the image base
+# RUN: ld.lld -Ttext 0x201000 %t.o -o %t4
+# RUN: llvm-readobj --elf-output-style=GNU -l -s %t4 | FileCheck %s --check-prefix=USER3
+# USER3:     .text   PROGBITS 0000000000201000 001000 000001
+# USER3-NEX: .rodata PROGBITS 0000000000202000 002000 000008
+# USER3-NEX: .aw     PROGBITS 0000000000203000 003000 000008
+# USER3-NEX: .data   PROGBITS 0000000000203008 003008 000008
+# USER3-NEX: .bss    NOBITS   0000000000203010 003010 000008
+# USER3:      PHDR
+# USER3-NEXT: LOAD 0x000000 0x0000000000200000
+
+.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