[ELF] Change the way we compute file offsets

[evgeny777]

Summary

Imagine we have too sections .foo and .bar with virtual addresses 0x10000 and 0x20000, which share the same segment:

PHDRS { all PT_LOAD; }
SECTIONS {
   .foo (0x10000) : { *(.foo*) } : all
   .bar (0x20000) : { *(.bar*) } : all
}

Now also imagine that section .foo is the first section in PT_LOAD and segment virtual address is the same as section .foo, i.e 0x10000
As we have only one PT_LOAD, OS kernel should allocate the both sections correctly using only one memory mapping operation. The only
way this can be done is setting difference between file offsets of .bar and .foo to the same value as difference between their virtual addresses, i.e:

File_offset(.bar) - File_offset(.foo) = VA(.bar) - VA(.foo) = 0x10000

In such case both sections be correctly loaded using a single mmap() call.

Also It looks like both gold and ld use the same approach.

[grimar]

ELF/Writer.cpp

1055 ↗

(On Diff #72792)

Why do you need this ?

1206 ↗

(On Diff #72792)

I think this looks nicer in 2 lines:

if (!First || Sec == First)
  return alignTo(Off, Target->MaxPageSize, Sec->getVA());
return std::max(Off, First->getFileOffset() + Sec->getVA() - First->getVA());

1225 ↗

(On Diff #72792)

Excessive line.

[evgeny777]

ELF/Writer.cpp

1055 ↗

(On Diff #72792)

This patch was done in times we could have non-allocatable sections in the middle of the section list. This is no longer needed as well as taking maximum of old and new offset. I'll update the diff.

[evgeny777]

Addressed review comments

[ruiu]

ELF/OutputSections.h

112 ↗

(On Diff #72801)

Needs a comment about what this is and why we need it.

[evgeny777]

Added comment for 'FirstInPtLoad'

[ruiu]

LGTM

lld/trunk/ELF/OutputSections.h

enum Kind {
     VersNeed,
     VersTable
   };
 
   OutputSectionBase(StringRef Name, uint32_t Type, uintX_t Flags);
   void setVA(uintX_t VA) { Header.sh_addr = VA; }
   uintX_t getVA() const { return Header.sh_addr; }
   void setFileOffset(uintX_t Off) { Header.sh_offset = Off; }
+  uintX_t getFileOffset() { return Header.sh_offset; }
   void setSHName(unsigned Val) { Header.sh_name = Val; }
   void writeHeaderTo(Elf_Shdr *SHdr);
   StringRef getName() { return Name; }
 
   virtual void addSection(InputSectionBase<ELFT> *C) {}
   virtual Kind getKind() const { return Base; }
   static bool classof(const OutputSectionBase<ELFT> *B) {
     return B->getKind() == Base;
void updateAlignment(uintX_t Alignment) {
     if (Alignment > Header.sh_addralign)
       Header.sh_addralign = Alignment;
   }
 
   // If true, this section will be page aligned on disk.
   // Typically the first section of each PT_LOAD segment has this flag.
   bool PageAlign = false;
 
+  // Pointer to the first section in PT_LOAD segment, which this section
+  // also 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.
+  OutputSectionBase<ELFT> *FirstInPtLoad = nullptr;
+
   virtual void finalize() {}
   virtual void finalizePieces() {}
   virtual void assignOffsets() {}
   virtual void writeTo(uint8_t *Buf) {}
   virtual ~OutputSectionBase() = default;
 
 protected:
   StringRef Name;

lld/trunk/ELF/Writer.cpp

 }
 
 template<class ELFT>
 void PhdrEntry<ELFT>::add(OutputSectionBase<ELFT> *Sec) {
   Last = Sec;
   if (!First)
     First = Sec;
   H.p_align = std::max<typename ELFT::uint>(H.p_align, Sec->getAlignment());
+  if (H.p_type == PT_LOAD && !Config->OFormatBinary)
+    Sec->FirstInPtLoad = First;
 }
 
 template <class ELFT>
 static Symbol *addOptionalSynthetic(StringRef Name,
                                     OutputSectionBase<ELFT> *Sec,
                                     typename ELFT::uint Val) {
   SymbolBody *S = Symtab<ELFT>::X->find(Name);
   if (!S)
static uintX_t getFileAlignment(uintX_t Off, OutputSectionBase<ELFT> *Sec) {
   if (Sec->PageAlign)
     Alignment = std::max<uintX_t>(Alignment, Config->MaxPageSize);
   Off = alignTo(Off, Alignment);
 
   // Relocatable output does not have program headers
   // and does not need any other offset adjusting.
   if (Config->Relocatable || !(Sec->getFlags() & SHF_ALLOC))
     return Off;
-  return alignTo(Off, Config->MaxPageSize, Sec->getVA());
+
+  OutputSectionBase<ELFT> *First = Sec->FirstInPtLoad;
+  // If two sections share the same PT_LOAD the file offset is calculated using
+  // this formula: Off2 = Off1 + (VA2 - VA1).
+  if (!First || Sec == First)
+    return alignTo(Off, Target->MaxPageSize, Sec->getVA());
+  return First->getFileOffset() + Sec->getVA() - First->getVA();
 }
 
 template <class ELFT, class uintX_t>
 void setOffset(OutputSectionBase<ELFT> *Sec, uintX_t &Off) {
   if (Sec->getType() == SHT_NOBITS) {
     Sec->setFileOffset(Off);
     return;
   }

lld/trunk/test/ELF/linkerscript/outsections-addr.s

 #CHECK:  Section {
 #CHECK:    Index: 3
 #CHECK:    Name: .ccc
 #CHECK:    Type: SHT_PROGBITS
 #CHECK:    Flags [
 #CHECK:      SHF_ALLOC
 #CHECK:    ]
 #CHECK:    Address: 0x4008
-#CHECK:    Offset: 0x2008
+#CHECK:    Offset: 0x3008
 #CHECK:    Size: 8
 #CHECK:    Link: 0
 #CHECK:    Info: 0
 #CHECK:    AddressAlignment: 1
 #CHECK:    EntrySize: 0
 #CHECK:  }
 #CHECK:  Section {
 #CHECK:    Index: 4
 #CHECK:    Name: .ddd
 #CHECK:    Type: SHT_PROGBITS
 #CHECK:    Flags [
 #CHECK:      SHF_ALLOC
 #CHECK:    ]
 #CHECK:    Address: 0x5010
-#CHECK:    Offset: 0x2010
+#CHECK:    Offset: 0x4010
 #CHECK:    Size: 8
 #CHECK:    Link: 0
 #CHECK:    Info: 0
 #CHECK:    AddressAlignment: 16
 #CHECK:    EntrySize: 0
 #CHECK:  }
 
 .globl _start