[ELF] Allow redefining LMA for a section inside a segment.

[ikudrin]

Summary

We have a constraint that all sections within a segment have the same difference between LMA and VMA.
If we encounter a section with a customized LMA, we might create a new segment, but not in the case
when all program headers are explicitly defined by a linker script. In that case, the setting is just ignored.

This patch allows sections within one segment to have different LMA offsets. The behavior is similar to GNU ld's.

The patch, technically, reverts r323456 and fixes PR36017 in a different. way.

[ikudrin]

• Adjust to the tip.

[ruiu]

The ELF spec [1] requires that "loadable process segments must have congruent values for p_vaddr and p_offset, modulo the page size." Doesn't the executable produced with this patch violate that rule?

[1] http://www.skyfree.org/linux/references/ELF_Format.pdf p. 2

[ikudrin]

It's not for an application. We use it for a kernel image.

[ruiu]

Do you need to create an ELF file that doesn't fully comply with the spec?

[ikudrin]

I don't see anything that violates the specs. With this patch, the offset of a segment (p_offset) is still congruent to its virtual address (p_vaddr), modulo page size. This rule is enforced in lines 1850-1852 of ELF/Writer.cpp:

if (Cmd == First)
  return alignTo(Off, std::max<uint64_t>(Cmd->Alignment, Config->MaxPageSize),
                 Cmd->Addr);

and I didn't touch them.

The description for AT output section attribute says that it defines a load address of the section and that this feature is designed to simplify creating a ROM image. This is exactly what we use it for. https://sourceware.org/binutils/docs/ld/Output-Section-LMA.html

If there are no prescribed program headers in a linker script, the linker creates a new segment on each section with customized LMA, and this is OK and expected (D43284). But in case of explicitly defined segments, we, in fact, ignore some of AT directives. And this contradicts the user's intention.

ELF/LinkerScript.cpp

void LinkerScript::assignOffsets(OutputSection *Sec) {
 
   if (MemoryRegion *MR = Sec->LMARegion)
     Ctx->LMAOffset = MR->CurPos - Dot;
 
   // If neither AT nor AT> is specified for an allocatable section, the linker
   // will set the LMA such that the difference between VMA and LMA for the
   // section is the same as the preceding output section in the same region
   // https://sourceware.org/binutils/docs-2.20/ld/Output-Section-LMA.html
-  if (PhdrEntry *L = Ctx->OutSec->PtLoad)
-    L->LMAOffset = Ctx->LMAOffset;
+  if (Ctx->LMAOffset)
+    Ctx->OutSec->LMAOffset = Ctx->LMAOffset;
 
   // The Size previously denoted how many InputSections had been added to this
   // section, and was used for sorting SHF_LINK_ORDER sections. Reset it to
   // compute the actual size value.
   Sec->Size = 0;
 
   // We visited SectionsCommands from processSectionCommands to
   // layout sections. Now, we visit SectionsCommands again to fix
void LinkerScript::allocateHeaders(std::vector<PhdrEntry *> &Phdrs) {
   uint64_t HeaderSize = getHeaderSize();
   // When linker script with SECTIONS is being used, don't output headers
   // unless there's a space for them.
   uint64_t Base = HasSectionsCommand ? alignDown(Min, Config->MaxPageSize) : 0;
   if (HeaderSize <= Min - Base || Script->hasPhdrsCommands()) {
     Min = alignDown(Min - HeaderSize, Config->MaxPageSize);
     Out::ElfHeader->Addr = Min;
     Out::ProgramHeaders->Addr = Min + Out::ElfHeader->Size;
+    // Avoid creating a gap in the segment
+    // if the first section has a customized LMA.
+    if (OutputSection *FirstSec = findFirstSection(FirstPTLoad)) {
+      Out::ElfHeader->LMAOffset = FirstSec->LMAOffset;
+      Out::ProgramHeaders->LMAOffset = FirstSec->LMAOffset;
+    }
     return;
   }
 
   Out::ElfHeader->PtLoad = nullptr;
   Out::ProgramHeaders->PtLoad = nullptr;
   FirstPTLoad->FirstSec = findFirstSection(FirstPTLoad);
 
   llvm::erase_if(Phdrs,

ELF/OutputSections.h

public:
   OutputSection(StringRef Name, uint32_t Type, uint64_t Flags);
 
   static bool classof(const SectionBase *S) {
     return S->kind() == SectionBase::Output;
   }
 
   static bool classof(const BaseCommand *C);
 
-  uint64_t getLMA() const { return PtLoad ? Addr + PtLoad->LMAOffset : Addr; }
+  uint64_t getLMA() const { return Addr + LMAOffset; }
   template <typename ELFT> void writeHeaderTo(typename ELFT::Shdr *SHdr);
 
   unsigned SectionIndex;
   unsigned SortRank;
 
   uint32_t getPhdrFlags() const;
 
   // Pointer to the PT_LOAD segment, which this section resides in. This field
   // is used to correctly compute file offset of a section. When two sections
   // share the same load segment, difference between their file offsets should
-  // be equal to difference between their virtual addresses. To compute some
-  // section offset we use the following formula: Off = Off_first + VA -
-  // VA_first, where Off_first and VA_first is file offset and VA of first
+  // be equal to difference between their load addresses. To compute some
+  // section offset we use the following formula: Off = Off_first + LA -
+  // LA_first, where Off_first and LA_first is file offset and LA of first
   // section in PT_LOAD.
   PhdrEntry *PtLoad = nullptr;
 
   // Pointer to a relocation section for this section. Usually nullptr because
   // we consume relocations, but if --emit-relocs is specified (which is rare),
   // it may have a non-null value.
   OutputSection *RelocationSection = nullptr;
 
   // Initially this field is the number of InputSections that have been added to
   // the OutputSection so far. Later on, after a call to assignAddresses, it
   // corresponds to the Elf_Shdr member.
   uint64_t Size = 0;
 
   // The following fields correspond to Elf_Shdr members.
   uint64_t Offset = 0;
+  uint64_t LMAOffset = 0;
   uint64_t Addr = 0;
   uint32_t ShName = 0;
 
   void addSection(InputSection *IS);
 
   // Location in the output buffer.
   uint8_t *Loc = nullptr;
 

ELF/Writer.h

struct PhdrEntry {
   uint64_t p_offset = 0;
   uint32_t p_align = 0;
   uint32_t p_type = 0;
   uint32_t p_flags = 0;
 
   OutputSection *FirstSec = nullptr;
   OutputSection *LastSec = nullptr;
   bool HasLMA = false;
-
-  uint64_t LMAOffset = 0;
 };
 
 void addReservedSymbols();
 llvm::StringRef getOutputSectionName(InputSectionBase *S);
 
 template <class ELFT> uint32_t calcMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,

ELF/Writer.cpp

 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
 
 template <class ELFT> void Writer<ELFT>::removeEmptyPTLoad() {
   llvm::erase_if(Phdrs, [&](const PhdrEntry *P) {
     if (P->p_type != PT_LOAD)
       return false;
     if (!P->FirstSec)
       return true;
-    uint64_t Size = P->LastSec->Addr + P->LastSec->Size - P->FirstSec->Addr;
+    uint64_t Size =
+        P->LastSec->getLMA() + P->LastSec->Size - P->FirstSec->getLMA();
     return Size == 0;
   });
 }
 
 template <class ELFT> static void combineEhFrameSections() {
   for (InputSectionBase *&S : InputSections) {
     EhInputSection *ES = dyn_cast<EhInputSection>(S);
     if (!ES || !ES->Live)
static uint64_t getFileAlignment(uint64_t Off, OutputSection *Cmd) {
   if (Cmd->Type == SHT_NOBITS)
     return Off;
 
   // If the section is not in a PT_LOAD, we just have to align it.
   if (!Cmd->PtLoad)
     return alignTo(Off, Cmd->Alignment);
 
   // If two sections share the same PT_LOAD the file offset is calculated
-  // using this formula: Off2 = Off1 + (VA2 - VA1).
-  return First->Offset + Cmd->Addr - First->Addr;
+  // using this formula: Off2 = Off1 + (LMA2 - LMA1).
+  return First->Offset + Cmd->getLMA() - First->getLMA();
 }
 
 static uint64_t setOffset(OutputSection *Cmd, uint64_t Off) {
   Off = getFileAlignment(Off, Cmd);
   Cmd->Offset = Off;
 
   // For SHT_NOBITS we should not count the size.
   if (Cmd->Type == SHT_NOBITS)

 template <class ELFT> void Writer<ELFT>::setPhdrs() {
   for (PhdrEntry *P : Phdrs) {
     OutputSection *First = P->FirstSec;
     OutputSection *Last = P->LastSec;
     if (First) {
       P->p_filesz = Last->Offset - First->Offset;
       if (Last->Type != SHT_NOBITS)
         P->p_filesz += Last->Size;
-      P->p_memsz = Last->Addr + Last->Size - First->Addr;
+      P->p_memsz = Last->getLMA() + Last->Size - First->getLMA();
       P->p_offset = First->Offset;
       P->p_vaddr = First->Addr;
       if (!P->HasLMA)
         P->p_paddr = First->getLMA();
     }
     if (P->p_type == PT_LOAD)
       P->p_align = std::max<uint64_t>(P->p_align, Config->MaxPageSize);
     else if (P->p_type == PT_GNU_RELRO) {

test/ELF/linkerscript/at5.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "PHDRS { all PT_LOAD; } \
+# RUN:       SECTIONS { \
+# RUN:           .aaa 0x1000 : AT(0x3000) { *(.aaa) } : all \
+# RUN:           .bbb 0x5000 : AT(0x3000 + SIZEOF(.aaa)) { *(.bbb) } \
+# RUN:           .text : { *(.text) } \
+# RUN:       }" > %t.script
+# RUN: ld.lld %t --script %t.script -o %t2
+# RUN: llvm-readobj -program-headers -sections %t2 | FileCheck %s
+
+# CHECK:      Sections [
+# CHECK:        Section {
+# CHECK:          Index: 1
+# CHECK-NEXT:     Name: .aaa
+# CHECK-NEXT:     Type: SHT_PROGBITS
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       SHF_ALLOC
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x1000
+# CHECK-NEXT:     Offset: 0x1000
+# CHECK-NEXT:     Size: 8
+# CHECK-NEXT:     Link:
+# CHECK-NEXT:     Info:
+# CHECK-NEXT:     AddressAlignment:
+# CHECK-NEXT:     EntrySize:
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .bbb
+# CHECK-NEXT:     Type: SHT_PROGBITS
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       SHF_ALLOC
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x5000
+# CHECK-NEXT:     Offset: 0x1008
+# CHECK-NEXT:     Size: 8
+# CHECK-NEXT:     Link:
+# CHECK-NEXT:     Info:
+# CHECK-NEXT:     AddressAlignment:
+# CHECK-NEXT:     EntrySize:
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 3
+# CHECK-NEXT:     Name: .text
+# CHECK-NEXT:     Type: SHT_PROGBITS
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       SHF_ALLOC
+# CHECK-NEXT:       SHF_EXECINSTR
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x5008
+# CHECK-NEXT:     Offset: 0x1010
+# CHECK-NEXT:     Size: 1
+# CHECK-NEXT:     Link:
+# CHECK-NEXT:     Info:
+# CHECK-NEXT:     AddressAlignment:
+# CHECK-NEXT:     EntrySize:
+# CHECK-NEXT:   }
+# CHECK:      ProgramHeaders [
+# CHECK-NEXT:   ProgramHeader {
+# CHECK-NEXT:     Type: PT_LOAD
+# CHECK-NEXT:     Offset: 0x1000
+# CHECK-NEXT:     VirtualAddress: 0x1000
+# CHECK-NEXT:     PhysicalAddress: 0x3000
+# CHECK-NEXT:     FileSize: 17
+# CHECK-NEXT:     MemSize: 17
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       PF_R
+# CHECK-NEXT:       PF_X
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Alignment:
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+.global _start
+_start:
+ nop
+
+.section .aaa, "a"
+.quad 0
+
+.section .bbb, "a"
+.quad 0