[ELF] Align SHT_LLVM_PART_EHDR to a maximum page size boundary

[MaskRay]

Summary

Fixes https://bugs.chromium.org/p/chromium/issues/detail?id=998712

SHT_LLVM_PART_EHDR marks the start of a partition. The partition
sections will be extracted to a separate file. Align to the next maximum
page size boundary so that we can find the ELF header at the start. We
cannot benefit from overlapping p_offset ranges with the previous
segment anyway.

It seems we lack some llvm-objcopy --extract-main-partition and
--extract-partition sanity checks. It may place EHDR at the start
even if p_offset if non zero. Anyway, the lld change is justified for
the reasons above.

[MaskRay]

Delete a stray line from the test

[ruiu]

LGTM

[MaskRay]

Update description

[pcc]

Alternatively it looks like we could increase the alignment of the partition ELF header section here: http://llvm-cs.pcc.me.uk/tools/lld/ELF/SyntheticSections.cpp#3581

[MaskRay]

In D67032#1679680, @pcc wrote:

Alternatively it looks like we could increase the alignment of the partition ELF header section here: http://llvm-cs.pcc.me.uk/tools/lld/ELF/SyntheticSections.cpp#3581

This approach will need a bit more work not to overadvance dot (we advance to the addrExpr() aligned address, then alignment aligned address):

[17] .data             PROGBITS        0000000000003178 002178 000008 00  WA  0   0  1                        
[18] .got.plt          PROGBITS        0000000000003180 002180 000028 00  WA  0   0  8                        
[19] part1             LOOS+0xfff4c06  0000000000005000 003000 000040 00   A  0   0 4096 <------- 0x5000 can be 0x4000

But I'll check if this can be implemented.

lld/trunk/ELF/Writer.cpp

if (cmd && !cmd->addrExpr) {
       // Prefer advancing to align(dot, maxPageSize) + dot%maxPageSize to avoid
       // padding in the file contents.
       //
       // When -z separate-code is used we must not have any overlap in pages
       // between an executable segment and a non-executable segment. We align to
       // the next maximum page size boundary on transitions between executable
       // and non-executable segments.
       //
+      // SHT_LLVM_PART_EHDR marks the start of a partition. The partition
+      // sections will be extracted to a separate file. Align to the next
+      // maximum page size boundary so that we can find the ELF header at the
+      // start. We cannot benefit from overlapping p_offset ranges with the
+      // previous segment anyway.
+      //
       // TODO Enable this technique on all targets.
       bool enable = config->emachine != EM_HEXAGON &&
                     config->emachine != EM_MIPS &&
                     config->emachine != EM_X86_64;
 
-      if (!enable || (config->zSeparateCode && prev &&
-                      (prev->p_flags & PF_X) != (p->p_flags & PF_X)))
+      if (!enable ||
+          (config->zSeparateCode && prev &&
+           (prev->p_flags & PF_X) != (p->p_flags & PF_X)) ||
+          cmd->type == SHT_LLVM_PART_EHDR)
         cmd->addrExpr = [] {
           return alignTo(script->getDot(), config->maxPageSize);
         };
       // PT_TLS is at the start of the first RW PT_LOAD. If `p` includes PT_TLS,
       // it must be the RW. Align to p_align(PT_TLS) to make sure
       // p_vaddr(PT_LOAD)%p_align(PT_LOAD) = 0. Otherwise, if
       // sh_addralign(.tdata) < sh_addralign(.tbss), we will set p_align(PT_TLS)
       // to sh_addralign(.tbss), while p_vaddr(PT_TLS)=p_vaddr(PT_LOAD) may not

lld/trunk/test/ELF/partitions.s

-// REQUIRES: x86
+// REQUIRES: aarch64, x86
 // RUN: llvm-mc %s -o %t.o -filetype=obj --triple=x86_64-unknown-linux
+// RUN: ld.lld %t.o -o %t --export-dynamic --gc-sections -z max-page-size=65536
+// RUN: llvm-readelf -S -s %t | FileCheck %s
+
+// RUN: llvm-mc %s -o %t.o -filetype=obj --triple=aarch64
 // RUN: ld.lld %t.o -o %t --export-dynamic --gc-sections
 // RUN: llvm-readelf -S -s %t | FileCheck %s
 
 // This is basically lld/docs/partitions.dot in object file form.
 // Test that the sections are correctly allocated to partitions.
+// part1 and part2 should be aligned to a maximum page size boundary.
 
 // CHECK: [[MAIN:[0-9]+]]] .text
+// CHECK: part1 LOOS+0xFFF4C06 {{[0-9a-f]+}}0000 {{[0-9a-f]+}}0000
 // CHECK: [[P1:[0-9]+]]] .text
+// CHECK: part2 LOOS+0xFFF4C06 {{[0-9a-f]+}}0000 {{[0-9a-f]+}}0000
 // CHECK: [[P2:[0-9]+]]] .text
 
 // CHECK: Symbol table '.symtab'
 // CHECK: [[MAIN]] f3
 // CHECK:   [[P1]] f4
 // CHECK: [[MAIN]] f5
 // CHECK:   [[P2]] f6
 // CHECK: [[MAIN]] _start
 // CHECK:   [[P1]] f1
 // CHECK:   [[P2]] f2
 
 .section .llvm_sympart.f1,"",@llvm_sympart
 .asciz "part1"
 .quad f1
 
 .section .llvm_sympart.f2,"",@llvm_sympart
 .asciz "part2"
 .quad f2
 
 .section .text._start,"ax",@progbits
 .globl _start
 _start:
-call f3
+.quad f3
 
 .section .text.f1,"ax",@progbits
 .globl f1
 f1:
-call f3
-call f4
-call f5
+.quad f3
+.quad f4
+.quad f5
 
 .section .text.f2,"ax",@progbits
 .globl f2
 f2:
-call f3
-call f5
-call f6
+.quad f3
+.quad f5
+.quad f6
 
 .section .text.f3,"ax",@progbits
 f3:
 ret
 
 .section .text.f4,"ax",@progbits
 f4:
 ret
 
 .section .text.f5,"ax",@progbits
 f5:
 ret
 
 .section .text.f6,"ax",@progbits
 f6:
 ret