[ELF] Split RW PT_LOAD on the PT_GNU_RELRO boundary

[MaskRay]

Summary

Based on Peter Collingbourne's suggestion in D56828.

Old: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) .data .bss)
New: PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro)) PT_LOAD(.data. .bss)

The new layout reflects the runtime memory mappings.
By having two PT_LOAD segments, we can utilize the NOBITS part of the
first PT_LOAD and save bytes for .bss.rel.ro.

.bss.rel.ro is currently small and only used by copy relocations of
symbols in read-only segments, but it can be used for other purposes in
the future, e.g. if a relro section's statically relocated data is all
zeros, we can move it to .bss.rel.ro.

[MaskRay]

.

[MaskRay]

This is independent from D56828.

[pcc]

Looks good modulo tests.

ELF/Writer.cpp

804–805

This comment should now be moved to line 814.

[MaskRay]

Add tests. Most offsets are off by 56 bytes as we add one more PT_LOAD.

[ruiu]

LGTM. Splitting a PT_LOAD into two should be harmless for this case.

ELF/Writer.cpp

1988–1989

Remove the blank line.

[MaskRay]

Remove the blank line.

[pcc]

Is there a test that shows that the behavior is correct if a .bss.rel.ro is large enough to require another page?

lld/trunk/test/ELF/pack-dyn-relocs-loop.s

12 ↗

(On Diff #190768)

I think you need to change the size of x here so that this test continues to test what it is intended to test.

[MaskRay]

Is there a test that shows that the behavior is correct if a .bss.rel.ro is large enough to require another page?

See https://reviews.llvm.org/D59404

lld/trunk/test/ELF/pack-dyn-relocs-loop.s

12 ↗

(On Diff #190768)

I think you mean https://reviews.llvm.org/D53003

As the description says, it is very sensitive to exact sizes and offsets. Now with the layout change, I'm not sure how to reproduce the oscillation after deleting if (RelocData.size() < OldSize) RelocData.append(OldSize - RelocData.size(), 0);...

I checked the following layout but it didn't fail.

[ 6] .text             PROGBITS        0000000000010000 010000 000000 00  AX  0   0  4                        
[ 7] .dynamic          DYNAMIC         0000000000010000 010000 0000b0 10  WA  4   0  8                        
[ 8] .data             PROGBITS        0000000000020000 020000 000004 00  WA  0   0  1                        
[ 9] x                 PROGBITS        0000000000020004 020004 00fff6 00  WA  0   0  1                        
[10] barr              PROGBITS        000000000002fffa 02fffa 00000a 00  WA  0   0  2                        
[11] foo               PROGBITS        0000000000030004 030004 00000c 00  WA  0   0  1

[MaskRay]

lld/trunk/test/ELF/pack-dyn-relocs-loop.s

12 ↗

(On Diff #190768)

OK, I can use -z norelro to counteract the layout change in D56828. Fixed by https://reviews.llvm.org/rLLD356229

[mgorny]

I know I'm late to the party but this change thoroughly destroyed NetBSD support. The NetBSD loader doesn't support having more than two PT_LOAD sections. -z norosegment helped with that so far but after this change practically everything fails to run.

[MaskRay]

In D58892#1783029, @mgorny wrote:

I know I'm late to the party but this change thoroughly destroyed NetBSD support. The NetBSD loader doesn't support having more than two PT_LOAD sections. -z norosegment helped with that so far but after this change practically everything fails to run.

This seems to be a very serious limitation. I have difficult to understand how such limitation could exist at all, but I think this should be straightforward to fix. I presume you meant --no-rosegment, not -z norosegment. The latter does not exist.

[mgorny]

In D58892#1783042, @MaskRay wrote:

In D58892#1783029, @mgorny wrote:

I know I'm late to the party but this change thoroughly destroyed NetBSD support. The NetBSD loader doesn't support having more than two PT_LOAD sections. -z norosegment helped with that so far but after this change practically everything fails to run.

This seems to be a very serious limitation. I have difficult to understand how such limitation could exist at all, but I think this should be straightforward to fix.

Yes, it is a serious limitation, and no, it's not straightforward to fix. The loader has making a lot of assumptions, especially what PT_LOAD segments to expect and in which order. I've previously made a patch that allowed third segment but it was rejected as apparently 'not doing it the right way'. Almost a year has passed, and I am entirely powerless to fix it.

I presume you meant --no-rosegment, not -z norosegment. The latter does not exist.

Yes, whichever exists, I meant it ;-).

[krytarowski]

We would like to get this PT_LOAD split as a tunable, ignoring whether tests are passed or not when it is disabled.

At some point of time (hopefully sooner than later) we will add a switch in lld that investigates Triplet, retrieves version of the OS and conditionally enables it. This way we will get support for older and newer versions of NetBSD. We want to narrow this knowledge to the linker (in a way like: https://reviews.llvm.org/D70048), rather than spread to GCC in base, several versions of GCC in pkgsrc and Portable C Compiler.

ELF/Writer.cpp

if (IsExec) {
     Rank |= RF_WRITE;
   } else if (Sec->Type == SHT_PROGBITS) {
     // Make non-executable and non-writable PROGBITS sections (e.g .rodata
     // .eh_frame) closer to .text. They likely contain PC or GOT relative
     // relocations and there could be relocation overflow if other huge sections
     // (.dynstr .dynsym) were placed in between.
     Rank |= RF_RODATA;
   }
 
   // Place RelRo sections first. After considering SHT_NOBITS below, the
   // ordering is PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss),
   // where | marks where page alignment happens. An alternative ordering is
   // PT_LOAD(.data | PT_GNU_RELRO( .data.rel.ro .bss.rel.ro) | .bss), but it may
   // waste more bytes due to 2 alignment places.
   if (!isRelroSection(Sec))
     Rank |= RF_NOT_RELRO;
 
   // If we got here we know that both A and B are in the same PT_LOAD.
template <class ELFT> std::vector<PhdrEntry *> Writer<ELFT>::createPhdrs() {
   // Add the first PT_LOAD segment for regular output sections.
   uint64_t Flags = computeFlags(PF_R);
   PhdrEntry *Load = AddHdr(PT_LOAD, Flags);
 
   // Add the headers. We will remove them if they don't fit.
   Load->add(Out::ElfHeader);
   Load->add(Out::ProgramHeaders);
 
+  // PT_GNU_RELRO includes all sections that should be marked as
+  // read-only by dynamic linker after proccessing relocations.
+  // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give
+  // an error message if more than one PT_GNU_RELRO PHDR is required.
+  PhdrEntry *RelRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
+  bool InRelroPhdr = false;
+  OutputSection *RelroEnd = nullptr;
+  for (OutputSection *Sec : OutputSections) {
+    if (!needsPtLoad(Sec))
+      continue;
+    if (isRelroSection(Sec)) {
+      InRelroPhdr = true;
+      if (!RelroEnd)
+        RelRo->add(Sec);
+      else
+        error("section: " + Sec->Name + " is not contiguous with other relro" +
+              " sections");
+    } else if (InRelroPhdr) {
+      InRelroPhdr = false;
+      RelroEnd = Sec;
+    }
+  }
+
   for (OutputSection *Sec : OutputSections) {
     if (!(Sec->Flags & SHF_ALLOC))
       break;
     if (!needsPtLoad(Sec))
       continue;
 
     // Segments are contiguous memory regions that has the same attributes
     // (e.g. executable or writable). There is one phdr for each segment.
     // Therefore, we need to create a new phdr when the next section has
     // different flags or is loaded at a discontiguous address or memory
     // region using AT or AT> linker script command, respectively. At the same
     // time, we don't want to create a separate load segment for the headers,
     // even if the first output section has an AT or AT> attribute.
     uint64_t NewFlags = computeFlags(Sec->getPhdrFlags());
     if (((Sec->LMAExpr ||
           (Sec->LMARegion && (Sec->LMARegion != Load->FirstSec->LMARegion))) &&
          Load->LastSec != Out::ProgramHeaders) ||
-        Sec->MemRegion != Load->FirstSec->MemRegion || Flags != NewFlags) {
-
+        Sec->MemRegion != Load->FirstSec->MemRegion || Flags != NewFlags ||
+        Sec == RelroEnd) {
       Load = AddHdr(PT_LOAD, NewFlags);
       Flags = NewFlags;
     }
 
     Load->add(Sec);
   }
 
   // Add a TLS segment if any.
   PhdrEntry *TlsHdr = make<PhdrEntry>(PT_TLS, PF_R);
   for (OutputSection *Sec : OutputSections)
     if (Sec->Flags & SHF_TLS)
       TlsHdr->add(Sec);
   if (TlsHdr->FirstSec)
     Ret.push_back(TlsHdr);
 
   // Add an entry for .dynamic.
   if (OutputSection *Sec = In.Dynamic->getParent())
     AddHdr(PT_DYNAMIC, Sec->getPhdrFlags())->add(Sec);
 
-  // PT_GNU_RELRO includes all sections that should be marked as
-  // read-only by dynamic linker after proccessing relocations.
-  // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give
-  // an error message if more than one PT_GNU_RELRO PHDR is required.
-  PhdrEntry *RelRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
-  bool InRelroPhdr = false;
-  bool IsRelroFinished = false;
-  for (OutputSection *Sec : OutputSections) {
-    if (!needsPtLoad(Sec))
-      continue;
-    if (isRelroSection(Sec)) {
-      InRelroPhdr = true;
-      if (!IsRelroFinished)
-        RelRo->add(Sec);
-      else
-        error("section: " + Sec->Name + " is not contiguous with other relro" +
-              " sections");
-    } else if (InRelroPhdr) {
-      InRelroPhdr = false;
-      IsRelroFinished = true;
-    }
-  }
   if (RelRo->FirstSec)
     Ret.push_back(RelRo);
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
   if (!In.EhFrame->empty() && In.EhFrameHdr && In.EhFrame->getParent() &&
       In.EhFrameHdr->getParent())
     AddHdr(PT_GNU_EH_FRAME, In.EhFrameHdr->getParent()->getPhdrFlags())
         ->add(In.EhFrameHdr->getParent());

test/ELF/aarch64-copy.s

 // Page(S + A) - Page(P) = 0x230000 - 0x210000 = 0x20000 = 131072
 // CODE-NEXT:  210004: {{.*}} adrp x2, #131072
 // S(y) = 0x230010, A = 0
 // (S + A) & 0xFFF = 0x10 = 16
 // CODE-NEXT:  210008: {{.*}} add  x2, x2, #16
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x230014
-// RODATA-NEXT:  2002e0 14002300
+// RODATA-NEXT:  200318 14002300

test/ELF/amdgpu-relocs.s

 # CHECK-NEXT: R_AMDGPU_ABS64 weak_var2 0x0
 # CHECK-NEXT: R_AMDGPU_ABS64 weakref_alias_var0 0x0
 # CHECK-NEXT: R_AMDGPU_ABS64 weakref_alias_var1 0x0
 # CHECK-NEXT: R_AMDGPU_ABS64 weakref_alias_var2 0x0
 # CHECK-NEXT: }
 # CHECK-NEXT: ]
 
 # OBJDUMP: Contents of section .rodata:
-# OBJDUMP: d0f8ffff ffffffff
+# OBJDUMP: 98f8ffff ffffffff
 
 # OBJDUMP: Contents of section nonalloc:
 # OBJDUMP-NEXT: 0000 00000000 14380000 00000000 18340000
 # OBJDUMP-NEXT: 00000000 1c300000

test/ELF/arm-copy.s

 // ((S + A) & 0xffff0000) >> 16 = 0x1
 // CODE-NEXT:   11004:       01 20 40 e3    movt    r2, #1
 // CODE-NEXT:   11008:       04 30 9f e5    ldr     r3, [pc, #4]
 // CODE-NEXT:   1100c:       00 30 93 e5    ldr     r3, [r3]
 
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x13004
-// RODATA-NEXT: 10190 04300100
+// RODATA-NEXT: 101b0 04300100

test/ELF/arm-exidx-shared.s

  bx lr
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section {{.*}} .rel.plt {
 // CHECK-NEXT:     0x300C R_ARM_JUMP_SLOT __gxx_personality_v0
 
 // CHECK-EXTAB: Contents of section .ARM.extab:
 // 0x0210 + 0x0e20 = 0x1030 = __gxx_personality_v0(PLT)
-// CHECK-EXTAB-NEXT:  0210 200e0000 b0b0b000 00000000
+// CHECK-EXTAB-NEXT:  0230 000e0000 b0b0b000 00000000

test/ELF/basic-ppc64.s

 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 1
 // CHECK-NEXT:    Name: .dynsym (1)
 // CHECK-NEXT:    Type: SHT_DYNSYM (0xB)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x1C8
-// CHECK-NEXT:    Offset: 0x1C8
+// CHECK-NEXT:    Address: 0x200
+// CHECK-NEXT:    Offset: 0x200
 // CHECK-NEXT:    Size: 24
 // CHECK-NEXT:    Link: 3
 // CHECK-NEXT:    Info: 1
 // CHECK-NEXT:    AddressAlignment: 8
 // CHECK-NEXT:    EntrySize: 24
 // CHECK-NEXT:    SectionData (
 // CHECK-NEXT:      0000: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:      0010: 00000000 00000000                    |........|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 2
 // CHECK-NEXT:    Name: .hash (9)
 // CHECK-NEXT:    Type: SHT_HASH (0x5)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x1E0
-// CHECK-NEXT:    Offset: 0x1E0
+// CHECK-NEXT:    Address: 0x218
+// CHECK-NEXT:    Offset: 0x218
 // CHECK-NEXT:    Size: 16
 // CHECK-NEXT:    Link: 1
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 4
 // CHECK-NEXT:    EntrySize: 4
 // CHECK-NEXT:    SectionData (
 // CHECK-NEXT:      0000: 01000000 01000000 00000000 00000000  |................|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 3
 // CHECK-NEXT:    Name: .dynstr (15)
 // CHECK-NEXT:    Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x1F0
-// CHECK-NEXT:    Offset: 0x1F0
+// CHECK-NEXT:    Address: 0x228
+// CHECK-NEXT:    Offset: 0x228
 // CHECK-NEXT:    Size: 1
 // CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 1
 // CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
 // CHECK-NEXT:      0000: 00                                   |.|
 // CHECK-NEXT:    )

 // CHECK-NEXT:    Address: 0x20000
 // CHECK-NEXT:    Offset: 0x20000
 // CHECK-NEXT:    Size: 96
 // CHECK-NEXT:    Link: 3
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 8
 // CHECK-NEXT:    EntrySize: 16
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 06000000 00000000 C8010000 00000000  |................|
-// CHECK-NEXT:      0010: 0B000000 00000000 18000000 00000000  |................|
-// CHECK-NEXT:      0020: 05000000 00000000 F0010000 00000000  |................|
-// CHECK-NEXT:      0030: 0A000000 00000000 01000000 00000000  |................|
-// CHECK-NEXT:      0040: 04000000 00000000 E0010000 00000000  |................|
-// CHECK-NEXT:      0050: 00000000 00000000 00000000 00000000  |................|
+// CHECK-NEXT:      0000: 06000000 00000000 00020000 00000000  |
+// CHECK-NEXT:      0010: 0B000000 00000000 18000000 00000000  |
+// CHECK-NEXT:      0020: 05000000 00000000 28020000 00000000  |
+// CHECK-NEXT:      0030: 0A000000 00000000 01000000 00000000  |
+// CHECK-NEXT:      0040: 04000000 00000000 18020000 00000000  |
+// CHECK-NEXT:      0050: 00000000 00000000 00000000 00000000  |
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 6
 // CHECK-NEXT:    Name: .branch_lt (38)
 // CHECK-NEXT:    Type: SHT_NOBITS (0x8)
 // CHECK-NEXT:    Flags [ (0x3)
 // CHECK-NEXT:      SHF_ALLOC (0x2)

 // CHECK-NEXT:  }
 // CHECK-NEXT:]
 // CHECK-NEXT:ProgramHeaders [
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_PHDR (0x6)
 // CHECK-NEXT:    Offset: 0x40
 // CHECK-NEXT:    VirtualAddress: 0x40
 // CHECK-NEXT:    PhysicalAddress: 0x40
-// CHECK-NEXT:    FileSize: 392
-// CHECK-NEXT:    MemSize: 392
+// CHECK-NEXT:    FileSize: 448
+// CHECK-NEXT:    MemSize: 448
 // CHECK-NEXT:    Flags [ (0x4)
 // CHECK-NEXT:      PF_R (0x4)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Alignment: 8
 // CHECK-NEXT:  }
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_LOAD (0x1)
 // CHECK-NEXT:    Offset: 0x0
 // CHECK-NEXT:    VirtualAddress: 0x0
 // CHECK-NEXT:    PhysicalAddress: 0x0
-// CHECK-NEXT:    FileSize: 497
-// CHECK-NEXT:    MemSize: 497
+// CHECK-NEXT:    FileSize: 553
+// CHECK-NEXT:    MemSize: 553
 // CHECK-NEXT:    Flags [ (0x4)
 // CHECK-NEXT:      PF_R (0x4)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Alignment: 65536
 // CHECK-NEXT:  }
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_LOAD (0x1)
 // CHECK-NEXT:    Offset: 0x10000
 // CHECK-NEXT:    VirtualAddress: 0x10000
 // CHECK-NEXT:    PhysicalAddress: 0x10000
 // CHECK-NEXT:    FileSize: 12
 // CHECK-NEXT:    MemSize: 12
 // CHECK-NEXT:    Flags [ (0x5)
 // CHECK-NEXT:      PF_R (0x4)
 // CHECK-NEXT:      PF_X (0x1)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Alignment: 65536
 // CHECK-NEXT:  }
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_LOAD (0x1)
 // CHECK-NEXT:    Offset: 0x20000
 // CHECK-NEXT:    VirtualAddress: 0x20000
 // CHECK-NEXT:    PhysicalAddress: 0x20000
 // CHECK-NEXT:    FileSize: 96
-// CHECK-NEXT:    MemSize: 65536
+// CHECK-NEXT:    MemSize: 96
 // CHECK-NEXT:    Flags [ (0x6)
 // CHECK-NEXT:      PF_R (0x4)
 // CHECK-NEXT:      PF_W (0x2)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Alignment: 65536
 // CHECK-NEXT:  }
 // CHECK-NEXT:  ProgramHeader {
 // CHECK-NEXT:    Type: PT_DYNAMIC (0x2)

test/ELF/gnu-ifunc-dyntags.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -pie %t.o -o %tout
 # RUN: llvm-objdump -section-headers %tout | FileCheck %s
 # RUN: llvm-readobj -dynamic-table -r %tout | FileCheck %s --check-prefix=TAGS
 
 ## Check we produce DT_PLTREL/DT_JMPREL/DT_PLTGOT and DT_PLTRELSZ tags
 ## when there are no other relocations except R_*_IRELATIVE.
 
 # CHECK:  Name          Size   VMA
-# CHECK:  .rela.plt   00000030 0000000000000210
+# CHECK:  .rela.plt   00000030 0000000000000248
 # CHECK:  .got.plt    00000010 0000000000003000
 
 # TAGS:      Relocations [
 # TAGS-NEXT:   Section {{.*}} .rela.plt {
 # TAGS-NEXT:     R_X86_64_IRELATIVE
 # TAGS-NEXT:     R_X86_64_IRELATIVE
 # TAGS-NEXT:   }
 # TAGS-NEXT: ]
 
 # TAGS:   Tag                Type                 Name/Value
-# TAGS:   0x0000000000000017 JMPREL               0x210
+# TAGS:   0x0000000000000017 JMPREL               0x248
 # TAGS:   0x0000000000000002 PLTRELSZ             48
 # TAGS:   0x0000000000000003 PLTGOT               0x3000
 # TAGS:   0x0000000000000014 PLTREL               RELA
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:

test/ELF/i386-merge.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -shared
 // RUN: llvm-readobj -s -section-data %t | FileCheck %s
 
 // CHECK:      Name: .mysec
 // CHECK-NEXT: Type:
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x158
+// CHECK-NEXT: Address: 0x178
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 42000000 |

 // CHECK-NEXT: Address: 0x2000
 // CHECK-NEXT: Offset: 0x2000
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 58010000 |
+// CHECK-NEXT:   0000: 78010000 |
 // CHECK-NEXT: )
 
 // The content of .data should be the address of .mysec.
 
         .data
         .long .mysec+4
 
         .section        .mysec,"aM",@progbits,4
         .align  4
         .long   0x42
         .long   0x42

test/ELF/linkerscript/align-section-offset.test

 # REQUIRES: x86
 # RUN: echo '.section .foo, "aw"; .quad 42' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %t.o
 # RUN: ld.lld -o %t --script %s %t.o -shared
 # RUN: llvm-readelf -S -l %t | FileCheck %s
 
 SECTIONS {
   .foo : ALIGN(2M) { *(.foo) }
 }
 
-# CHECK: .foo  PROGBITS  0000000000200000 201000 000008 00  WA  0   0 2097152
-# CHECK: LOAD 0x001048 0x0000000000000048 0x0000000000000048 {{.*}} RW  0x200000
+# CHECK: .foo  PROGBITS  0000000000200000 200000 000008 00  WA  0   0 2097152
+# CHECK: LOAD 0x200000 0x0000000000200000 0x0000000000200000 {{.*}} RW  0x200000

test/ELF/linkerscript/overlapping-sections.s

 # RUN: echo "SECTIONS { \
 # RUN:   .sec1 0x8000 : { sec1_start = .; *(.first_sec) sec1_end = .;} \
 # RUN:   .sec2 0x8040 : { sec2_start = .; *(.second_sec) sec2_end = .;} \
 # RUN: }" > %t-both-overlap.script
 
 # RUN: not ld.lld -o %t.so --script %t-both-overlap.script %t.o -shared 2>&1 | FileCheck %s -check-prefix BOTH-OVERLAP-ERR
 
 # BOTH-OVERLAP-ERR:      error: section .sec1 file range overlaps with .sec2
-# BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x9000, 0x90FF]
-# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x9040, 0x913F]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x2000, 0x20FF]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x2040, 0x213F]
 # BOTH-OVERLAP-ERR:      error: section .sec1 virtual address range overlaps with .sec2
 # BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000, 0x80FF]
 # BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8040, 0x813F]
 # BOTH-OVERLAP-ERR:      error: section .sec1 load address range overlaps with .sec2
 # BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000, 0x80FF]
 # BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8040, 0x813F]
 
 # RUN: ld.lld -o %t.so --script %t-both-overlap.script %t.o -shared --noinhibit-exec

 # BROKEN-OUTPUT-FILE-NEXT: 8010 01010101 01010101 01010101 01010101
 # BROKEN-OUTPUT-FILE-NEXT: 8020 01010101 01010101 01010101 01010101
 # BROKEN-OUTPUT-FILE-NEXT: 8030 01010101 01010101 01010101 01010101
 # Starting here the contents of .sec2 overwrites .sec1:
 # BROKEN-OUTPUT-FILE-NEXT: 8040 02020202 02020202 02020202 02020202
 
 # RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-BOTH
 # BAD-BOTH-LABEL: Section Headers:
-# BAD-BOTH: .sec1             PROGBITS        0000000000008000 009000 000100 00  WA  0   0  1
-# BAD-BOTH: .sec2             PROGBITS        0000000000008040 009040 000100 00  WA  0   0  1
+# BAD-BOTH: .sec1             PROGBITS        0000000000008000 002000 000100 00  WA  0   0  1
+# BAD-BOTH: .sec2             PROGBITS        0000000000008040 002040 000100 00  WA  0   0  1
 # BAD-BOTH-LABEL: Program Headers:
 # BAD-BOTH-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
 # BAD-BOTH-NEXT:  LOAD 0x001000 0x0000000000000000 0x0000000000000000 0x000100 0x000100 R E 0x1000
-# BAD-BOTH-NEXT:  LOAD           0x001100 0x0000000000000100 0x0000000000000100 0x008040 0x008040 RW  0x1000
+# BAD-BOTH-NEXT:  LOAD           0x001100 0x0000000000000100 0x0000000000000100 0x000070 0x000070 RW  0x1000
 # BAD-BOTH-LABEL: Section to Segment mapping:
-# BAD-BOTH:   01     .text .dynamic .sec1 .sec2
+# BAD-BOTH:   01     .text .dynamic
 
 .section        .first_sec,"aw",@progbits
 .rept 0x100
 .byte 1
 .endr
 
 .section        .second_sec,"aw",@progbits
 .rept 0x100
 .byte 2
 .endr

test/ELF/linkerscript/repsection-symbol.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { \
 # RUN:   . = SIZEOF_HEADERS; \
 # RUN:   .text : { *(.text) } \
 # RUN:   .foo : {foo1 = .;  *(.foo.*) foo2 = .;  *(.bar) foo3 = .;} \
 # RUN: }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t1 --script %t.script %t -shared
 # RUN: llvm-readobj -t %t1 | FileCheck %s
 
 # CHECK:      Name: foo1
-# CHECK-NEXT: Value: 0x288
+# CHECK-NEXT: Value: 0x2C0
 
 # CHECK:      Name: foo2
-# CHECK-NEXT: Value: 0x290
+# CHECK-NEXT: Value: 0x2C8
 
 # CHECK:      Name: foo3
-# CHECK-NEXT: Value: 0x294
+# CHECK-NEXT: Value: 0x2CC
 
 .section .foo.1,"a"
  .long 1
 
 .section .foo.2,"aw"
  .long 2
 
  .section .bar,"aw"
  .long 3

test/ELF/map-file.s

 .long zed - .
 local:
 .comm   common,4,16
 .global abs
 abs = 0xAB5
 labs = 0x1AB5
 
 // CHECK:         VMA              LMA     Size Align Out     In      Symbol
-// CHECK-NEXT: 2001c8           2001c8       78     8 .dynsym
-// CHECK-NEXT: 2001c8           2001c8       78     8         <internal>:(.dynsym)
-// CHECK-NEXT: 200240           200240       2c     8 .gnu.hash
-// CHECK-NEXT: 200240           200240       2c     8         <internal>:(.gnu.hash)
-// CHECK-NEXT: 20026c           20026c       30     4 .hash
-// CHECK-NEXT: 20026c           20026c       30     4         <internal>:(.hash)
-// CHECK-NEXT: 20029c           20029c       31     1 .dynstr
-// CHECK-NEXT: 20029c           20029c       31     1         <internal>:(.dynstr)
-// CHECK-NEXT: 2002d0           2002d0       30     8 .rela.dyn
-// CHECK-NEXT: 2002d0           2002d0       30     8         <internal>:(.rela.dyn)
-// CHECK-NEXT: 200300           200300       30     8 .rela.plt
-// CHECK-NEXT: 200300           200300       30     8         <internal>:(.rela.plt)
-// CHECK-NEXT: 200330           200330       64     8 .eh_frame
-// CHECK-NEXT: 200330           200330       2c     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
-// CHECK-NEXT: 200360           200360       14     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
-// CHECK-NEXT: 200378           200378       18     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
+// CHECK-NEXT: 200200           200200       78     8 .dynsym
+// CHECK-NEXT: 200200           200200       78     8         <internal>:(.dynsym)
+// CHECK-NEXT: 200278           200278       2c     8 .gnu.hash
+// CHECK-NEXT: 200278           200278       2c     8         <internal>:(.gnu.hash)
+// CHECK-NEXT: 2002a4           2002a4       30     4 .hash
+// CHECK-NEXT: 2002a4           2002a4       30     4         <internal>:(.hash)
+// CHECK-NEXT: 2002d4           2002d4       31     1 .dynstr
+// CHECK-NEXT: 2002d4           2002d4       31     1         <internal>:(.dynstr)
+// CHECK-NEXT: 200308           200308       30     8 .rela.dyn
+// CHECK-NEXT: 200308           200308       30     8         <internal>:(.rela.dyn)
+// CHECK-NEXT: 200338           200338       30     8 .rela.plt
+// CHECK-NEXT: 200338           200338       30     8         <internal>:(.rela.plt)
+// CHECK-NEXT: 200368           200368       64     8 .eh_frame
+// CHECK-NEXT: 200368           200368       2c     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
+// CHECK-NEXT: 200398           200398       14     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
+// CHECK-NEXT: 2003b0           2003b0       18     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
 // CHECK-NEXT: 201000           201000       2d     4 .text
 // CHECK-NEXT: 201000           201000       28     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
 // CHECK-NEXT: 201000           201000        0     1                 _start
 // CHECK-NEXT: 20101f           20101f        0     1                 f(int)
 // CHECK-NEXT: 201028           201028        0     1                 local
 // CHECK-NEXT: 201028           201028        2     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
 // CHECK-NEXT: 201028           201028        0     1                 foo
 // CHECK-NEXT: 201029           201029        0     1                 bar

test/ELF/merge-shared-str.s

 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT:   SHF_STRINGS
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x228
+// CHECK-NEXT: Address: 0x260
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x229
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x261
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/merge-shared.s

 
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x228
+// CHECK-NEXT: Address: 0x260
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x22A
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x262
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/pack-dyn-relocs-loop.s

 
 // This test is very sensitive to the exact section sizes and offsets,
 // so check that they don't change.
 // CHECK:         Name: .rela.dyn (33)
 // CHECK-NEXT:    Type: SHT_ANDROID_RELA (0x60000002)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x210
-// CHECK-NEXT:    Offset: 0x210
+// CHECK-NEXT:    Address: 0x248
+// CHECK-NEXT:    Offset: 0x248
 // CHECK-NEXT:    Size: 22
 
 // CHECK:         Name: x (43)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x226
-// CHECK-NEXT:    Offset: 0x226
+// CHECK-NEXT:    Address: 0x25E
+// CHECK-NEXT:    Offset: 0x25E
 // CHECK-NEXT:    Size: 64980
 
 // CHECK:         Name: barr (45)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x2)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0xFFFA
-// CHECK-NEXT:    Offset: 0xFFFA
+// CHECK-NEXT:    Address: 0x10032
+// CHECK-NEXT:    Offset: 0x10032
 // CHECK-NEXT:    Size: 0
 
 // CHECK:         Name: foo (71)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x3)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_WRITE (0x1)
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x20004
-// CHECK-NEXT:    Offset: 0x20004
+// CHECK-NEXT:    Address: 0x30004
+// CHECK-NEXT:    Offset: 0x30004
 // CHECK-NEXT:    Size: 12
 
 
 .data
 .long 0
 
 .section foo,"aw"
 foof:

test/ELF/ppc64-relocs.s

 .FR_PPC64_REL32:
   addis 5, 2, .LC0@toc@ha
   ld 5, .LC0@toc@l(5)
 .LBB0_2:
   add 3, 3, 4
 
 # DATALE: Disassembly of section .rodata:
 # DATALE: .rodata:
-# DATALE: 10000190: b8 fe 00 00
+# DATALE: 100001c8: 80 fe 00 00
 
 # DATABE: Disassembly of section .rodata:
 # DATABE: .rodata:
-# DATABE: 10000190: 00 00 fe b8
+# DATABE: 100001c8: 00 00 fe 80
 
 # Address of rodata + value stored at rodata entry
 # should equal address of LBB0_2.
 # 0x10000190 + 0xfeb4 = 0x10010044
 # CHECK: Disassembly of section .R_PPC64_REL32:
 # CHECK: .FR_PPC64_REL32:
 # CHECK: 10010040: {{.*}} nop
 # CHECK: 10010044: {{.*}} ld 5, -32736(2)

 
 # Check that address of eh_frame entry + value stored
 # should equal the address of foo. Since it is not aligned,
 # the entry is not stored exactly at 10000198. It starts at
 # address 0x1000019a and has the value 0xfeaa.
 # 0x100001aa + 0xfeae = 0x10010058
 # DATALE: Disassembly of section .eh_frame:
 # DATALE: .eh_frame:
-# DATALE: 100001a8: {{.*}} ae fe
+# DATALE: 100001d0: {{.*}} 00 00
 
 # DATABE: Disassembly of section .eh_frame:
 # DATABE: .eh_frame:
-# DATABE: 100001b0: fe ae {{.*}}
+# DATABE: 100001e8: fe 76 {{.*}}
 
 # CHECK: __foo
 # CHECK-NEXT: 10010058: {{.*}} li 3, 0

test/ELF/relocation.s

 // CHECK-NEXT: 201021: {{.*}}  movl    2101328, %eax
 
 .section .R_X86_64_64,"a",@progbits
 .global R_X86_64_64
 R_X86_64_64:
  .quad R_X86_64_64
 
 // CHECK:      Contents of section .R_X86_64_64:
-// CHECK-NEXT:   2002c0 c0022000 00000000
+// CHECK-NEXT:   2002f8 f8022000 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
 // 0x2020F0(.got) - 0x2002c8(.R_X86_64_GOTPCREL) = 0x1e28
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   2002c8 281e0000
+// CHECK-NEXT:   200300 f01d0000
 
 .section .R_X86_64_GOT32,"a",@progbits
 .global R_X86_64_GOT32
 R_X86_64_GOT32:
         .long zed@got
 
 // CHECK: Contents of section .R_X86_64_GOT32:
 // CHECK-NEXT: f8ffffff
 
 
 // CHECK: Contents of section .R_X86_64_GOT64:
 // CHECK-NEXT: f8ffffff ffffffff
 .section .R_X86_64_GOT64,"a",@progbits
 .global R_X86_64_GOT64
 R_X86_64_GOT64:
         .quad zed@got

test/ELF/relro.s

 // RUN: llvm-readobj -l --elf-output-style=GNU %t | FileCheck --check-prefix=NORELRO %s
 
 // CHECK:      Program Headers:
 // CHECK-NEXT: Type
 // CHECK-NEXT: PHDR
 // CHECK-NEXT: LOAD
 // CHECK-NEXT: LOAD
 // CHECK-NEXT: LOAD
+// CHECK-NEXT: LOAD
 // CHECK-NEXT: DYNAMIC
 // CHECK-NEXT: GNU_RELRO
 // CHECK: Section to Segment mapping:
 
-// FULLRELRO:  05     .openbsd.randomdata .dynamic .got .got.plt {{$}}
-// PARTRELRO:  05     .openbsd.randomdata .dynamic .got {{$}}
+// FULLRELRO:  03     .openbsd.randomdata .dynamic .got .got.plt {{$}}
+// PARTRELRO:  03     .openbsd.randomdata .dynamic .got {{$}}
 
 
 // NORELRO-NOT: GNU_RELRO
 
 .global _start
 _start:
   .long bar
   jmp *bar2@GOTPCREL(%rip)

test/ELF/verdef-defaultver.s

 # EXE-NEXT:      Binding: Global
 # EXE-NEXT:      Type: Function
 # EXE-NEXT:      Other: 0
 # EXE-NEXT:      Section: Undefined
 # EXE-NEXT:    }
 # EXE-NEXT:  ]
 # EXE-NEXT:  Version symbols {
 # EXE-NEXT:    Section Name: .gnu.version
-# EXE-NEXT:    Address: 0x200228
-# EXE-NEXT:    Offset: 0x228
+# EXE-NEXT:    Address: 0x200260
+# EXE-NEXT:    Offset: 0x260
 # EXE-NEXT:    Link: 1
 # EXE-NEXT:    Symbols [
 # EXE-NEXT:      Symbol {
 # EXE-NEXT:        Version: 0
 # EXE-NEXT:        Name:
 # EXE-NEXT:      }
 # EXE-NEXT:      Symbol {
 # EXE-NEXT:        Version: 2

test/ELF/verdef.s

 
 ## Check that we can link agains DSO we produced.
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/verdef.s -o %tmain.o
 # RUN: ld.lld --hash-style=sysv %tmain.o %t.so -o %tout
 # RUN: llvm-readobj -V %tout | FileCheck --check-prefix=MAIN %s
 
 # MAIN:      Version symbols {
 # MAIN-NEXT:   Section Name: .gnu.version
-# MAIN-NEXT:   Address: 0x200228
-# MAIN-NEXT:   Offset: 0x228
+# MAIN-NEXT:   Address: 0x200260
+# MAIN-NEXT:   Offset: 0x260
 # MAIN-NEXT:   Link: 1
 # MAIN-NEXT:   Symbols [
 # MAIN-NEXT:     Symbol {
 # MAIN-NEXT:       Version: 0
 # MAIN-NEXT:       Name:
 # MAIN-NEXT:     }
 # MAIN-NEXT:     Symbol {
 # MAIN-NEXT:       Version: 2

test/ELF/verneed.s

 
 # CHECK:        Section {
 # CHECK:          Index: 1
 # CHECK-NEXT:     Name: .dynsym
 # CHECK-NEXT:     Type: SHT_DYNSYM (0xB)
 # CHECK-NEXT:     Flags [ (0x2)
 # CHECK-NEXT:       SHF_ALLOC (0x2)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     Address: 0x2001C8
-# CHECK-NEXT:     Offset: 0x1C8
+# CHECK-NEXT:     Address: 0x200200
+# CHECK-NEXT:     Offset: 0x200
 # CHECK-NEXT:     Size: 96
 # CHECK-NEXT:     Link: [[DYNSTR:.*]]
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     AddressAlignment: 8
 # CHECK-NEXT:     EntrySize: 24
 
 # CHECK:       Section {
 # CHECK-NEXT:    Index: 2

 # CHECK:       Section {
 # CHECK-NEXT:    Index: 3
 # CHECK-NEXT:    Name: .gnu.version_r
 # CHECK-NEXT:    Type: SHT_GNU_verneed (0x6FFFFFFE)
 # CHECK-NEXT:    Flags [ (0x2)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:    ]
 # CHECK-NEXT:    Address: [[VERNEED:.*]]
-# CHECK-NEXT:    Offset: 0x230
+# CHECK-NEXT:    Offset: 0x268
 # CHECK-NEXT:    Size: 80
 # CHECK-NEXT:    Link: 5
 # CHECK-NEXT:    Info: 2
 # CHECK-NEXT:    AddressAlignment: 4
 # CHECK-NEXT:    EntrySize: 0
 
 # CHECK:          Index: [[DYNSTR]]
 # CHECK-NEXT:     Name: .dynstr
 # CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 # CHECK-NEXT:     Flags [ (0x2)
 # CHECK-NEXT:       SHF_ALLOC (0x2)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     Address: 0x2002A8
-# CHECK-NEXT:     Offset: 0x2A8
+# CHECK-NEXT:     Address: 0x2002E0
+# CHECK-NEXT:     Offset: 0x2E0
 # CHECK-NEXT:     Size: 47
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:     SectionData (
 # CHECK-NEXT:       0000: 00663100 7665726E 65656431 2E736F2E  |.f1.verneed1.so.|
 # CHECK-NEXT:       0010: 30007633 00663200 76320067 31007665  |0.v3.f2.v2.g1.ve|