[ELF] Use MaxPageSize for aligning PT_LOAD

[phosek]

Summary

This matches the behavior of Binutils linkers. We also change the default MaxPageSize on x86-64 to 0x1000 to preserve the current behavior, which is the same as the behavior implemented by gold.

https://llvm.org/bugs/show_bug.cgi?id=30541

[phosek]

The question is whether it wouldn't also make more sense to rename MaxPageSize and PageSize to something more descriptive/less confusing, e.g. gold uses abi_pagesize (for MaxPageSize) and common_pagesize (for PageSize) which IMHO makes more sense.

[• rafael]

LGTM

[emaste]

This change broke linking the FreeBSD kernel with lld, which relies on MAXPAGESIZE to set the kernel's phys addr. See https://svnweb.freebsd.org/base/head/sys/conf/ldscript.amd64?revision=303442&view=markup#l9

[emaste]

I'm not sure what's the best solution here; we could add -zmax-page-size to the FreeBSD kernel build, but I'm not sure we want to diverge from ld.bfd. For now I'm testing with a change to set x86 MaxPageSize back to 0x200000.

[emaste]

The FreeBSD kernel build breakage after this change is tracked in http://llvm.org/pr30891.

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
     Symtab.trace(Arg->getValue());
 
   // Initialize Config->ImageBase.
   if (auto *Arg = Args.getLastArg(OPT_image_base)) {
     StringRef S = Arg->getValue();
     if (S.getAsInteger(0, Config->ImageBase))
       error(Arg->getSpelling() + ": number expected, but got " + S);
-    else if ((Config->ImageBase % Target->PageSize) != 0)
+    else if ((Config->ImageBase % Target->MaxPageSize) != 0)
       warning(Arg->getSpelling() + ": address isn't multiple of page size");
   } else {
     Config->ImageBase = Config->Pic ? 0 : Target->DefaultImageBase;
   }
 
   // Add all files to the symbol table. After this, the symbol table
   // contains all known names except a few linker-synthesized symbols.
   for (InputFile *F : Files)

ELF/Target.cpp

const uint8_t Inst[] = {
       0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0,%eax
       0x90,                               // nop
       0x8d, 0x74, 0x26, 0x00              // leal 0(%esi,1),%esi
   };
   memcpy(Loc - 2, Inst, sizeof(Inst));
 }
 
 template <class ELFT> X86_64TargetInfo<ELFT>::X86_64TargetInfo() {
-  MaxPageSize = 0x200000; // 2MiB
   CopyRel = R_X86_64_COPY;
   GotRel = R_X86_64_GLOB_DAT;
   PltRel = R_X86_64_JUMP_SLOT;
   RelativeRel = R_X86_64_RELATIVE;
   IRelativeRel = R_X86_64_IRELATIVE;
   TlsGotRel = R_X86_64_TPOFF64;
   TlsModuleIndexRel = R_X86_64_DTPMOD64;
   TlsOffsetRel = R_X86_64_DTPOFF64;
PPC64TargetInfo::PPC64TargetInfo() {
   RelativeRel = R_PPC64_RELATIVE;
   GotEntrySize = 8;
   GotPltEntrySize = 8;
   PltEntrySize = 32;
   PltHeaderSize = 0;
 
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
-  PageSize = 65536;
+  MaxPageSize = 65536;
 
   // The PPC64 ELF ABI v1 spec, says:
   //
   //   It is normally desirable to put segments with different characteristics
   //   in separate 256 Mbyte portions of the address space, to give the
   //   operating system full paging flexibility in the 64-bit address space.
   //
   // And because the lowest non-zero 256M boundary is 0x10000000, PPC64 linkers

 }
 
 bool ARMTargetInfo::isTlsInitialExecRel(uint32_t Type) const {
   return Type == R_ARM_TLS_IE32;
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   GotPltHeaderEntriesNum = 2;
-  PageSize = 65536;
+  MaxPageSize = 65536;
   GotEntrySize = sizeof(typename ELFT::uint);
   GotPltEntrySize = sizeof(typename ELFT::uint);
   PltEntrySize = 16;
   PltHeaderSize = 32;
   CopyRel = R_MIPS_COPY;
   PltRel = R_MIPS_JUMP_SLOT;
   NeedsThunks = true;
   if (ELFT::Is64Bits) {

ELF/Writer.cpp

 
 // 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<ELFT> *Sec : OutputSections) {
     uintX_t Alignment = Sec->getAlignment();
     if (Sec->PageAlign)
-      Alignment = std::max<uintX_t>(Alignment, Target->PageSize);
+      Alignment = std::max<uintX_t>(Alignment, Target->MaxPageSize);
 
     auto I = Config->SectionStartMap.find(Sec->getName());
     if (I != Config->SectionStartMap.end())
       VA = I->second;
 
     // We only assign VAs to allocated sections.
     if (needsPtLoad(Sec)) {
       VA = alignTo(VA, Alignment);

 // Adjusts the file alignment for a given output section and returns
 // its new file offset. The file offset must be the same with its
 // virtual address (modulo the page size) so that the loader can load
 // executables without any address adjustment.
 template <class ELFT, class uintX_t>
 static uintX_t getFileAlignment(uintX_t Off, OutputSectionBase<ELFT> *Sec) {
   uintX_t Alignment = Sec->getAlignment();
   if (Sec->PageAlign)
-    Alignment = std::max<uintX_t>(Alignment, Target->PageSize);
+    Alignment = std::max<uintX_t>(Alignment, Target->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, Target->PageSize, Sec->getVA());
+  return alignTo(Off, Target->MaxPageSize, Sec->getVA());
 }
 
 template <class ELFT, class uintX_t>
 void setOffset(OutputSectionBase<ELFT> *Sec, uintX_t &Off) {
   if (Sec->getType() == SHT_NOBITS) {
     Sec->setFileOffset(Off);
     return;
   }
if (First) {
       H.p_filesz = Last->getFileOff() - First->getFileOff();
       if (Last->getType() != SHT_NOBITS)
         H.p_filesz += Last->getSize();
       H.p_memsz = Last->getVA() + Last->getSize() - First->getVA();
       H.p_offset = First->getFileOff();
       H.p_vaddr = First->getVA();
     }
     if (H.p_type == PT_LOAD)
-      H.p_align = Target->PageSize;
+      H.p_align = Target->MaxPageSize;
     else if (H.p_type == PT_GNU_RELRO)
       H.p_align = 1;
 
     if (!P.HasLMA) {
     // The p_paddr field can be set using linker script AT command.
     // By default, it is the same value as p_vaddr.
       H.p_paddr = H.p_vaddr;
       if (H.p_type == PT_LOAD && First)

test/ELF/linkerscript/data-segment-relro.s

 # CHECK:       Section {
 # CHECK:         Index:
 # CHECK:         Name: .got
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_WRITE
 # CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x2000F0
+# CHECK-NEXT:    Address: 0x10F0
 # CHECK-NEXT:    Offset: 0x10F0
 # CHECK-NEXT:    Size:
 # CHECK-NEXT:    Link:
 # CHECK-NEXT:    Info:
 # CHECK-NEXT:    AddressAlignment:
 # CHECK-NEXT:    EntrySize:
 # CHECK-NEXT:  }
 # CHECK-NEXT:  Section {
 # CHECK-NEXT:    Index:
 # CHECK-NEXT:    Name: .got.plt
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Flags [
 # CHECK-NEXT:      SHF_ALLOC
 # CHECK-NEXT:      SHF_WRITE
 # CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x201000
+# CHECK-NEXT:    Address: 0x2000
 # CHECK-NEXT:    Offset: 0x2000
 # CHECK-NEXT:    Size:
 # CHECK-NEXT:    Link:
 # CHECK-NEXT:    Info:
 # CHECK-NEXT:    AddressAlignment:
 # CHECK-NEXT:    EntrySize:
 # CHECK-NEXT:  }
 

test/ELF/linkerscript/locationcounter.s

 # CHECK: .ternary1         {{.*}} 0000000000016000
 # CHECK: .ternary2         {{.*}} 0000000000017000
 # CHECK: .less             {{.*}} 0000000000018000
 # CHECK: .lesseq           {{.*}} 0000000000019000
 # CHECK: .great            {{.*}} 0000000000020000
 # CHECK: .greateq          {{.*}} 0000000000021000
 # CHECK: .eq               {{.*}} 0000000000022000
 # CHECK: .neq              {{.*}} 0000000000023000
-# CHECK: .maxpagesize      {{.*}} 0000000004800000
+# CHECK: .maxpagesize      {{.*}} 0000000000024000
 # CHECK: .commonpagesize   {{.*}} 0000000000025000
-# CHECK: .datasegmentalign {{.*}} 0000000000200000
+# CHECK: .datasegmentalign {{.*}} 0000000000026000
 # CHECK: .plusassign       {{.*}} 0000000000028000
 # CHECK: .unary            {{.*}} 000000000002a000
 # CHECK: .shiftl           {{.*}} 0000000000030040
 # CHECK: .shiftr           {{.*}} 0000000000030100
 
 ## Mailformed number error.
 # RUN: echo "SECTIONS { \
 # RUN:  . = 0x12Q41; \

test/ELF/linkerscript/outsections-addr.s

 #CHECK:  }
 #CHECK:  Section {
 #CHECK:    Index: 3
 #CHECK:    Name: .ccc
 #CHECK:    Type: SHT_PROGBITS
 #CHECK:    Flags [
 #CHECK:      SHF_ALLOC
 #CHECK:    ]
-#CHECK:    Address: 0x203008
+#CHECK:    Address: 0x4008
 #CHECK:    Offset: 0x2008
 #CHECK:    Size: 8
 #CHECK:    Link: 0
 #CHECK:    Info: 0
 #CHECK:    AddressAlignment: 1
 #CHECK:    EntrySize: 0
 #CHECK:  }
 #CHECK:  Section {

test/ELF/linkerscript/symbol-assignexpr.s

 # RUN:       }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck %s
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT: 0000000000000000 *UND* 00000000
 # CHECK-NEXT:                  .text 00000000 _start
 # CHECK-NEXT:                  .text 00000000 foo
-# CHECK-NEXT: 0000000000200000 *ABS* 00000000 symbol
-# CHECK-NEXT: 0000000000201234 *ABS* 00000000 symbol2
-# CHECK-NEXT: 0000000000201234 *ABS* 00000000 symbol3
-# CHECK-NEXT: 00000000001ffffc *ABS* 00000000 symbol4
-# CHECK-NEXT: 000000000020fffc *ABS* 00000000 symbol5
-# CHECK-NEXT: 000000000020fffc *ABS* 00000000 symbol6
-# CHECK-NEXT: 0000000000210000 *ABS* 00000000 symbol7
+# CHECK-NEXT: 0000000000001000 *ABS* 00000000 symbol
+# CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol2
+# CHECK-NEXT: 0000000000002234 *ABS* 00000000 symbol3
+# CHECK-NEXT: 0000000000000ffc *ABS* 00000000 symbol4
+# CHECK-NEXT: 0000000000010ffc *ABS* 00000000 symbol5
+# CHECK-NEXT: 0000000000010ffc *ABS* 00000000 symbol6
+# CHECK-NEXT: 0000000000011000 *ABS* 00000000 symbol7
 # CHECK-NEXT: ffffffffffff0004 *ABS* 00000000 symbol8
 # CHECK-NEXT: fffffffffffffffc *ABS* 00000000 symbol9
 # CHECK-NEXT: fedcba9876543210 *ABS* 00000000 symbol10
 # CHECK-NEXT: 0000000000029000 *ABS* 00000000 symbol11
 
 # RUN: echo "SECTIONS { \
 # RUN:         symbol2 = symbol; \
 # RUN:       }" > %t2.script