[ELF] Make non-writable non-executable PROGBITS sections closer to .text

[MaskRay]

The idea is that we should place .text in the middle and huge data sections on both sides:

The desired order is roughly:

.dynstr / .dymstr
.rodata .eh_frame .eh_frame_hdr  # they can be huge and we don't want them placed between .text and .bss
# preferably .rodata is immediately before .text 
.text
.data
.bss

Effect:

[Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
[ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
[ 1] .interp           PROGBITS        0000000000200270 000270 00001c 00   A  0   0  1
[ 2] .dynsym           DYNSYM          0000000000200290 000290 0000c0 18   A  7   1  8
[ 3] .gnu.version      VERSYM          0000000000200350 000350 000010 02   A  2   0  2
[ 4] .gnu.version_r    VERNEED         0000000000200360 000360 000020 00   A  7   1  4
[ 5] .gnu.hash         GNU_HASH        0000000000200380 000380 000020 00   A  2   0  8
[ 6] .hash             HASH            00000000002003a0 0003a0 000048 04   A  2   0  4
[ 7] .dynstr           STRTAB          00000000002003e8 0003e8 000097 00   A  0   0  1
[ 8] .rela.dyn         RELA            0000000000200480 000480 000048 18   A  2   0  8
[ 9] .rela.plt         RELA            00000000002004c8 0004c8 000030 18   A  2   0  8
[10] .note.ABI-tag     NOTE            00000000002004f8 0004f8 000020 00   A  0   0  4
[11] .note.gnu.property NOTE            0000000000200518 000518 000040 00   A  0   0  8
[12] .rodata           PROGBITS        0000000000200560 000560 000403 00 AMS  0   0 16
[13] .eh_frame_hdr     PROGBITS        0000000000200964 000964 00002c 00   A  0   0  4
[14] .eh_frame         PROGBITS        0000000000200990 000990 0000cc 00   A  0   0  8
[15] .text             PROGBITS        0000000000201000 001000 0001a2 00  AX  0   0 16
[16] .init             PROGBITS        00000000002011a4 0011a4 000017 00  AX  0   0  4
[17] .fini             PROGBITS        00000000002011bc 0011bc 000009 00  AX  0   0  4
[18] .plt              PROGBITS        00000000002011d0 0011d0 000030 00  AX  0   0 16
[19] .data             PROGBITS        0000000000202000 002000 000010 00  WA  0   0  8
[20] .tm_clone_table   PROGBITS        0000000000202010 002010 000000 00  WA  0   0  8
[21] .got.plt          PROGBITS        0000000000202010 002010 000028 00  WA  0   0  8
[22] .fini_array       FINI_ARRAY      0000000000203000 003000 000008 08  WA  0   0  8
[23] .init_array       INIT_ARRAY      0000000000203008 003008 000008 08  WA  0   0  8
[24] .dynamic          DYNAMIC         0000000000203010 003010 0001a0 10  WA  7   0  8
[25] .got              PROGBITS        00000000002031b0 0031b0 000010 00  WA  0   0  8
[26] .bss              NOBITS          0000000000204000 0031c0 0003f8 00  WA  0   0 16
[27] .comment          PROGBITS        0000000000000000 0031c0 0000aa 01  MS  0   0  1
[28] .symtab           SYMTAB          0000000000000000 003270 000378 18     30  19  8
[29] .shstrtab         STRTAB          0000000000000000 0035e8 00011e 00      0   0  1
[30] .strtab           STRTAB          0000000000000000 003706 0001fb 00      0   0  1

The Flg Type columns look better and we can remove that DYNSTR DYNSYM special case.

There are 60+ tests failing because of changed addresses and I'll fix them. Just sending it for review first so that I don't need to change the tests back and forth...

[echristo]

OK, this ranking looks good to me. Go ahead and put your long comment with the layout into your commit message and do fix up the tests.

-eric

[MaskRay]

[12] .rodata           PROGBITS        0000000000200560 000560 000403 00 AMS  0   0 16
[13] .eh_frame_hdr     PROGBITS        0000000000200964 000964 00002c 00   A  0   0  4
[14] .eh_frame         PROGBITS        0000000000200990 000990 0000cc 00   A  0   0  8
[15] .text             PROGBITS        0000000000201000 001000 0001a2 00  AX  0   0 16

I want to make .rodata and .text back-to-back, but not sure how to make such heuristic more general...

[MaskRay]

Update all tests.

[ruiu]

LGTM with these changes.

lld/trunk/ELF/Writer.cpp

704

I'd name this RF_RODATA for conciseness.

760–766

nit: I'd avoid writing a long comment before else if because it visually split a consecutive if ~ else if ~ else expressions. This is probably better:

if (IsWriter) {
  ...
} else if (...) {
  // your comment here
  your code here
}

That said, the best way to arrange this particular piece code is to replace else { if with else if like this

if (IsExec) {
  ...
} else if (IsWriter) {
  ...
} else if (Sec->Type == SHT_PROGBITS) {
  ...
}

762

space before .

[MaskRay]

lld/trunk/ELF/Writer.cpp

760–766

Done in r335743

762

I tend to avoid immediate trailing dot when the last word is an identifier (OT: when I double click it, the trailing dot will be a part of the selection) or URL (slight OT: trailing punctuation is not friendly to some terminals). That said, I don't have a strong preference here so I'll follow yours.

lld/trunk/ELF/Writer.cpp

 // * It is easy two see how similar two ranks are (see getRankProximity).
 enum RankFlags {
   RF_NOT_ADDR_SET = 1 << 18,
   RF_NOT_INTERP = 1 << 17,
   RF_NOT_ALLOC = 1 << 16,
   RF_WRITE = 1 << 15,
   RF_EXEC_WRITE = 1 << 14,
   RF_EXEC = 1 << 13,
-  RF_NON_TLS_BSS = 1 << 12,
-  RF_NON_TLS_BSS_RO = 1 << 11,
-  RF_NOT_TLS = 1 << 10,
-  RF_ALLOC_FIRST = 1 << 9,
+  RF_PROGBITS_NOT_EXEC_OR_WRITE = 1 << 12,
+  RF_NON_TLS_BSS = 1 << 11,
+  RF_NON_TLS_BSS_RO = 1 << 10,
+  RF_NOT_TLS = 1 << 9,
   RF_BSS = 1 << 8,
   RF_NOTE = 1 << 7,
   RF_PPC_NOT_TOCBSS = 1 << 6,
   RF_PPC_TOCL = 1 << 5,
   RF_PPC_TOC = 1 << 4,
   RF_PPC_GOT = 1 << 3,
   RF_PPC_BRANCH_LT = 1 << 2,
   RF_MIPS_GPREL = 1 << 1,
if (Sec->Name == ".interp")
     return Rank;
   Rank |= RF_NOT_INTERP;
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
   if (!(Sec->Flags & SHF_ALLOC))
     return Rank | RF_NOT_ALLOC;
 
-  // Place .dynsym and .dynstr at the beginning of SHF_ALLOC
-  // sections. We want to do this to mitigate the possibility that
-  // huge .dynsym and .dynstr sections placed between ro-data and text
-  // sections cause relocation overflow.  Note: .dynstr has SHT_STRTAB
-  // type and SHF_ALLOC attribute, whereas sections that only have
-  // SHT_STRTAB but without SHF_ALLOC is placed at the end. All "Sec"
-  // reaching here has SHF_ALLOC bit set.
-  if (Sec->Type == SHT_DYNSYM || Sec->Type == SHT_STRTAB)
-    return Rank | RF_ALLOC_FIRST;
-
   // Sort sections based on their access permission in the following
   // order: R, RX, RWX, RW.  This order is based on the following
   // considerations:
   // * Read-only sections come first such that they go in the
   //   PT_LOAD covering the program headers at the start of the file.
   // * Read-only, executable sections come next.
   // * Writable, executable sections follow such that .plt on
   //   architectures where it needs to be writable will be placed
   //   between .text and .data.
   // * Writable sections come last, such that .bss lands at the very
   //   end of the last PT_LOAD.
   bool IsExec = Sec->Flags & SHF_EXECINSTR;
   bool IsWrite = Sec->Flags & SHF_WRITE;
 
   if (IsExec) {
     if (IsWrite)
       Rank |= RF_EXEC_WRITE;
     else
       Rank |= RF_EXEC;
   } else {
     if (IsWrite)
       Rank |= RF_WRITE;
+    // 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.
+    else if (Sec->Type == SHT_PROGBITS)
+      Rank |= RF_PROGBITS_NOT_EXEC_OR_WRITE;
   }
 
   // If we got here we know that both A and B are in the same PT_LOAD.
 
   bool IsTls = Sec->Flags & SHF_TLS;
   bool IsNoBits = Sec->Type == SHT_NOBITS;
 
   // The first requirement we have is to put (non-TLS) nobits sections last. The

lld/trunk/test/ELF/aarch64-copy.s

 // Page(S + A) - Page(P) = 0x40000 - 0x20000 = 0x20000 = 131072
 // CODE-NEXT:  20004: {{.*}} adrp x2, #131072
 // S(y) = 0x40010, A = 0
 // (S + A) & 0xFFF = 0x10 = 16
 // CODE-NEXT:  20008: {{.*}} add  x2, x2, #16
 
 // RODATA: Contents of section .rodata:
 // S(z) = 0x40014
-// RODATA-NEXT:  10246 14000400
+// RODATA-NEXT:  102e0 14000400

lld/trunk/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: 28fbffff ffffffff
+# OBJDUMP: d0f8ffff ffffffff
 
 # OBJDUMP: Contents of section nonalloc:
 # OBJDUMP-NEXT: 0000 00000000 04480000 00000000 08440000
 # OBJDUMP-NEXT: 00000000 0c400000

lld/trunk/test/ELF/arm-copy.s

 // CHECK-NEXT:     Address: 0x13000
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 8
 // CHECK-NEXT:     Link:
 // CHECK-NEXT:     Info:
 // CHECK-NEXT:     AddressAlignment: 16
 
 // CHECK: Relocations [
-// CHECK-NEXT:  Section (5) .rel.dyn {
+// CHECK-NEXT:  Section {{.*}} .rel.dyn {
 // CHECK-NEXT:    Relocation {
 // CHECK-NEXT:      Offset: 0x13000
 // CHECK-NEXT:      Type: R_ARM_COPY
 // CHECK-NEXT:      Symbol: y
 // CHECK-NEXT:      Addend: 0x0
 // CHECK-NEXT:    }
 // CHECK-NEXT:    Relocation {
 // CHECK-NEXT:      Offset: 0x13004

 // ((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: 10160 04300100
+// RODATA-NEXT: 10190 04300100

lld/trunk/test/ELF/arm-execute-only.s

 // REQUIRES: arm
 
 // RUN: llvm-mc -filetype=obj -triple=armv7-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t.so -shared
 // RUN: llvm-readelf -l %t.so | FileCheck %s
 
 // RUN: ld.lld %t.o %t.o -o %t.so -shared
 // RUN: llvm-readelf -l %t.so | FileCheck %s
 
 // RUN: echo ".section .foo,\"ax\"; \
 // RUN:       bx lr" > %t.s
 // RUN: llvm-mc -filetype=obj -triple=armv7-pc-linux %t.s -o %t2.o
 // RUN: ld.lld %t.o %t2.o -o %t.so -shared
 // RUN: llvm-readelf -l %t.so | FileCheck --check-prefix=DIFF %s
 
 // CHECK-NOT:  LOAD
-// CHECK:      LOAD           0x000000 0x00000000 0x00000000 0x00170 0x00170  R 0x1000
+// CHECK:      LOAD           0x000000 0x00000000 0x00000000 0x0016d 0x0016d  R 0x1000
 // CHECK:      LOAD           0x001000 0x00001000 0x00001000 0x{{.*}} 0x{{.*}} R E 0x1000
 // CHECK:      LOAD           0x002000 0x00002000 0x00002000 0x{{.*}} 0x{{.*}}   E 0x1000
 // CHECK:      LOAD           0x003000 0x00003000 0x00003000 0x00038  0x00038  RW  0x1000
 // CHECK-NOT:  LOAD
 
-// CHECK: 01     .dynsym .dynstr .gnu.hash .hash
+// CHECK: 01     .dynsym .gnu.hash .hash .dynstr
 // CHECK: 02     .text
 // CHECK: 03     .foo
 // CHECK: 04     .dynamic
 
 // DIFF-NOT:  LOAD
-// DIFF:      LOAD           0x000000 0x00000000 0x00000000 0x00150 0x00150 R   0x1000
+// DIFF:      LOAD           0x000000 0x00000000 0x00000000 0x0014d 0x0014d R   0x1000
 // DIFF:      LOAD           0x001000 0x00001000 0x00001000 0x0000c 0x0000c R E 0x1000
 // DIFF:      LOAD           0x002000 0x00002000 0x00002000 0x00038 0x00038 RW  0x1000
 // DIFF-NOT:  LOAD
 
-// DIFF: 01     .dynsym .dynstr .gnu.hash .hash
+// DIFF: 01     .dynsym .gnu.hash .hash .dynstr
 // DIFF: 02     .text .foo
 // DIFF: 03     .dynamic
 
         bx lr
         .section .foo,"axy"
         bx lr

lld/trunk/test/ELF/arm-exidx-shared.s

  .fnend
 
  .section .text.__aeabi_unwind_cpp_pr0, "ax", %progbits
  .global __aeabi_unwind_cpp_pr0
 __aeabi_unwind_cpp_pr0:
  bx lr
 
 // CHECK: Relocations [
-// CHECK-NEXT:   Section (6) .rel.plt {
+// CHECK-NEXT:   Section {{.*}} .rel.plt {
 // CHECK-NEXT:     0x200C R_ARM_JUMP_SLOT __gxx_personality_v0
 
 // CHECK-EXTAB: Contents of section .ARM.extab:
-// 01d8 + 0e58 = 0x1030 = __gxx_personality_v0(PLT)
-// CHECK-EXTAB-NEXT:  01d8 580e0000 b0b0b000 00000000
+// 0x0210 + 0x0e20 = 0x1030 = __gxx_personality_v0(PLT)
+// CHECK-EXTAB-NEXT:  0210 200e0000 b0b0b000 00000000

lld/trunk/test/ELF/arm-target2.s

  .type function, %function
 __gxx_personality_v0:
  bx lr
 
  .rodata
 _ZTIi:  .word 0
 
 // CHECK: Contents of section .ARM.extab:
-// 1011c + 1ee4 = 12000 = .got
-// CHECK-NEXT:  10114 f00e0000 b0b0b000 e41e0000
+// 0x1012c + 0x1ed4 = 0x12000 = .got
+// CHECK-NEXT:  10124 e00e0000 b0b0b000 d41e0000
 
 // CHECK-ABS: Contents of section .ARM.extab:
-// 100f0 = .rodata
-// CHECK-ABS-NEXT: 100d4 300f0000 b0b0b000 f0000100
+// 0x100f0 = .rodata
+// CHECK-ABS-NEXT: 100e4 200f0000 b0b0b000 f0000100
 
 // CHECK-REL: Contents of section .ARM.extab:
-// 100dc + c = 100e8 = .rodata
-// CHECK-REL-NEXT: 100d4 300f0000 b0b0b000 14000000
+// 0x100ec + 4 = 0x100f0 = .rodata
+// CHECK-REL-NEXT: 100e4 200f0000 b0b0b000 04000000
 
 // CHECK: Contents of section .rodata:
 // CHECK-NEXT: 10130 00000000
 
 // CHECK-ABS: Contents of section .rodata:
 // CHECK-ABS-NEXT: 100f0 00000000
 
 // CHECK-REL: Contents of section .rodata:
 // CHECK-REL-NEXT: 100f0 00000000
 
 // CHECK: Contents of section .got:
 // 10130 = _ZTIi
 // CHECK-NEXT: 12000 30010100

lld/trunk/test/ELF/basic-ppc.s

 // CHECK-NEXT:     Name: .dynsym
 // CHECK-NEXT:     Type: SHT_DYNSYM (0xB)
 // CHECK-NEXT:     Flags [ (0x2)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x114
 // CHECK-NEXT:     Offset: 0x114
 // CHECK-NEXT:     Size: 16
-// CHECK-NEXT:     Link: 2
+// CHECK-NEXT:     Link: 3
 // CHECK-NEXT:     Info: 1
 // CHECK-NEXT:     AddressAlignment: 4
 // CHECK-NEXT:     EntrySize: 16
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 2
-// CHECK-NEXT:     Name: .dynstr
-// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+// CHECK-NEXT:     Name: .hash
+// CHECK-NEXT:     Type: SHT_HASH (0x5)
 // CHECK-NEXT:     Flags [ (0x2)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x124
 // CHECK-NEXT:     Offset: 0x124
-// CHECK-NEXT:     Size: 1
-// CHECK-NEXT:     Link: 0
+// CHECK-NEXT:     Size: 16
+// CHECK-NEXT:     Link: 1
 // CHECK-NEXT:     Info: 0
-// CHECK-NEXT:     AddressAlignment: 1
-// CHECK-NEXT:     EntrySize: 0
+// CHECK-NEXT:     AddressAlignment: 4
+// CHECK-NEXT:     EntrySize: 4
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 00                                   |.|
+// CHECK-NEXT:       0000: 00000001 00000001 00000000 00000000  |................|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 3
-// CHECK-NEXT:     Name: .hash
-// CHECK-NEXT:     Type: SHT_HASH (0x5)
+// CHECK-NEXT:     Name: .dynstr
+// CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:     Flags [ (0x2)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address: 0x128
-// CHECK-NEXT:     Offset: 0x128
-// CHECK-NEXT:     Size: 16
-// CHECK-NEXT:     Link: 1
+// CHECK-NEXT:     Address: 0x134
+// CHECK-NEXT:     Offset: 0x134
+// CHECK-NEXT:     Size: 1
+// CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
-// CHECK-NEXT:     AddressAlignment: 4
-// CHECK-NEXT:     EntrySize: 4
+// CHECK-NEXT:     AddressAlignment: 1
+// CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 00000001 00000001 00000000 00000000  |................|
+// CHECK-NEXT:       0000: 00                                   |.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 4
 // CHECK-NEXT:     Name: .text
 // CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:     Flags [ (0x6)
 // CHECK-NEXT:       SHF_ALLOC (0x2)

 // CHECK-NEXT:     Type: SHT_DYNAMIC (0x6)
 // CHECK-NEXT:     Flags [ (0x3)
 // CHECK-NEXT:       SHF_ALLOC (0x2)
 // CHECK-NEXT:       SHF_WRITE (0x1)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x2000
 // CHECK-NEXT:     Offset: 0x2000
 // CHECK-NEXT:     Size: 48
-// CHECK-NEXT:     Link: 2
+// CHECK-NEXT:     Link: 3
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 4
 // CHECK-NEXT:     EntrySize: 8
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 00000006 00000114 0000000B 00000010  |................|
-// CHECK-NEXT:       0010: 00000005 00000124 0000000A 00000001  |.......$........|
-// CHECK-NEXT:       0020: 00000004 00000128 00000000 00000000  |.......(........|
+// CHECK-NEXT:       0000: 00000006 00000114 0000000B 00000010
+// CHECK-NEXT:       0010: 00000005 00000134 0000000A 00000001
+// CHECK-NEXT:       0020: 00000004 00000124 00000000 00000000
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 6
 // CHECK-NEXT:     Name: .comment
 // CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:     Flags [ (0x30)
 // CHECK-NEXT:       SHF_MERGE (0x10)

 // CHECK-NEXT:     Address: 0x0
 // CHECK-NEXT:     Offset: 0x2058
 // CHECK-NEXT:     Size: 73
 // CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 1
 // CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 002E6479 6E73796D 002E6479 6E737472  |..dynsym..dynstr|
-// CHECK-NEXT:       0010: 002E6861 7368002E 74657874 002E6479  |..hash..text..dy|
+// CHECK-NEXT:       0000: 002E6479 6E73796D 002E6861 7368002E  |..dynsym..hash..|
+// CHECK-NEXT:       0010: 64796E73 7472002E 74657874 002E6479  |dynstr..text..dy|
 // CHECK-NEXT:       0020: 6E616D69 63002E63 6F6D6D65 6E74002E  |namic..comment..|
 // CHECK-NEXT:       0030: 73796D74 6162002E 73687374 72746162  |symtab..shstrtab|
 // CHECK-NEXT:       0040: 002E7374 72746162 00                 |..strtab.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 9
 // CHECK-NEXT:     Name: .strtab

 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Alignment: 4
 // 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: 312
-// CHECK-NEXT:     MemSize: 312
+// CHECK-NEXT:     FileSize: 309
+// CHECK-NEXT:     MemSize: 309
 // CHECK-NEXT:     Flags [ (0x4)
 // CHECK-NEXT:       PF_R (0x4)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Alignment: 4096
 // CHECK-NEXT:   }
 // CHECK-NEXT:   ProgramHeader {
 // CHECK-NEXT:     Type: PT_LOAD (0x1)
 // CHECK-NEXT:     Offset: 0x1000

lld/trunk/test/ELF/basic-ppc64.s

 // 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:    Size: 24
-// CHECK-NEXT:    Link: 2
+// 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: .dynstr (9)
-// CHECK-NEXT:    Type: SHT_STRTAB (0x3)
+// 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:    Size: 1
-// CHECK-NEXT:    Link: 0
+// CHECK-NEXT:    Size: 16
+// CHECK-NEXT:    Link: 1
 // CHECK-NEXT:    Info: 0
-// CHECK-NEXT:    AddressAlignment: 1
-// CHECK-NEXT:    EntrySize: 0
+// CHECK-NEXT:    AddressAlignment: 4
+// CHECK-NEXT:    EntrySize: 4
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 00                                   |.|
+// CHECK-NEXT:      0000: 01000000 01000000 00000000 00000000  |................|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 3
-// CHECK-NEXT:    Name: .hash (17)
-// CHECK-NEXT:    Type: SHT_HASH (0x5)
+// 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: 0x1E4
-// CHECK-NEXT:    Offset: 0x1E4
-// CHECK-NEXT:    Size: 16
-// CHECK-NEXT:    Link: 1
+// CHECK-NEXT:    Address: 0x1F0
+// CHECK-NEXT:    Offset: 0x1F0
+// CHECK-NEXT:    Size: 1
+// CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
-// CHECK-NEXT:    AddressAlignment: 4
-// CHECK-NEXT:    EntrySize: 4
+// CHECK-NEXT:    AddressAlignment: 1
+// CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 01000000 01000000 00000000 00000000  |................|
+// CHECK-NEXT:      0000: 00                                   |.|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 4
 // CHECK-NEXT:    Name: .text (23)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x6)
 // CHECK-NEXT:      SHF_ALLOC (0x2)

 // CHECK-NEXT:    Type: SHT_DYNAMIC (0x6)
 // CHECK-NEXT:    Flags [ (0x3)
 // CHECK-NEXT:      SHF_ALLOC (0x2)
 // CHECK-NEXT:      SHF_WRITE (0x1)
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: 0x20000
 // CHECK-NEXT:    Offset: 0x20000
 // CHECK-NEXT:    Size: 96
-// CHECK-NEXT:    Link: 2
+// 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 E0010000 00000000  |................|
+// CHECK-NEXT:      0020: 05000000 00000000 F0010000 00000000  |................|
 // CHECK-NEXT:      0030: 0A000000 00000000 01000000 00000000  |................|
-// CHECK-NEXT:      0040: 04000000 00000000 E4010000 00000000  |................|
+// CHECK-NEXT:      0040: 04000000 00000000 E0010000 00000000  |................|
 // CHECK-NEXT:      0050: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 6
 // CHECK-NEXT:    Name: .comment (38)
 // CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
 // CHECK-NEXT:    Flags [ (0x30)

 // CHECK-NEXT:    Address: 0x0
 // CHECK-NEXT:    Offset: 0x20098
 // CHECK-NEXT:    Size: 73
 // CHECK-NEXT:    Link: 0
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 1
 // CHECK-NEXT:    EntrySize: 0
 // CHECK-NEXT:    SectionData (
-// CHECK-NEXT:      0000: 002E6479 6E73796D 002E6479 6E737472  |..dynsym..dynstr|
-// CHECK-NEXT:      0010: 002E6861 7368002E 74657874 002E6479  |..hash..text..dy|
+// CHECK-NEXT:      0000: 002E6479 6E73796D 002E6861 7368002E  |..dynsym..hash..|
+// CHECK-NEXT:      0010: 64796E73 7472002E 74657874 002E6479  |dynstr..text..dy|
 // CHECK-NEXT:      0020: 6E616D69 63002E63 6F6D6D65 6E74002E  |namic..comment..|
 // CHECK-NEXT:      0030: 73796D74 6162002E 73687374 72746162  |symtab..shstrtab|
 // CHECK-NEXT:      0040: 002E7374 72746162 00                 |..strtab.|
 // CHECK-NEXT:    )
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Section {
 // CHECK-NEXT:    Index: 9
 // CHECK-NEXT:    Name: .strtab (65)

 // 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: 500
-// CHECK-NEXT:    MemSize: 500
+// CHECK-NEXT:    FileSize: 497
+// CHECK-NEXT:    MemSize: 497
 // 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

lld/trunk/test/ELF/dynamic-no-rosegment.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -shared --no-rosegment -z rodynamic -o %t %t.o
 # RUN: llvm-readobj -dynamic-table -s %t | FileCheck %s
 
 # CHECK:      DynamicSection [ (7 entries)
 # CHECK-NEXT:   Tag                Type                 Name/Value
 # CHECK-NEXT:   0x0000000000000006 SYMTAB               0x120
 # CHECK-NEXT:   0x000000000000000B SYMENT               24 (bytes)
-# CHECK-NEXT:   0x0000000000000005 STRTAB               0x138
+# CHECK-NEXT:   0x0000000000000005 STRTAB               0x1D8
 # CHECK-NEXT:   0x000000000000000A STRSZ                1 (bytes)
-# CHECK-NEXT:   0x000000006FFFFEF5 GNU_HASH             0x140
-# CHECK-NEXT:   0x0000000000000004 HASH                 0x15C
+# CHECK-NEXT:   0x000000006FFFFEF5 GNU_HASH             0x138
+# CHECK-NEXT:   0x0000000000000004 HASH                 0x154
 # CHECK-NEXT:   0x0000000000000000 NULL                 0x0
 # CHECK-NEXT: ]

lld/trunk/test/ELF/dynsec-at-beginning.s

-# REQUIRES: x86
-# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
-
-# RUN: ld.lld --hash-style=gnu -o %t1  %t -shared
-# RUN: llvm-readelf -s %t1 | FileCheck %s
-
-# Dynamic symbol and dynamic strtab sections are at the beginning of
-# SHF_ALLOC sections.
-# CHECK:      .dynsym  {{.*}}   A
-# CHECK-NEXT: .dynstr  {{.*}}   A
-# CHECK-NEXT: foo      {{.*}}   A
-# CHECK-NEXT: .hash    {{.*}}   A
-# CHECK-NEXT: .text    {{.*}}   AX
-
-.section foo, "a"
-.byte 0

lld/trunk/test/ELF/gc-merge-local-sym.s

 // REQUIRES: x86
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: ld.lld %t.o -o %t.so -shared -O3 --gc-sections
 // RUN: llvm-readobj -s -section-data -t %t.so | FileCheck %s
 
 // CHECK:      Name: .rodata
 // 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: 0x1FD
+// CHECK-NEXT: Address: 0x235
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 1
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300 |abc.|

lld/trunk/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      Address
-# CHECK:  .rela.plt   00000030 0000000000000218
+# CHECK:  .rela.plt   00000030 0000000000000210
 # CHECK:  .got.plt    00000010 0000000000002000
 
 # 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               0x218
+# TAGS:   0x0000000000000017 JMPREL               0x210
 # TAGS:   0x0000000000000002 PLTRELSZ             48
 # TAGS:   0x0000000000000003 PLTGOT               0x2000
 # TAGS:   0x0000000000000014 PLTREL               RELA
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:

lld/trunk/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: 0x128
+// CHECK-NEXT: Address: 0x158
 // 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: 0x1000
 // CHECK-NEXT: Offset: 0x1000
 // 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: 28010000 |
+// CHECK-NEXT:   0000: 58010000 |
 // CHECK-NEXT: )
 
-// The content of .data should be the address of .mysec. 14010000 is 0x114 in
-// little endian.
+// 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

lld/trunk/test/ELF/linkerscript/align-empty.test

SECTIONS {
   . = ALIGN(0x1000);
   foo : { *(foo) }
 }
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address
 # CHECK-NEXT:   0               00000000 0000000000000000
 # CHECK-NEXT:   1 .dynsym       00000018 0000000000000190
-# CHECK-NEXT:   2 .dynstr       00000001 00000000000001a8
-# CHECK-NEXT:   3 foo           00000001 0000000000001000
+# CHECK-NEXT:   2 .gnu.hash     0000001c 00000000000001a8
+# CHECK-NEXT:   3 .hash         00000010 00000000000001c4
+# CHECK-NEXT:   4 .dynstr       00000001 00000000000001d4
+# CHECK-NEXT:   5 foo           00000001 0000000000001000

lld/trunk/test/ELF/linkerscript/implicit-program-header.test

 # REQUIRES: x86
 
 # RUN: echo '.section .text,"ax"; .quad 0' > %t.s
 # RUN: echo '.section .foo,"ax"; .quad 0' >> %t.s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t.s -o %t.o
 # RUN: ld.lld --hash-style=sysv -o %t1 --script %s %t.o -shared
 # RUN: llvm-readelf -l %t1 | FileCheck %s
 
 # CHECK:      Segment Sections...
-# CHECK-NEXT:   00     .dynsym .dynstr .hash .bar .foo .text .dynamic
+# CHECK-NEXT:   00     .dynsym .hash .dynstr .bar .foo .text .dynamic
 # CHECK-NEXT:   01     .bar .foo
 
 PHDRS {
   ph_write PT_LOAD FLAGS(2);
   ph_exec  PT_LOAD FLAGS(1);
 }
 
 SECTIONS {
   .bar : { *(.bar) } : ph_exec
   .foo : { *(.foo) }
   .text : { *(.text) } : ph_write
 }

lld/trunk/test/ELF/linkerscript/merge-sections-syms.s

 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding:
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: A
-# CHECK-NEXT:     Value: 0x1E2
+# CHECK-NEXT:     Value: 0x226
 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding:
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section:
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: B
-# CHECK-NEXT:     Value: 0x1E3
+# CHECK-NEXT:     Value: 0x227
 # CHECK-NEXT:     Size:
 # CHECK-NEXT:     Binding:
 # CHECK-NEXT:     Type:
 # CHECK-NEXT:     Other:
 # CHECK-NEXT:     Section:
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 

lld/trunk/test/ELF/linkerscript/merge-sections.s

 # CHECK-NEXT:   AddressAlignment: 2
 # CHECK-NEXT:   EntrySize: 0
 # CHECK-NEXT: }
 
 # CHECK:      Name: begin
 # CHECK-NEXT: Value: 0x[[ADDR1]]
 
 # CHECK:      Name: end
-# 0x19E = begin + sizeof(.foo) = 0x190 + 0xE
-# CHECK-NEXT: Value: 0x1F2
+# CHECK-NEXT: Value: 0x236
 
 # Check that we don't crash with --gc-sections
 # RUN: ld.lld --gc-sections -o %t2 --script %t.script %t -shared
 # RUN: llvm-readobj -s -t %t2 | FileCheck %s --check-prefix=GC
 
 # GC:        Name: .foo
 # GC-NEXT:   Type: SHT_NOBITS
 # GC-NEXT:   Flags [

lld/trunk/test/ELF/linkerscript/no-space.s

 # after it. Don't create a PT_PHDR as the header is not allocated.
 
 # CHECK: Program Headers:
 # CHECK-NEXT: Type  Offset   VirtAddr           PhysAddr
 # CHECK-NEXT: LOAD  0x001000 0x0000000000000000 0x0000000000000000
 
 # CHECK:      Section to Segment mapping:
 # CHECK-NEXT:  Segment Sections...
-# CHECK-NEXT:   00     foo .hash .dynsym .dynstr
+# CHECK-NEXT:   00     foo .dynsym .dynstr .hash
 
 .section foo, "a"
 .quad 0

lld/trunk/test/ELF/linkerscript/non-absolute2.test

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux /dev/null -o %t1.o
 # RUN: ld.lld -shared %t1.o --script %s -o %t
 # RUN: llvm-objdump -section-headers -t %t | FileCheck %s
 
 SECTIONS {
   A = . + 0x1;
   . += 0x1000;
 }
 
 # CHECK:       Sections:
-# CHECK-NEXT:  Idx Name          Size      Address          Type
-# CHECK-NEXT:    0               00000000 0000000000000000 
-# CHECK-NEXT:    1 .dynsym       00000030 0000000000001000 
-# CHECK-NEXT:    2 .dynstr       00000003 0000000000001030 
-# CHECK:         5 .text         00000000 0000000000001070
+# CHECK-NEXT:  Idx Name          Size      Address
+# CHECK-NEXT:    0               00000000 0000000000000000
+# CHECK-NEXT:    1 .dynsym       00000030 0000000000001000
+# CHECK:         5 .text         00000000 000000000000106c
 
 # CHECK: 0000000000000001         .dynsym            00000000 A

lld/trunk/test/ELF/linkerscript/non-alloc.s

 
 # CHECK: Program Headers:
 # CHECK-NEXT:  Type
 # CHECK-NEXT:  LOAD {{.*}} R E
 # CHECK-NEXT:  LOAD {{.*}} RW
 
 # CHECK:      Section to Segment mapping:
 # CHECK-NEXT:  Segment Sections...
-# CHECK-NEXT:   00     .dynsym .dynstr .hash .text
+# CHECK-NEXT:   00     .dynsym .hash .dynstr .text
 # CHECK-NEXT:   01     .dynamic
 
 nop
 .section foo
 .quad 0

lld/trunk/test/ELF/linkerscript/overlapping-sections.s

 # Verify that the .sec2 was indeed placed in a PT_LOAD where the PhysAddr
 # overlaps with where .sec1 is loaded:
 # RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-LMA
 # BAD-LMA-LABEL: Section Headers:
 # BAD-LMA: .sec1             PROGBITS        0000000000008000 002000 000100 00  WA  0   0  1
 # BAD-LMA: .sec2             PROGBITS        0000000000008800 002800 000100 00  WA  0   0  1
 # BAD-LMA-LABEL: Program Headers:
 # BAD-LMA-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-# BAD-LMA-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x000104 0x000104 R E 0x1000
+# BAD-LMA-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x000100 0x000100 R E 0x1000
 # BAD-LMA-NEXT:  LOAD           0x002000 0x0000000000008000 0x0000000000008000 0x000100 0x000100 RW  0x1000
 # BAD-LMA-NEXT:  LOAD           0x002800 0x0000000000008800 0x0000000000008080 0x000170 0x000170 RW  0x1000
 # BAD-LMA-LABEL: Section to Segment mapping:
 # BAD-LMA:  01     .sec1
 # BAD-LMA:  02     .sec2 .dynamic
 
 # Now try a script where the virtual memory addresses overlap but ensure that the
 # load addresses don't:

 # Check that the expected binary was created with --noinhibit-exec:
 # RUN: ld.lld -o %t.so --script %t-vaddr.script %t.o -shared --noinhibit-exec
 # RUN: llvm-readobj -sections -program-headers -elf-output-style=GNU %t.so | FileCheck %s -check-prefix BAD-VADDR
 # BAD-VADDR-LABEL: Section Headers:
 # BAD-VADDR: .sec1             PROGBITS        0000000000008000 002000 000100 00  WA  0   0  1
 # BAD-VADDR: .sec2             PROGBITS        0000000000008020 003020 000100 00  WA  0   0  1
 # BAD-VADDR-LABEL: Program Headers:
 # BAD-VADDR-NEXT:  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
-# BAD-VADDR-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x000104 0x000104 R E 0x1000
+# BAD-VADDR-NEXT:  LOAD           0x001000 0x0000000000000000 0x0000000000000000 0x000100 0x000100 R E 0x1000
 # BAD-VADDR-NEXT:  LOAD           0x002000 0x0000000000008000 0x0000000000008000 0x000100 0x000100 RW  0x1000
 # BAD-VADDR-NEXT:  LOAD           0x003020 0x0000000000008020 0x0000000000008800 0x000170 0x000170 RW  0x1000
 # BAD-VADDR-LABEL: Section to Segment mapping:
 # BAD-VADDR:  01     .sec1
 # BAD-VADDR:  02     .sec2 .dynamic
 
 # Finally check the case where both LMA and vaddr overlap
 

 # 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 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 0x000104 0x000104 R E 0x1000
+# BAD-BOTH-NEXT:  LOAD 0x001000 0x0000000000000000 0x0000000000000000 0x000100 0x000100 R E 0x1000
 # BAD-BOTH-NEXT:  LOAD           0x002000 0x0000000000008000 0x0000000000008000 0x0001b0 0x0001b0 RW  0x1000
 # BAD-BOTH-LABEL: Section to Segment mapping:
 # BAD-BOTH:   01     .sec1 .sec2 .dynamic
 
 .section        .first_sec,"aw",@progbits
 .rept 0x100
 .byte 1
 .endr
 
 .section        .second_sec,"aw",@progbits
 .rept 0x100
 .byte 2
 .endr

lld/trunk/test/ELF/linkerscript/sections-sort.s

 
 .section foo, "a"
 .byte 0
 
 # CHECK: Idx
 # CHECK-NEXT: 0
 # CHECK-NEXT: 1 .text
 # CHECK-NEXT: 2 .dynsym
-# CHECK-NEXT: 3 .dynstr
-# CHECK-NEXT: 4 foo
-# CHECK-NEXT: 5 .hash
+# CHECK-NEXT: 3 .hash
+# CHECK-NEXT: 4 .dynstr
+# CHECK-NEXT: 5 foo
 # CHECK-NEXT: 6 .dynamic
 # CHECK-NEXT: 7 .comment
 # CHECK-NEXT: 8 .symtab
 # CHECK-NEXT: 9 .shstrtab
 # CHECK-NEXT: 10 .strtab

lld/trunk/test/ELF/linkerscript/sort-non-script.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 # RUN: echo "SECTIONS { foo : {*(foo)} }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t --script %t.script %t.o -shared
 # RUN: llvm-readelf -s %t | FileCheck %s
 
 # CHECK:      .dynsym  {{.*}}   A
-# CHECK-NEXT: .dynstr  {{.*}}   A
 # CHECK-NEXT: .hash    {{.*}}   A
+# CHECK-NEXT: .dynstr  {{.*}}   A
 # CHECK-NEXT: .text    {{.*}}   AX
 # CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

lld/trunk/test/ELF/linkerscript/symbol-only.test

 # REQUIRES: x86
 # RUN: echo '.section bar, "a"' \
 # RUN:   | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t
 # RUN: ld.lld -o %t1 --script %s %t -shared
 # RUN: llvm-objdump -section-headers -t %t1 | FileCheck %s
 
 SECTIONS {
   . = SIZEOF_HEADERS;
   abc : { foo = .; }
   . = ALIGN(0x1000);
   bar : { *(bar) }
 }
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK:          abc           00000000 [[ADDR:[0-9a-f]*]] BSS
-# CHECK-NEXT:     .dynsym       00000030 0000000000000190
-# CHECK-NEXT:     .dynstr       00000005 00000000000001c0
-# CHECK-NEXT:     bar           00000000 0000000000001000 DATA
+# CHECK:          abc           00000000 [[ADDR:[0-9a-f]*]]
+# CHECK:          bar           00000000 0000000000001000
 
 # CHECK: SYMBOL TABLE:
 # CHECK:     [[ADDR]]         abc                00000000 foo

lld/trunk/test/ELF/linkerscript/unused-synthetic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { \
 # RUN:    .got  : { *(.got) *(.got) } \
 # RUN:    .plt  : { *(.plt) } \
 # RUN:    .text : { *(.text) } \
 # RUN:  }" > %t.script
 # RUN: ld.lld -shared -o %t.so --script %t.script %t.o
 
 # RUN: llvm-readelf -s %t.so | FileCheck %s
 # CHECK-NOT:  .got
 # CHECK-NOT:  .plt
 # CHECK:      .dynsym
-# CHECK-NEXT: .dynstr
-# CHECK-NEXT: .gnu.hash
 # CHECK:      .text
 
 # Test that the size of a removed unused synthetic input section is not added
 # to the output section size. Adding a symbol assignment prevents removal of
 # the output section, but does not cause the section size to be recomputed.
 # RUN: echo "SECTIONS { \
 # RUN:    .got.plt : { a_sym = .; *(.got.plt) } \
 # RUN:  }" > %t2.script
 # RUN: ld.lld -shared -o %t2.so --script %t2.script %t.o
 # RUN: llvm-objdump -section-headers %t2.so | FileCheck %s --check-prefix=CHECK2
 # CHECK2: .got.plt 00000000
 
 .global _start
 _start:
   nop

lld/trunk/test/ELF/map-file.s

 .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       31     1 .dynstr
-// CHECK-NEXT: 200240           200240       31     1         <internal>:(.dynstr)
-// 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: 2002d8           2002d8       30     8 .rela.dyn
-// CHECK-NEXT: 2002d8           2002d8       30     8         <internal>:(.rela.dyn)
-// CHECK-NEXT: 200308           200308       30     8 .rela.plt
-// CHECK-NEXT: 200308           200308       30     8         <internal>:(.rela.plt)
-// CHECK-NEXT: 200338           200338       64     8 .eh_frame
-// CHECK-NEXT: 200338           200338       2c     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x0)
-// CHECK-NEXT: 200368           200368       14     1         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.eh_frame+0x2c)
-// CHECK-NEXT: 200380           200380       18     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.eh_frame+0x18)
+// 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: 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

lld/trunk/test/ELF/merge-gc-piece.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.so -shared --gc-sections
 # RUN: llvm-readobj -s -section-data %t.so | FileCheck %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: 0x1C8
+# CHECK-NEXT: Address: 0x200
 
 # CHECK:      Name: .bar
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT: ]
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size: 16
 # CHECK-NEXT: Link:
 # CHECK-NEXT: Info:
 # CHECK-NEXT: AddressAlignment:
 # CHECK-NEXT: EntrySize:
 # CHECK-NEXT: SectionData (
-# CHECK-NEXT:   0000: C9010000 00000000 CA010000 00000000
+# CHECK-NEXT:   0000: 01020000 00000000 02020000 00000000
 # CHECK-NEXT: )
 
         .section .foo,"aM",@progbits,8
         .quad 42
         .global sym
 sym:
         .quad 43
 
         .section .bar
         .quad .foo + 1
         .quad .foo + 2

lld/trunk/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: 0x1E1
+// CHECK-NEXT: Address: 0x228
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1E2
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x229
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

lld/trunk/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: 0x1E4
+// CHECK-NEXT: Address: 0x228
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x1E6
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x22A
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

lld/trunk/test/ELF/merge-string.s

 
 // CHECK:      Name:    .rodata1
 // 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: 0x1E1
-// CHECK-NEXT: Offset: 0x1E1
+// CHECK-NEXT: Address: 0x20D
+// CHECK-NEXT: Offset: 0x20D
 // CHECK-NEXT: Size:    4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 1
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 61626300                             |abc.|
 // CHECK-NEXT: )
 
 // NOTAIL:      Name:    .rodata1
 // NOTAIL-NEXT: Type:    SHT_PROGBITS
 // NOTAIL-NEXT: Flags [
 // NOTAIL-NEXT:   SHF_ALLOC
 // NOTAIL-NEXT:   SHF_MERGE
 // NOTAIL-NEXT:   SHF_STRINGS
 // NOTAIL-NEXT: ]
-// NOTAIL-NEXT: Address: 0x1E1
-// NOTAIL-NEXT: Offset: 0x1E1
+// NOTAIL-NEXT: Address: 0x20D
+// NOTAIL-NEXT: Offset: 0x20D
 // NOTAIL-NEXT: Size:    7
 // NOTAIL-NEXT: Link: 0
 // NOTAIL-NEXT: Info: 0
 // NOTAIL-NEXT: AddressAlignment: 1
 // NOTAIL-NEXT: EntrySize: 1
 // NOTAIL-NEXT: SectionData (
 // NOTAIL-NEXT:   0000: 62630061 626300                     |bc.abc.|
 // NOTAIL-NEXT: )
 
 // NOMERGE:      Name:    .rodata1
 // NOMERGE-NEXT: Type:    SHT_PROGBITS
 // NOMERGE-NEXT: Flags [
 // NOMERGE-NEXT:   SHF_ALLOC
 // NOMERGE-NEXT:   SHF_MERGE
 // NOMERGE-NEXT:   SHF_STRINGS
 // NOMERGE-NEXT: ]
-// NOMERGE-NEXT: Address: 0x1E1
-// NOMERGE-NEXT: Offset: 0x1E1
+// NOMERGE-NEXT: Address: 0x20D
+// NOMERGE-NEXT: Offset: 0x20D
 // NOMERGE-NEXT: Size:    11
 // NOMERGE-NEXT: Link: 0
 // NOMERGE-NEXT: Info: 0
 // NOMERGE-NEXT: AddressAlignment: 1
 // NOMERGE-NEXT: EntrySize: 1
 // NOMERGE-NEXT: SectionData (
 // NOMERGE-NEXT:   0000: 61626300 61626300 626300 |abc.abc.bc.|
 // NOMERGE-NEXT: )
 
 // CHECK:      Name: .rodata2
 // 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: 0x1E6
-// CHECK-NEXT: Offset: 0x1E6
+// CHECK-NEXT: Address: 0x212
+// CHECK-NEXT: Offset: 0x212
 // CHECK-NEXT: Size: 4
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 2
 // CHECK-NEXT: EntrySize: 2
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 14000000                             |....|
 // CHECK-NEXT: )
 
 
 // CHECK:      Name:    bar
-// CHECK-NEXT: Value: 0x1E2
+// CHECK-NEXT: Value: 0x20E
 
 // CHECK:      Name:    foo
-// CHECK-NEXT: Value: 0x1E1
+// CHECK-NEXT: Value: 0x20D
 
 // CHECK:      Name: zed
-// CHECK-NEXT: Value: 0x1E6
+// CHECK-NEXT: Value: 0x212
 // CHECK-NEXT: Size: 0

lld/trunk/test/ELF/merge-sym.s

 
 
 // CHECK:      Name: .rodata
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_MERGE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1E4
+// CHECK-NEXT: Address: 0x210
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x1E6
+// CHECK-NEXT: Value: 0x212

lld/trunk/test/ELF/merge-to-non-alloc.s

 // CHECK-NEXT: Address:
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 16
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: E4010000 00000000 EC010000 00000000  |
+// CHECK-NEXT:   0000: 10020000 00000000 18020000 00000000  |
 // CHECK-NEXT: )
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x1E4
+// CHECK-NEXT: Value: 0x210
 
         .section        .foo,"aM",@progbits,4
         .align  4
         .global foo
         .hidden foo
 foo:
         .long   0x42
 
         .section .bar
         .quad foo
         .quad foo + 8

lld/trunk/test/ELF/mips-got-string.s

 # REQUIRES: mips
 # Check R_MIPS_GOT16 relocation against merge section.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux -o %t.o %s
 # RUN: ld.lld -shared -o %t.so %t.o
 # RUN: llvm-readobj -t -mips-plt-got %t.so | FileCheck %s
 
 # CHECK:      Symbol {
 # CHECK:        Name: $.str
-# CHECK-NEXT:   Value: 0x105
+# CHECK-NEXT:   Value: 0x1B1
 # CHECK:      }
 
 # CHECK:      Local entries [
 # CHECK-NEXT:   Entry {
 # CHECK-NEXT:     Address:
 # CHECK-NEXT:     Access: -32744
 # CHECK-NEXT:     Initial: 0x0
 # CHECK:        }

lld/trunk/test/ELF/mips-gp-ext.s

 # RUN: echo "SECTIONS { \
 # RUN:          .text : { *(.text) } \
 # RUN:          _gp = 0x200; \
 # RUN:          .got  : { *(.got) } }" > %t.abs.script
 # RUN: ld.lld -shared -o %t.abs.so --script %t.abs.script %t.o
 # RUN: llvm-objdump -s -t %t.abs.so | FileCheck --check-prefix=ABS %s
 
 # REL:      Contents of section .reginfo:
-# REL-NEXT:  0040 10000104 00000000 00000000 00000000
-# REL-NEXT:  0050 00000000 000001ec
+# REL-NEXT:  0018 10000104 00000000 00000000 00000000
+# REL-NEXT:  0028 00000000 000001ec
 #                          ^-- _gp
 
 # REL:      Contents of section .text:
 # REL-NEXT:  00e0 3c080000 2108010c 8f82ff1c
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x1ec - 0x100)
 #                                       G - (GP - .got)
 
 # REL:      Contents of section .data:
 # REL-NEXT:  00f0 fffffef4
 #                 ^-- 0x30-0x1ec
 #                     foo - GP
 
 # REL: 000000e0         .text           00000000 foo
 # REL: 00000000         *ABS*           00000000 .hidden _gp_disp
 # REL: 000001ec         *ABS*           00000000 .hidden _gp
 
 # ABS:      Contents of section .reginfo:
-# ABS-NEXT:  0040 10000104 00000000 00000000 00000000
-# ABS-NEXT:  0050 00000000 00000200
+# ABS-NEXT:  0018 10000104 00000000 00000000 00000000
+# ABS-NEXT:  0028 00000000 00000200
 #                          ^-- _gp
 
 # ABS:      Contents of section .text:
 # ABS-NEXT:  00e0 3c080000 21080120 8f82ff08
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
 #                                   ^-- 8 - (0x200 - 0x100)
 #                                       G - (GP - .got)

lld/trunk/test/ELF/note-noalloc.s

 // CHECK-NEXT:   Type: SHT_NOTE
 // CHECK-NEXT:   Flags [
 // CHECK-NEXT:   ]
 
 // CHECK:      ProgramHeader {
 // CHECK:        Type: PT_NOTE
 // CHECK-NEXT:   Offset:
 // CHECK-NEXT:   VirtualAddress: 0x[[ADDR]]
-// CHECK-NEXT:   PhysicalAddress: 0x24C
+// CHECK-NEXT:   PhysicalAddress: 0x[[ADDR]]
 // CHECK-NEXT:   FileSize: 16
 // CHECK-NEXT:   MemSize: 16
 // CHECK-NOT:  PT_NOTE
 
 .section        .note.a,"a",@note
 .quad 1
 .quad 2
 
 .section        .note.b,"",@note
 .quad 3

lld/trunk/test/ELF/relocation-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -shared -o %t.so
 // RUN: llvm-readobj -r -s -section-data %t.so | FileCheck %s
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1E1
+// CHECK-NEXT: Address: 0x20D
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 1F0E0000 00000000
-//                     0x1000 - 0x1E1 = 0xE1F
+// CHECK-NEXT:   0000: F30D0000 00000000
+//                     0x1000 - 0x20D = 0xDF3
 // CHECK-NEXT: )
 
 // CHECK:      Name: .text
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x1000
 
 // CHECK:      Relocations [
 // CHECK-NEXT: ]
 
 bar:
         .section foo,"a",@progbits
         .quad bar - .

lld/trunk/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:   20024d 4d022000 00000000
+// CHECK-NEXT:   2002c0 c0022000 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
-// 0x2020F0(.got) - 0x200255(.R_X86_64_GOTPCREL) = 0x2e9b
+// 0x2030F0(.got) - 0x2002c8(.R_X86_64_GOTPCREL) = 0x2e28
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   200255 9b2e0000
+// CHECK-NEXT:   2002c8 282e0000
 
 .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

lld/trunk/test/ELF/relro-omagic.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t2.so -soname relro-omagic.s.tmp2.so
 # RUN: ld.lld --hash-style=sysv -N %t.o %t2.so -o %t
 # RUN: llvm-objdump -section-headers %t | FileCheck --check-prefix=NORELRO %s
 # RUN: llvm-readobj --program-headers %t | FileCheck --check-prefix=NOPHDRS %s
 
 # NORELRO:      Sections:
 # NORELRO-NEXT: Idx Name          Size      Address          Type
 # NORELRO-NEXT:   0               00000000 0000000000000000
 # NORELRO-NEXT:   1 .dynsym       00000048 0000000000200120
-# NORELRO-NEXT:   2 .dynstr       00000021 0000000000200168
-# NORELRO-NEXT:   3 .hash         00000020 000000000020018c
+# NORELRO-NEXT:   2 .hash         00000020 0000000000200168
+# NORELRO-NEXT:   3 .dynstr       00000021 0000000000200188
 # NORELRO-NEXT:   4 .rela.dyn     00000018 00000000002001b0
 # NORELRO-NEXT:   5 .rela.plt     00000018 00000000002001c8
 # NORELRO-NEXT:   6 .text         0000000a 00000000002001e0 TEXT
 # NORELRO-NEXT:   7 .plt          00000020 00000000002001f0 TEXT
 # NORELRO-NEXT:   8 .data         00000008 0000000000200210 DATA
 # NORELRO-NEXT:   9 .foo          00000004 0000000000200218 DATA
 # NORELRO-NEXT:  10 .dynamic      000000f0 0000000000200220
 # NORELRO-NEXT:  11 .got          00000008 0000000000200310 DATA

lld/trunk/test/ELF/section-layout.s

 .section l,"awx",@nobits
 .section k,"awx"
 .section j,"aw",@nobits
 .section i,"aw"
 .section g,"awT",@nobits
 .section e,"awT"
 .section d,"ax",@nobits
 .section c,"ax"
-.section b,"a",@nobits
-.section a,"a"
+.section a,"a",@nobits
+.section b,"a"
 
+// For non-executable and non-writable sections, PROGBITS appear after others.
 // CHECK: Name: a
 // CHECK: Name: b
 // CHECK: Name: c
 // CHECK: Name: d
 
 // Sections that are both writable and executable appear before
 // sections that are only writable.
 // CHECK: Name: k

lld/trunk/test/ELF/shared.s

 // CHECK-NEXT:   EntrySize: 16
 // CHECK-NEXT:   SectionData (
 // CHECK-NEXT:     0000:
 // CHECK-NEXT:     0010:
 // CHECK-NEXT:     0020:
 // CHECK-NEXT:     0030:
 // CHECK-NEXT:   )
 // CHECK-NEXT: }
-// CHECK:        Index: [[DYNSTR]]
-// CHECK-NEXT:   Name: .dynstr
-// CHECK-NEXT:   Type: SHT_STRTAB
-// CHECK-NEXT:   Flags [
-// CHECK-NEXT:     SHF_ALLOC
-// CHECK-NEXT:   ]
-// CHECK-NEXT:   Address: [[DYNSTRADDR:.*]]
-// CHECK-NEXT:   Offset:
-// CHECK-NEXT:   Size:
-// CHECK-NEXT:   Link: 0
-// CHECK-NEXT:   Info: 0
-// CHECK-NEXT:   AddressAlignment: 1
-// CHECK-NEXT:   EntrySize: 0
-// CHECK-NEXT:   SectionData (
-// CHECK:        )
-// CHECK-NEXT: }
 // CHECK-NEXT: Section {
-// CHECK-NEXT:   Index: 4
+// CHECK-NEXT:   Index: 3
 // CHECK-NEXT:    Name: .hash
 // CHECK-NEXT:    Type: SHT_HASH
 // CHECK-NEXT:    Flags [
 // CHECK-NEXT:      SHF_ALLOC
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Address: [[HASHADDR:.*]]
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size:
 // CHECK-NEXT:    Link: 2
 // CHECK-NEXT:    Info: 0
 // CHECK-NEXT:    AddressAlignment: 4
 // CHECK-NEXT:    EntrySize: 4
+// CHECK:      Section {
+// CHECK-NEXT:   Index: [[DYNSTR]]
+// CHECK-NEXT:   Name: .dynstr
+// CHECK-NEXT:   Type: SHT_STRTAB
+// CHECK-NEXT:   Flags [
+// CHECK-NEXT:     SHF_ALLOC
+// CHECK-NEXT:   ]
+// CHECK-NEXT:   Address: [[DYNSTRADDR:.*]]
+// CHECK-NEXT:   Offset:
+// CHECK-NEXT:   Size:
+// CHECK-NEXT:   Link: 0
+// CHECK-NEXT:   Info: 0
+// CHECK-NEXT:   AddressAlignment: 1
+// CHECK-NEXT:   EntrySize: 0
 
 // CHECK:      Name: .rel.dyn
 // CHECK-NEXT: Type: SHT_REL
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: [[RELADDR:.*]]
 // CHECK-NEXT: Offset:

lld/trunk/test/ELF/sort-norosegment.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 
 # RUN: ld.lld --hash-style=sysv -no-rosegment -o %t %t.o -shared
 # RUN: llvm-readelf -s %t | FileCheck %s
 
 # CHECK:      .dynsym  {{.*}}   A
-# CHECK-NEXT: .dynstr  {{.*}}   A
 # CHECK-NEXT: .hash    {{.*}}   A
+# CHECK-NEXT: .dynstr  {{.*}}   A
 # CHECK-NEXT: .text    {{.*}}   AX
 # CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

lld/trunk/test/ELF/verdef-defaultver.s

 # DSO-NEXT:      Binding: Global
 # DSO-NEXT:      Type: Function
 # DSO-NEXT:      Other: 0
 # DSO-NEXT:      Section: .text
 # DSO-NEXT:    }
 # DSO-NEXT:  ]
 # DSO-NEXT:  Version symbols {
 # DSO-NEXT:    Section Name: .gnu.version
-# DSO-NEXT:    Address: 0x256
-# DSO-NEXT:    Offset: 0x256
+# DSO-NEXT:    Address: 0x240
+# DSO-NEXT:    Offset: 0x240
 # DSO-NEXT:    Link: 1
 # DSO-NEXT:    Symbols [
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 0
 # DSO-NEXT:        Name: @
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 2

 # 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: 0x20023C
-# EXE-NEXT:    Offset: 0x23C
+# EXE-NEXT:    Address: 0x200228
+# EXE-NEXT:    Offset: 0x228
 # 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

lld/trunk/test/ELF/verdef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "LIBSAMPLE_1.0 { global: a; local: *; };" > %t.script
 # RUN: echo "LIBSAMPLE_2.0 { global: b; local: *; };" >> %t.script
 # RUN: echo "LIBSAMPLE_3.0 { global: c; local: *; };" >> %t.script
 # RUN: ld.lld --hash-style=sysv --version-script %t.script -shared -soname shared %t.o -o %t.so
 # RUN: llvm-readobj -V -dyn-symbols %t.so | FileCheck --check-prefix=DSO %s
 
 # DSO:        Version symbols {
 # DSO-NEXT:   Section Name: .gnu.version
-# DSO-NEXT:   Address: 0x260
-# DSO-NEXT:   Offset: 0x260
+# DSO-NEXT:   Address: 0x228
+# DSO-NEXT:   Offset: 0x228
 # DSO-NEXT:   Link: 1
 # DSO-NEXT:   Symbols [
 # DSO-NEXT:     Symbol {
 # DSO-NEXT:       Version: 0
 # DSO-NEXT:       Name: @
 # DSO-NEXT:     }
 # DSO-NEXT:     Symbol {
 # DSO-NEXT:       Version: 2

 
 ## 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: 0x200260
-# MAIN-NEXT:   Offset: 0x260
+# MAIN-NEXT:   Address: 0x200228
+# MAIN-NEXT:   Offset: 0x228
 # 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

lld/trunk/test/ELF/verneed.s

 # 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:     Size: 96
-# CHECK-NEXT:     Link: 2
+# CHECK-NEXT:     Link: [[DYNSTR:.*]]
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     AddressAlignment: 8
 # CHECK-NEXT:     EntrySize: 24
 
-# CHECK:        Section {
-# CHECK-NEXT:     Index: 2
-# CHECK-NEXT:     Name: .dynstr
-# CHECK-NEXT:     Type: SHT_STRTAB (0x3)
-# CHECK-NEXT:     Flags [ (0x2)
-# CHECK-NEXT:       SHF_ALLOC (0x2)
-# CHECK-NEXT:     ]
-# CHECK-NEXT:     Address: 0x200228
-# CHECK-NEXT:     Offset: 0x228
-# 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: 00766572 6E656564 312E736F 2E300076  |.verneed1.so.0.v|
-# CHECK-NEXT:       0010: 65726E65 6564322E 736F2E30 00663100  |erneed2.so.0.f1.|
-# CHECK-NEXT:       0020: 76330066 32007632 00673100 763100    |v3.f2.v2.g1.v1.|
-# CHECK-NEXT:     )
-# CHECK-NEXT:   }
-
-# CHECK:       Section {
-# CHECK-NEXT:    Index: 3
+# CHECK:       Section {
+# CHECK-NEXT:    Index: 2
 # CHECK-NEXT:    Name: .gnu.version
 # CHECK-NEXT:    Type: SHT_GNU_versym (0x6FFFFFFF)
 # CHECK-NEXT:    Flags [ (0x2)
 # CHECK-NEXT:      SHF_ALLOC (0x2)
 # CHECK-NEXT:    ]
-# CHECK-NEXT:    Address: 0x200258
-# CHECK-NEXT:    Offset: 0x258
+# CHECK-NEXT:    Address: [[VERSYM:.*]]
+# CHECK-NEXT:    Offset: [[VERSYM_OFFSET:.*]]
 # CHECK-NEXT:    Size: 8
 # CHECK-NEXT:    Link: 1
 # CHECK-NEXT:    Info: 0
 # CHECK-NEXT:    AddressAlignment: 2
 # CHECK-NEXT:    EntrySize: 2
 
 # CHECK:       Section {
-# CHECK-NEXT:    Index: 4
+# 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: 0x200260
-# CHECK-NEXT:    Offset: 0x260
+# CHECK-NEXT:    Address: [[VERNEED:.*]]
+# CHECK-NEXT:    Offset: 0x230
 # CHECK-NEXT:    Size: 80
-# CHECK-NEXT:    Link: 2
+# 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:     Size: 47
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 1
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:     SectionData (
+# CHECK-NEXT:       0000: 00766572 6E656564 312E736F 2E300076  |.verneed1.so.0.v|
+# CHECK-NEXT:       0010: 65726E65 6564322E 736F2E30 00663100  |erneed2.so.0.f1.|
+# CHECK-NEXT:       0020: 76330066 32007632 00673100 763100    |v3.f2.v2.g1.v1.|
+# CHECK-NEXT:     )
+# CHECK-NEXT:   }
+
 # CHECK:      DynamicSymbols [
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: @
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Local (0x0)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0

 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Global (0x1)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Undefined (0x0)
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
-# CHECK:      0x000000006FFFFFF0 VERSYM               0x200258
-# CHECK-NEXT: 0x000000006FFFFFFE VERNEED              0x200260
+# CHECK:      0x000000006FFFFFF0 VERSYM               [[VERSYM]]
+# CHECK-NEXT: 0x000000006FFFFFFE VERNEED              [[VERNEED]]
 # CHECK-NEXT: 0x000000006FFFFFFF VERNEEDNUM           2
 
 # CHECK:      Version symbols {
 # CHECK-NEXT:    Section Name: .gnu.version
-# CHECK-NEXT:    Address: 0x200258
-# CHECK-NEXT:    Offset: 0x258
+# CHECK-NEXT:    Address: [[VERSYM]]
+# CHECK-NEXT:    Offset: [[VERSYM_OFFSET]]
 # CHECK-NEXT:    Link: 1
 # CHECK-NEXT:    Symbols [
 # CHECK-NEXT:      Symbol {
 # CHECK-NEXT:        Version: 0
 # CHECK-NEXT:        Name: @
 # CHECK-NEXT:      }
 # CHECK-NEXT:      Symbol {
 # CHECK-NEXT:        Version: 2

lld/trunk/test/ELF/version-script-extern.s

 # DSO-NEXT:      Binding: Global (0x1)
 # DSO-NEXT:      Type: Function (0x2)
 # DSO-NEXT:      Other: 0
 # DSO-NEXT:      Section: .text (0x6)
 # DSO-NEXT:    }
 # DSO-NEXT:  ]
 # DSO-NEXT:  Version symbols {
 # DSO-NEXT:    Section Name: .gnu.version
-# DSO-NEXT:    Address: 0x2BA
-# DSO-NEXT:    Offset: 0x2BA
+# DSO-NEXT:    Address: 0x258
+# DSO-NEXT:    Offset: 0x258
 # DSO-NEXT:    Link: 1
 # DSO-NEXT:    Symbols [
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 0
 # DSO-NEXT:        Name: @
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 3