[ELF] Simplify RelRo, TLS, NOBITS section ranks and make RW PT_LOAD start with RelRo

[MaskRay]

Summary

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

The placement of | indicates page alignment caused by PT_GNU_RELRO. The
new layout has simler rules and saves space for many cases.

Old size: roundup(.data) + roundup(.data.rel.ro)
New size: roundup(.data.rel.ro + .bss.rel.ro) + .data

Other advantages:

• At runtime the 3 memory mappings decrease to 2.
• start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD). This simplifies binary manipulation tools. GNU strip before 2.31 discards PT_GNU_RELRO if its address is not equal to the start of its associated PT_LOAD. This has been fixed by https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=f2731e0c374e5323ce4cdae2bcc7b7fe22da1a6f But with this change, we will be compatible with GNU strip before 2.31
• Before, .got.plt (non-relro by default) was placed before .got (relro by default), which made it impossible to have _GLOBAL_OFFSET_TABLE_ (start of .got.plt on x86-64) equal to the end of .got (R_GOT*_FROM_END) (https://bugs.llvm.org/show_bug.cgi?id=36555). With the new ordering, we can improve on this regard if we'd like to.

[MaskRay]

This would require fixing 100+ tests because of address changes. I want to get some feedback first...

[MaskRay]

There are other cases that the patch hasn't (but should) cover: NOBITS sections can also be RELRO; I need to check ld.bfd/gold's behavior

[ruiu]

Not sure why you want to implement a workaround at the moment. Can you elaborate? This is a bug in GNU binutils, and the fix was submitted almost a year ago. It looks like we should keep doing what we think right and don't implement too many workarounds.

[MaskRay]

In D56828#1361812, @ruiu wrote:

Not sure why you want to implement a workaround at the moment. Can you elaborate? This is a bug in GNU binutils, and the fix was submitted almost a year ago. It looks like we should keep doing what we think right and don't implement too many workarounds.

Fixing GNU strip<2.31 (see https://sourceware.org/bugzilla/show_bug.cgi?id=22829#c6) was my motivation to investigate this issue but it is only a secondary reason why I propose this patch (the workaround we get for GNU strip<2.31 is a byproduct). The primary reason is that it can decrease 1 memory mapping (if PT_GNU_RELRO is in the middle, the PT_LOAD splits into 3 memory mappings), save some address space, and make it possible to let PT_GNU_RELRO have the same p_memsz and p_filesz in a future change.

<del>I'll check other relro changes to see if this patch is reasonable and feasible.</del>

Since rLLD291523, an lld-linked executable can have the following section layout:

.data
.data.rel.ro
.bss.rel.ro
.bss

where .data.rel.ro and .bss.rel.ro are included in PT_GNU_RELRO. SHT_NOBITS .bss.rel.ro was invented around rLLD291523 to save space reserved for copy relocation (ld.bfd/gold use .data.rel.ro and do not save the space)

After ld.so remaps PT_GNU_RELRO, the single memory mapping splits into 3 mappings.

By changing to start(PT_GNU_RELRO) = start(PT_LOAD), we work around GNU strip<2.31 and probably some other binary post-processing tools.
However, the change is not incompatible with .bss.rel.ro .

I want to understand more about the pros and cons of this change to see if it is really favorale. CC pcc@ to get some insights from him.

[ruiu]

Thank you for your explanation. I think that makes sense.

ELF/Writer.cpp

824–826 ↗

(On Diff #182217)

I don't feel this comment explains the intention of the change clearly. IIUC, the intention of the change is to separate relro sections (e.g. .data.rel.ro and .bss.rel.ro) from non-relro sections (e.g. .data and .bss), so that we don't waste space for page alignment. An alternative ordering, e.g., .data, .data.rel.ro, .bss, .bss.rel.ro, wastes on average address space of 2 pages because each section would be page-aligned.

[pcc]

So after this patch the layout will be

.data.rel.ro
.bss.rel.ro
.data
.bss

? That's valid I suppose, but I don't see how we avoid the extra mapping.

[ruiu]

In D56828#1415833, @pcc wrote:

So after this patch the layout will be

.data.rel.ro
.bss.rel.ro
.data
.bss

? That's valid I suppose, but I don't see how we avoid the extra mapping.

You can at least save on average one page of memory address space, as the last page of .data.rel.ro and the first page of .bss.rel.ro can be on the same page?

[pcc]

Well, with the old layout you could still place .data.rel.ro and .bss.rel.ro on the same page, but with the new one .data and .bss can now be placed together. That's probably where you get the largest benefit since they're more commonly used.

In terms of mappings I guess you save a mapping unless .bss.rel.ro is large enough to require another page, in which case you need another PT_LOAD (and another mapping).

[MaskRay]

Retitle

[MaskRay]

Comment

[joerg]

Placing .bss.rel.ro before .data doesn't make sense. It forces the content of .bss.rel.ro to embedded into the binary. I also don't really understand the motivation here. Memory mappins on the kernel side are quite cheap.

[MaskRay]

In D56828#1416170, @joerg wrote:

Placing .bss.rel.ro before .data doesn't make sense. It forces the content of .bss.rel.ro to embedded into the binary. I also don't really understand the motivation here. Memory mappins on the kernel side are quite cheap.

.bss.rel.ro is a linker synthesized section whose only purpose is to reserve space for copy relocations of symbols in read-only segments. In most applications, we expect it is very small or does not exist at all.

I agree that in -z relro mode (default), when either .data or .bss exists (almost always true), the contents of .bss.rel.ro are embedded (as if it is .data.rel.ro; this is used by newer ld.bfd/gold). However, since .bss.rel.ro is small, this doesn't matter.

(We use .data.rel.ro as a representative for relro progbits sections like .dynamic .got)

old size: roundup(.data) + roundup(.data.rel.ro)
new size: roundup(.data.rel.ro + .bss.rel.ro) + .data
old-new = (page - .data%page)%page - roundup(.bss.rel.ro - (pagesize - .data.rel.ro%page)%page)

The first term is on average page/2 while the second term is (unbounded in theory), though 0 in most cases, pagesize in rare cases. The difference is usually positive => we decrease binary sizes.

So the advantage of this patch:

• Simpler rule: we no longer need to place RelRo in the segment boundary.
• start(PT_TLS) = start(PT_GNU_RELRO) = start(RW PT_LOAD): this simplifies some binary manipulation tools. As I noted, GNU strip<2.31 will not strip RelRo. It should also make llvm-objcopy's life easier. I don't know of a specific corner case but the split RW PT_LOAD may be bug-prone for tools.

Now In.BssRelRo serves as a marker (ld.bfd/gold call it dynrelro). In -z norelro mode, .bss.rel.ro naturally merges with .bss

Before, .got.plt (non-relro by default) is placed before .got (relro by default), which makes it impossible to have _GLOBAL_OFFSET_TABLE_ (start of .got.plt on x86-64) equal to end of .got (R_GOT*_FROM_END) (https://bugs.llvm.org/show_bug.cgi?id=36555): this is not a big deal though, as we've fixed tools to emit relocation types not relying the symbolic value of _GLOBAL_OFFSET_TABLE_. To the best of my knowledge it only affects glibc.

[pcc]

I agree that in -z relro mode (default), when either .data or .bss exists (almost always true), the contents of .bss.rel.ro are embedded (as if it is .data.rel.ro; this is used by newer ld.bfd/gold). However, since .bss.rel.ro is small, this doesn't matter.

Not necessarily. As I mentioned in my earlier comment, you could have a second PT_LOAD for relro.

e.g. with the following layout:

.data.rel.ro (vaddr 0x3000 size 0x1000)
.bss.rel.ro (vaddr 0x4000 size 0x1000)
.data (vaddr 0x5000 size 0x1000)
.bss (vaddr 0x6000 size 0x1000)

You could lay out .data at file offset 0x4000 and then have the following program headers:

PT_LOAD rw p_offset = 0x3000 p_vaddr = 0x3000 p_filesz = 0x1000 p_memsz = 0x2000
PT_LOAD rw p_offset = 0x4000 p_vaddr = 0x5000 p_filesz = 0x1000 p_memsz = 0x2000
PT_GNU_RELRO p_offset = 0x3000 p_vaddr = 0x3000 p_filesz = 0x1000 p_memsz = 0x2000

I wouldn't expect .bss.rel.ro to always be small in the future. One thing that we could use it for is to compress the storage of relro sections which do not contain data, only relocations (a good example of this is most vtables in position-independent binaries). If a relro section's statically relocated data is all zeros, we could move it into .bss.rel.ro. Then the section itself would not take up space in the output file, only its relocations would.

[MaskRay]

Update description

[MaskRay]

In D56828#1416503, @pcc wrote:

I agree that in -z relro mode (default), when either .data or .bss exists (almost always true), the contents of .bss.rel.ro are embedded (as if it is .data.rel.ro; this is used by newer ld.bfd/gold). However, since .bss.rel.ro is small, this doesn't matter.

Not necessarily. As I mentioned in my earlier comment, you could have a second PT_LOAD for relro.

e.g. with the following layout:

.data.rel.ro (vaddr 0x3000 size 0x1000)
.bss.rel.ro (vaddr 0x4000 size 0x1000)
.data (vaddr 0x5000 size 0x1000)
.bss (vaddr 0x6000 size 0x1000)

You could lay out .data at file offset 0x4000 and then have the following program headers:

PT_LOAD rw p_offset = 0x3000 p_vaddr = 0x3000 p_filesz = 0x1000 p_memsz = 0x2000
PT_LOAD rw p_offset = 0x4000 p_vaddr = 0x5000 p_filesz = 0x1000 p_memsz = 0x2000
PT_GNU_RELRO p_offset = 0x3000 p_vaddr = 0x3000 p_filesz = 0x1000 p_memsz = 0x2000

I wouldn't expect .bss.rel.ro to always be small in the future. One thing that we could use it for is to compress the storage of relro sections which do not contain data, only relocations (a good example of this is most vtables in position-independent binaries). If a relro section's statically relocated data is all zeros, we could move it into .bss.rel.ro. Then the section itself would not take up space in the output file, only its relocations would.

Thanks for the suggestion and pointing out the improvement direction of .bss.rel.ro ("If a relro section's statically relocated data is all zeros, we could move it into .bss.rel.ro")! The idea is illustrated below:

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)

I've created https://reviews.llvm.org/D58892 for the idea. This patch alone requires 116 tests. Do you favor the new layout?

If yes, once this is accepted, I can work on D58892 and fix another 9 tests.

[MaskRay]

Ping :)

[MaskRay]

Ping :)

This is simpler than it appeared to be..

[pcc]

Looks good, please go ahead and modify the tests.

[MaskRay]

Add tests

[MaskRay]

Looks good, please go ahead and modify the tests.

I'll take that as approval as in offline discussion ruiu said he didn't have objection and was waiting on your decision :)

[pcc]

In D56828#1428674, @MaskRay wrote:

Looks good, please go ahead and modify the tests.

I'll take that as approval as in offline discussion ruiu said he didn't have objection and was waiting on your decision :)

I intended to review your test changes first. I have now done so.

lld/trunk/test/ELF/arm-plt-reloc.s

53

Same here.

lld/trunk/test/ELF/arm-thumb-plt-reloc.s

63

The calculations in this file need to be updated.

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

12

Can you check that this test fails if you revert the change that added the test?

[MaskRay]

The three tests are fixed in https://reviews.llvm.org/rLLD356229

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

12

Done.

Have to use -z norelro to counteract layout change.

lld/trunk/ELF/Writer.cpp

 // We compute a rank for each section. The rank indicates where the
 // section should be placed in the file.  Instead of using simple
 // numbers (0,1,2...), we use a series of flags. One for each decision
 // point when placing the section.
 // Using flags has two key properties:
 // * It is easy to check if a give branch was taken.
 // * It is easy two see how similar two ranks are (see getRankProximity).
 enum RankFlags {
-  RF_NOT_ADDR_SET = 1 << 18,
-  RF_NOT_ALLOC = 1 << 17,
-  RF_NOT_INTERP = 1 << 16,
-  RF_NOT_NOTE = 1 << 15,
-  RF_WRITE = 1 << 14,
-  RF_EXEC_WRITE = 1 << 13,
-  RF_EXEC = 1 << 12,
-  RF_RODATA = 1 << 11,
-  RF_NON_TLS_BSS = 1 << 10,
-  RF_NON_TLS_BSS_RO = 1 << 9,
+  RF_NOT_ADDR_SET = 1 << 17,
+  RF_NOT_ALLOC = 1 << 16,
+  RF_NOT_INTERP = 1 << 15,
+  RF_NOT_NOTE = 1 << 14,
+  RF_WRITE = 1 << 13,
+  RF_EXEC_WRITE = 1 << 12,
+  RF_EXEC = 1 << 11,
+  RF_RODATA = 1 << 10,
+  RF_NOT_RELRO = 1 << 9,
   RF_NOT_TLS = 1 << 8,
   RF_BSS = 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,
static unsigned getSectionRank(const OutputSection *Sec) {
   } 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;
   }
 
-  // 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;
+  // 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;
 
-  // The first requirement we have is to put (non-TLS) nobits sections last. The
-  // reason is that the only thing the dynamic linker will see about them is a
-  // p_memsz that is larger than p_filesz. Seeing that it zeros the end of the
-  // PT_LOAD, so that has to correspond to the nobits sections.
-  bool IsNonTlsNoBits = IsNoBits && !IsTls;
-  if (IsNonTlsNoBits)
-    Rank |= RF_NON_TLS_BSS;
-
-  // We place nobits RelRo sections before plain r/w ones, and non-nobits RelRo
-  // sections after r/w ones, so that the RelRo sections are contiguous.
-  bool IsRelRo = isRelroSection(Sec);
-  if (IsNonTlsNoBits && !IsRelRo)
-    Rank |= RF_NON_TLS_BSS_RO;
-  if (!IsNonTlsNoBits && IsRelRo)
-    Rank |= RF_NON_TLS_BSS_RO;
+  // If we got here we know that both A and B are in the same PT_LOAD.
 
   // The TLS initialization block needs to be a single contiguous block in a R/W
   // PT_LOAD, so stick TLS sections directly before the other RelRo R/W
-  // sections. The TLS NOBITS sections are placed here as they don't take up
-  // virtual address space in the PT_LOAD.
-  if (!IsTls)
+  // sections. Since p_filesz can be less than p_memsz, place NOBITS sections
+  // after PROGBITS.
+  if (!(Sec->Flags & SHF_TLS))
     Rank |= RF_NOT_TLS;
 
-  // Within the TLS initialization block, the non-nobits sections need to appear
-  // first.
-  if (IsNoBits)
+  // Within TLS sections, or within other RelRo sections, or within non-RelRo
+  // sections, place non-NOBITS sections first.
+  if (Sec->Type == SHT_NOBITS)
     Rank |= RF_BSS;
 
   // Some architectures have additional ordering restrictions for sections
   // within the same PT_LOAD.
   if (Config->EMachine == EM_PPC64) {
     // PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections
     // that we would like to make sure appear is a specific order to maximize
     // their coverage by a single signed 16-bit offset from the TOC base

lld/trunk/test/ELF/aarch64-condb-reloc.s

 #DSOREL:      Section {
 #DSOREL:        Index:
 #DSOREL:        Name: .got.plt
 #DSOREL-NEXT:   Type: SHT_PROGBITS
 #DSOREL-NEXT:   Flags [
 #DSOREL-NEXT:     SHF_ALLOC
 #DSOREL-NEXT:     SHF_WRITE
 #DSOREL-NEXT:   ]
-#DSOREL-NEXT:   Address: 0x20000
-#DSOREL-NEXT:   Offset: 0x20000
+#DSOREL-NEXT:   Address: 0x30000
+#DSOREL-NEXT:   Offset: 0x30000
 #DSOREL-NEXT:   Size: 48
 #DSOREL-NEXT:   Link: 0
 #DSOREL-NEXT:   Info: 0
 #DSOREL-NEXT:   AddressAlignment: 8
 #DSOREL-NEXT:   EntrySize: 0
 #DSOREL-NEXT:  }
 #DSOREL:      Relocations [
 #DSOREL-NEXT:  Section ({{.*}}) .rela.plt {
-#DSOREL-NEXT:    0x20018 R_AARCH64_JUMP_SLOT _foo
-#DSOREL-NEXT:    0x20020 R_AARCH64_JUMP_SLOT _bar
-#DSOREL-NEXT:    0x20028 R_AARCH64_JUMP_SLOT _dah
+#DSOREL-NEXT:    0x30018 R_AARCH64_JUMP_SLOT _foo
+#DSOREL-NEXT:    0x30020 R_AARCH64_JUMP_SLOT _bar
+#DSOREL-NEXT:    0x30028 R_AARCH64_JUMP_SLOT _dah
 #DSOREL-NEXT:  }
 #DSOREL-NEXT:]
 
 #DSO:      Disassembly of section .text:
 #DSO-NEXT: _foo:
 #DSO-NEXT:     10000: {{.*}} nop
 #DSO-NEXT:     10004: {{.*}} nop
 #DSO-NEXT:     10008: {{.*}} nop
 #DSO-NEXT:     1000c: {{.*}} nop
 #DSO:      _bar:
 #DSO-NEXT:     10010: {{.*}} nop
 #DSO-NEXT:     10014: {{.*}} nop
 #DSO-NEXT:     10018: {{.*}} nop
 #DSO:      _dah:
 #DSO-NEXT:     1001c: {{.*}} nop
 #DSO-NEXT:     10020: {{.*}} nop
 #DSO:      _start:
 #DSO-NEXT:     10024: {{.*}} b.eq #44
 #DSO-NEXT:     10028: {{.*}} b.eq #56
 #DSO-NEXT:     1002c: {{.*}} b.eq #68
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-NEXT: .plt:
 #DSO-NEXT:     10030: {{.*}} stp x16, x30, [sp, #-16]!
-#DSO-NEXT:     10034: {{.*}} adrp x16, #65536
+#DSO-NEXT:     10034: {{.*}} adrp x16, #131072
 #DSO-NEXT:     10038: {{.*}} ldr x17, [x16, #16]
 #DSO-NEXT:     1003c: {{.*}} add x16, x16, #16
 #DSO-NEXT:     10040: {{.*}} br x17
 #DSO-NEXT:     10044: {{.*}} nop
 #DSO-NEXT:     10048: {{.*}} nop
 #DSO-NEXT:     1004c: {{.*}} nop
 #DSO-EMPTY:
 #DSO-NEXT:   _foo@plt:
-#DSO-NEXT:     10050: {{.*}} adrp x16, #65536
+#DSO-NEXT:     10050: {{.*}} adrp x16, #131072
 #DSO-NEXT:     10054: {{.*}} ldr x17, [x16, #24]
 #DSO-NEXT:     10058: {{.*}} add x16, x16, #24
 #DSO-NEXT:     1005c: {{.*}} br x17
 #DSO-EMPTY:
 #DSO-NEXT:   _bar@plt:
-#DSO-NEXT:     10060: {{.*}} adrp x16, #65536
+#DSO-NEXT:     10060: {{.*}} adrp x16, #131072
 #DSO-NEXT:     10064: {{.*}} ldr x17, [x16, #32]
 #DSO-NEXT:     10068: {{.*}} add x16, x16, #32
 #DSO-NEXT:     1006c: {{.*}} br x17
 #DSO-EMPTY:
 #DSO-NEXT:   _dah@plt:
-#DSO-NEXT:     10070: {{.*}} adrp x16, #65536
+#DSO-NEXT:     10070: {{.*}} adrp x16, #131072
 #DSO-NEXT:     10074: {{.*}} ldr x17, [x16, #40]
 #DSO-NEXT:     10078: {{.*}} add x16, x16, #40
 #DSO-NEXT:     1007c: {{.*}} br x17
 
 .globl _start
 _start:
  b.eq _foo
  b.eq _bar
  b.eq _dah

lld/trunk/test/ELF/aarch64-cortex-a53-843419-large.s

// CHECK2-NEXT:    211000:       00 fc ff 97     bl      #-4096
         .type t3_ff8_ldr, %function
 t3_ff8_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK3: t3_ff8_ldr:
-// CHECK3-NEXT:    211ff8:       60 00 04 f0     adrp    x0, #134279168
+// CHECK3-NEXT:    211ff8:       e0 00 04 f0     adrp    x0, #134344704
 // CHECK3-NEXT:    211ffc:       21 00 40 f9     ldr     x1, [x1]
 // CHECK3-NEXT:    212000:       02 08 80 15     b       #100671496
 // CHECK3-NEXT:    212004:       c0 03 5f d6     ret
 
         .section .text.04, "ax", %progbits
         .space 64 * 1024 * 1024
 
         // Expect patch on pass 1
         .section .text.05, "ax", %progbits
         .balign 4096
         .space 4096 - 8
         .globl t3_ff8_str
         .type t3_ff8_str, %function
 t3_ff8_str:
         adrp x0, dat
         ldr x1, [x1, #0]
         str x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK4: t3_ff8_str:
-// CHECK4-NEXT:  4213ff8:       60 00 02 b0     adrp    x0, #67162112
+// CHECK4-NEXT:  4213ff8:       e0 00 02 b0     adrp    x0, #67227648
 // CHECK4-NEXT:  4213ffc:       21 00 40 f9     ldr     x1, [x1]
 // CHECK4-NEXT:  4214000:       04 00 80 14     b       #33554448
 // CHECK4-NEXT:  4214004:       c0 03 5f d6     ret
 
         .section .text.06, "ax", %progbits
         .space 32 * 1024 * 1024
 
 // CHECK5: __CortexA53843419_211000:
// CHECK6-NEXT:  821100c:       c0 03 5f d6     ret
         .type t3_ffc_ldr, %function
 t3_ffc_ldr:
         adrp x0, dat
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat]
         ret
 
 // CHECK7: t3_ffc_ldr:
-// CHECK7-NEXT:  8211ffc:       60 00 00 f0     adrp    x0, #61440
+// CHECK7-NEXT:  8211ffc:       e0 00 00 f0     adrp    x0, #126976
 // CHECK7-NEXT:  8212000:       21 00 40 f9     ldr     x1, [x1]
 // CHECK7-NEXT:  8212004:       02 00 00 14     b       #8
 // CHECK7-NEXT:  8212008:       c0 03 5f d6     ret
 // CHECK7: __CortexA53843419_8212004:
 // CHECK7-NEXT:  821200c:       00 00 40 f9     ldr     x0, [x0]
 // CHECK7-NEXT:  8212010:       fe ff ff 17     b       #-8
 
         .section .data
         .globl dat
 dat:    .quad 0

lld/trunk/test/ELF/aarch64-cortex-a53-843419-recognize.s

 // as erratum 843419. The test cases cover the major variations such as:
 // - adrp starts at 0xfff8 or 0xfffc.
 // - Variations in instruction class for instruction 2.
 // - Optional instruction 3 present or not.
 // - Load or store for instruction 4.
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 211FF8 in unpatched output.
 // CHECK: t3_ff8_ldr:
-// CHECK-NEXT:    211ff8:        e0 01 00 f0     adrp    x0, #258048
+// CHECK-NEXT:    211ff8:        60 02 00 f0     adrp    x0, #323584
 // CHECK-NEXT:    211ffc:        21 00 40 f9     ldr             x1, [x1]
 // CHECK-FIX:     212000:        03 c8 00 14     b       #204812
 // CHECK-NOFIX:   212000:        00 00 40 f9     ldr             x0, [x0]
 // CHECK-NEXT:    212004:        c0 03 5f d6     ret
         .section .text.01, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldr
         .type t3_ff8_ldr, %function
         .space 4096 - 8
 t3_ff8_ldr:
         adrp x0, dat1
         ldr x1, [x1, #0]
         ldr x0, [x0, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 213FF8 in unpatched output.
 // CHECK: t3_ff8_ldrsimd:
-// CHECK-NEXT:    213ff8:        e0 01 00 b0     adrp    x0, #249856
+// CHECK-NEXT:    213ff8:        60 02 00 b0     adrp    x0, #315392
 // CHECK-NEXT:    213ffc:        21 00 40 bd     ldr             s1, [x1]
 // CHECK-FIX:     214000:        05 c0 00 14     b       #196628
 // CHECK-NOFIX:   214000:        02 04 40 f9     ldr     x2, [x0, #8]
 // CHECK-NEXT:    214004:        c0 03 5f d6     ret
         .section .text.02, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldrsimd
         .type t3_ff8_ldrsimd, %function
         .space 4096 - 8
 t3_ff8_ldrsimd:
         adrp x0, dat2
         ldr s1, [x1, #0]
         ldr x2, [x0, :got_lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 215FFC in unpatched output.
 // CHECK: t3_ffc_ldrpost:
-// CHECK-NEXT:    215ffc:        c0 01 00 f0     adrp    x0, #241664
+// CHECK-NEXT:    215ffc:        40 02 00 f0     adrp    x0, #307200
 // CHECK-NEXT:    216000:        21 84 40 bc     ldr     s1, [x1], #8
 // CHECK-FIX:     216004:        06 b8 00 14     b       #188440
 // CHECK-NOFIX:   216004:        03 08 40 f9     ldr     x3, [x0, #16]
 // CHECK-NEXT:    216008:        c0 03 5f d6     ret
         .section .text.03, "ax", %progbits
         .balign 4096
         .globl t3_ffc_ldrpost
         .type t3_ffc_ldrpost, %function
         .space 4096 - 4
 t3_ffc_ldrpost:
         adrp x0, dat3
         ldr s1, [x1], #8
         ldr x3, [x0, :got_lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 217FF8 in unpatched output.
 // CHECK: t3_ff8_strpre:
-// CHECK-NEXT:    217ff8:        c0 01 00 b0     adrp    x0, #233472
+// CHECK-NEXT:    217ff8:        40 02 00 b0     adrp    x0, #299008
 // CHECK-NEXT:    217ffc:        21 8c 00 bc     str     s1, [x1, #8]!
 // CHECK-FIX:     218000:        09 b0 00 14     b       #180260
 // CHECK-NOFIX:   218000:        02 00 40 f9     ldr             x2, [x0]
 // CHECK-NEXT:    218004:        c0 03 5f d6     ret
         .section .text.04, "ax", %progbits
         .balign 4096
         .globl t3_ff8_strpre
         .type t3_ff8_strpre, %function
         .space 4096 - 8
 t3_ff8_strpre:
         adrp x0, dat1
         str s1, [x1, #8]!
         ldr x2, [x0, :lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 219FFC in unpatched output.
 // CHECK: t3_ffc_str:
-// CHECK-NEXT:    219ffc:        bc 01 00 f0     adrp    x28, #225280
+// CHECK-NEXT:    219ffc:        3c 02 00 f0     adrp    x28, #290816
 // CHECK-NEXT:    21a000:        42 00 00 f9     str             x2, [x2]
 // CHECK-FIX:     21a004:        0a a8 00 14     b       #172072
 // CHECK-NOFIX:   21a004:        9c 07 00 f9     str     x28, [x28, #8]
 // CHECK-NEXT:    21a008:        c0 03 5f d6     ret
         .section .text.05, "ax", %progbits
         .balign 4096
         .globl t3_ffc_str
         .type t3_ffc_str, %function
         .space 4096 - 4
 t3_ffc_str:
         adrp x28, dat2
         str x2, [x2, #0]
         str x28, [x28, :lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21BFFC in unpatched output.
 // CHECK: t3_ffc_strsimd:
-// CHECK-NEXT:    21bffc:        bc 01 00 b0     adrp    x28, #217088
+// CHECK-NEXT:    21bffc:        3c 02 00 b0     adrp    x28, #282624
 // CHECK-NEXT:    21c000:        44 00 00 b9     str             w4, [x2]
 // CHECK-FIX:     21c004:        0c a0 00 14     b       #163888
 // CHECK-NOFIX:   21c004:        84 0b 00 f9     str     x4, [x28, #16]
 // CHECK-NEXT:    21c008:        c0 03 5f d6     ret
         .section .text.06, "ax", %progbits
         .balign 4096
         .globl t3_ffc_strsimd
         .type t3_ffc_strsimd, %function
         .space 4096 - 4
 t3_ffc_strsimd:
         adrp x28, dat3
         str w4, [x2, #0]
         str x4, [x28, :lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21DFF8 in unpatched output.
 // CHECK: t3_ff8_ldrunpriv:
-// CHECK-NEXT:    21dff8:        9d 01 00 f0     adrp    x29, #208896
+// CHECK-NEXT:    21dff8:        1d 02 00 f0     adrp    x29, #274432
 // CHECK-NEXT:    21dffc:        41 08 40 38     ldtrb           w1, [x2]
 // CHECK-FIX:     21e000:        0f 98 00 14     b       #155708
 // CHECK-NOFIX:   21e000:        bd 03 40 f9     ldr             x29, [x29]
 // CHECK-NEXT:    21e004:        c0 03 5f d6     ret
         .section .text.07, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldrunpriv
         .type t3_ff8_ldrunpriv, %function
         .space 4096 - 8
 t3_ff8_ldrunpriv:
         adrp x29, dat1
         ldtrb w1, [x2, #0]
         ldr x29, [x29, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21FFFC in unpatched output.
 // CHECK: t3_ffc_ldur:
-// CHECK-NEXT:    21fffc:        9d 01 00 b0     adrp    x29, #200704
+// CHECK-NEXT:    21fffc:        1d 02 00 b0     adrp    x29, #266240
 // CHECK-NEXT:    220000:        42 40 40 b8     ldur    w2, [x2, #4]
 // CHECK-FIX:     220004:        10 90 00 14     b       #147520
 // CHECK-NOFIX:   220004:        bd 07 40 f9     ldr     x29, [x29, #8]
 // CHECK-NEXT:    220008:        c0 03 5f d6     ret
         .balign 4096
         .globl t3_ffc_ldur
         .type t3_ffc_ldur, %function
         .space 4096 - 4
 t3_ffc_ldur:
         adrp x29, dat2
         ldur w2, [x2, #4]
         ldr x29, [x29, :got_lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 221FFC in unpatched output.
 // CHECK: t3_ffc_sturh:
-// CHECK-NEXT:    221ffc:        72 01 00 f0     adrp    x18, #192512
+// CHECK-NEXT:    221ffc:        f2 01 00 f0     adrp    x18, #258048
 // CHECK-NEXT:    222000:        43 40 00 78     sturh   w3, [x2, #4]
 // CHECK-FIX:     222004:        12 88 00 14     b       #139336
 // CHECK-NOFIX:   222004:        41 0a 40 f9     ldr     x1, [x18, #16]
 // CHECK-NEXT:    222008:        c0 03 5f d6     ret
         .section .text.09, "ax", %progbits
         .balign 4096
         .globl t3_ffc_sturh
         .type t3_ffc_sturh, %function
         .space 4096 - 4
 t3_ffc_sturh:
         adrp x18, dat3
         sturh w3, [x2, #4]
         ldr x1, [x18, :got_lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 223FF8 in unpatched output.
 // CHECK: t3_ff8_literal:
-// CHECK-NEXT:    223ff8:        72 01 00 b0     adrp    x18, #184320
+// CHECK-NEXT:    223ff8:        f2 01 00 b0     adrp    x18, #249856
 // CHECK-NEXT:    223ffc:        e3 ff ff 58     ldr     x3, #-4
 // CHECK-FIX:     224000:        15 80 00 14     b       #131156
 // CHECK-NOFIX:   224000:        52 02 40 f9     ldr             x18, [x18]
 // CHECK-NEXT:    224004:        c0 03 5f d6     ret
         .section .text.10, "ax", %progbits
         .balign 4096
         .globl t3_ff8_literal
         .type t3_ff8_literal, %function
         .space 4096 - 8
 t3_ff8_literal:
         adrp x18, dat1
         ldr x3, t3_ff8_literal
         ldr x18, [x18, :lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 225FFC in unpatched output.
 // CHECK: t3_ffc_register:
-// CHECK-NEXT:    225ffc:        4f 01 00 f0     adrp    x15, #176128
+// CHECK-NEXT:    225ffc:        cf 01 00 f0     adrp    x15, #241664
 // CHECK-NEXT:    226000:        43 68 61 f8     ldr             x3, [x2, x1]
 // CHECK-FIX:     226004:        16 78 00 14     b       #122968
 // CHECK-NOFIX:   226004:        ea 05 40 f9     ldr     x10, [x15, #8]
 // CHECK-NEXT:    226008:        c0 03 5f d6     ret
         .section .text.11, "ax", %progbits
         .balign 4096
         .globl t3_ffc_register
         .type t3_ffc_register, %function
         .space 4096 - 4
 t3_ffc_register:
         adrp x15, dat2
         ldr x3, [x2, x1]
         ldr x10, [x15, :lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 227FF8 in unpatched output.
 // CHECK: t3_ff8_stp:
-// CHECK-NEXT:    227ff8:        50 01 00 b0     adrp    x16, #167936
+// CHECK-NEXT:    227ff8:        d0 01 00 b0     adrp    x16, #233472
 // CHECK-NEXT:    227ffc:        61 08 00 a9     stp             x1, x2, [x3]
 // CHECK-FIX:     228000:        19 70 00 14     b       #114788
 // CHECK-NOFIX:   228000:        0d 0a 40 f9     ldr     x13, [x16, #16]
 // CHECK-NEXT:    228004:        c0 03 5f d6     ret
         .section .text.12, "ax", %progbits
         .balign 4096
         .globl t3_ff8_stp
         .type t3_ff8_stp, %function
         .space 4096 - 8
 t3_ff8_stp:
         adrp x16, dat3
         stp x1,x2, [x3, #0]
         ldr x13, [x16, :lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 229FFC in unpatched output.
 // CHECK: t3_ffc_stnp:
-// CHECK-NEXT:    229ffc:        27 01 00 f0     adrp    x7, #159744
+// CHECK-NEXT:    229ffc:        a7 01 00 f0     adrp    x7, #225280
 // CHECK-NEXT:    22a000:        61 08 00 a8     stnp            x1, x2, [x3]
 // CHECK-FIX:     22a004:        1a 68 00 14     b       #106600
 // CHECK-NOFIX:   22a004:        e9 00 40 f9     ldr             x9, [x7]
 // CHECK-NEXT:    22a008:        c0 03 5f d6     ret
         .section .text.13, "ax", %progbits
         .balign 4096
         .globl t3_ffc_stnp
         .type t3_ffc_stnp, %function
         .space 4096 - 4
 t3_ffc_stnp:
         adrp x7, dat1
         stnp x1,x2, [x3, #0]
         ldr x9, [x7, :lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22BFFC in unpatched output.
 // CHECK: t3_ffc_st1singlepost:
-// CHECK-NEXT:    22bffc:        37 01 00 b0     adrp    x23, #151552
+// CHECK-NEXT:    22bffc:        b7 01 00 b0     adrp    x23, #217088
 // CHECK-NEXT:    22c000:        20 04 82 0d     st1 { v0.b }[1], [x1], x2
 // CHECK-FIX:     22c004:        1c 60 00 14     b       #98416
 // CHECK-NOFIX:   22c004:        f6 06 40 f9     ldr     x22, [x23, #8]
 // CHECK-NEXT:    22c008:        c0 03 5f d6     ret
         .section .text.14, "ax", %progbits
         .balign 4096
         .globl t3_ffc_st1singlepost
         .type t3_ffc_st1singlepost, %function
         .space 4096 - 4
 t3_ffc_st1singlepost:
         adrp x23, dat2
         st1 { v0.b }[1], [x1], x2
         ldr x22, [x23, :lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22DFF8 in unpatched output.
 // CHECK: t3_ff8_st1multiple:
-// CHECK-NEXT:    22dff8:        17 01 00 f0     adrp    x23, #143360
+// CHECK-NEXT:    22dff8:        97 01 00 f0     adrp    x23, #208896
 // CHECK-NEXT:    22dffc:        20 a0 00 4c     st1     { v0.16b, v1.16b }, [x1]
 // CHECK-FIX:     22e000:        1f 58 00 14     b       #90236
 // CHECK-NOFIX:   22e000:        f8 0a 40 f9     ldr     x24, [x23, #16]
 // CHECK-NEXT:    22e004:        c0 03 5f d6     ret
         .section .text.15, "ax", %progbits
         .balign 4096
         .globl t3_ff8_st1multiple
         .type t3_ff8_st1muliple, %function
         .space 4096 - 8
 t3_ff8_st1multiple:
         adrp x23, dat3
         st1 { v0.16b, v1.16b }, [x1]
         ldr x24, [x23, :lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22FFF8 in unpatched output.
 // CHECK: t4_ff8_ldr:
-// CHECK-NEXT:    22fff8:        00 01 00 b0     adrp    x0, #135168
+// CHECK-NEXT:    22fff8:        80 01 00 b0     adrp    x0, #200704
 // CHECK-NEXT:    22fffc:        21 00 40 f9     ldr             x1, [x1]
 // CHECK-NEXT:    230000:        42 00 00 8b     add             x2, x2, x0
 // CHECK-FIX:     230004:        20 50 00 14     b       #82048
 // CHECK-NOFIX:   230004:        02 00 40 f9     ldr             x2, [x0]
 // CHECK-NEXT:    230008:        c0 03 5f d6     ret
         .section .text.16, "ax", %progbits
         .balign 4096
         .globl t4_ff8_ldr
         .type t4_ff8_ldr, %function
         .space 4096 - 8
 t4_ff8_ldr:
         adrp x0, dat1
         ldr x1, [x1, #0]
         add x2, x2, x0
         ldr x2, [x0, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 231FFC in unpatched output.
 // CHECK: t4_ffc_str:
-// CHECK-NEXT:    231ffc:        fc 00 00 f0     adrp    x28, #126976
+// CHECK-NEXT:    231ffc:        7c 01 00 f0     adrp    x28, #192512
 // CHECK-NEXT:    232000:        42 00 00 f9     str             x2, [x2]
 // CHECK-NEXT:    232004:        20 00 02 cb     sub             x0, x1, x2
 // CHECK-FIX:     232008:        21 48 00 14     b       #73860
 // CHECK-NOFIX:   232008:        9b 07 00 f9     str     x27, [x28, #8]
 // CHECK-NEXT:    23200c:        c0 03 5f d6     ret
         .section .text.17, "ax", %progbits
         .balign 4096
         .globl t4_ffc_str
         .type t4_ffc_str, %function
         .space 4096 - 4
 t4_ffc_str:
         adrp x28, dat2
         str x2, [x2, #0]
         sub x0, x1, x2
         str x27, [x28, :got_lo12:dat2]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 233FF8 in unpatched output.
 // CHECK: t4_ff8_stp:
-// CHECK-NEXT:    233ff8:        f0 00 00 b0     adrp    x16, #118784
+// CHECK-NEXT:    233ff8:        70 01 00 b0     adrp    x16, #184320
 // CHECK-NEXT:    233ffc:        61 08 00 a9     stp             x1, x2, [x3]
 // CHECK-NEXT:    234000:        03 7e 10 9b     mul             x3, x16, x16
 // CHECK-FIX:     234004:        24 40 00 14     b       #65680
 // CHECK-NOFIX:   234004:        0e 0a 40 f9     ldr     x14, [x16, #16]
 // CHECK-NEXT:    234008:        c0 03 5f d6     ret
         .section .text.18, "ax", %progbits
         .balign 4096
         .globl t4_ff8_stp
         .type t4_ff8_stp, %function
         .space 4096 - 8
 t4_ff8_stp:
         adrp x16, dat3
         stp x1,x2, [x3, #0]
         mul x3, x16, x16
         ldr x14, [x16, :got_lo12:dat3]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 235FF8 in unpatched output.
 // CHECK: t4_ff8_stppre:
-// CHECK-NEXT:    235ff8:        d0 00 00 f0     adrp    x16, #110592
+// CHECK-NEXT:    235ff8:        50 01 00 f0     adrp    x16, #176128
 // CHECK-NEXT:    235ffc:        61 08 81 a9     stp     x1, x2, [x3, #16]!
 // CHECK-NEXT:    236000:        03 7e 10 9b     mul             x3, x16, x16
 // CHECK-FIX:     236004:        26 38 00 14     b       #57496
 // CHECK-NOFIX:   236004:        0e 06 40 f9     ldr     x14, [x16, #8]
 // CHECK-NEXT:    236008:        c0 03 5f d6     ret
         .section .text.19, "ax", %progbits
         .balign 4096
         .globl t4_ff8_stppre
         .type t4_ff8_stppre, %function
         .space 4096 - 8
 t4_ff8_stppre:
         adrp x16, dat1
         stp x1,x2, [x3, #16]!
         mul x3, x16, x16
         ldr x14, [x16, #8]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 237FF8 in unpatched output.
 // CHECK: t4_ff8_stppost:
-// CHECK-NEXT:    237ff8:        d0 00 00 b0     adrp    x16, #102400
+// CHECK-NEXT:    237ff8:        50 01 00 b0     adrp    x16, #167936
 // CHECK-NEXT:    237ffc:        61 08 81 a8     stp     x1, x2, [x3], #16
 // CHECK-NEXT:    238000:        03 7e 10 9b     mul             x3, x16, x16
 // CHECK-FIX:     238004:        28 30 00 14     b       #49312
 // CHECK-NOFIX:   238004:        0e 06 40 f9     ldr     x14, [x16, #8]
 // CHECK-NEXT:    238008:        c0 03 5f d6     ret
         .section .text.20, "ax", %progbits
         .balign 4096
         .globl t4_ff8_stppost
         .type t4_ff8_stppost, %function
         .space 4096 - 8
 t4_ff8_stppost:
         adrp x16, dat2
         stp x1,x2, [x3], #16
         mul x3, x16, x16
         ldr x14, [x16, #8]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 239FFC in unpatched output.
 // CHECK: t4_ffc_stpsimd:
-// CHECK-NEXT:    239ffc:        b0 00 00 f0     adrp    x16, #94208
+// CHECK-NEXT:    239ffc:        30 01 00 f0     adrp    x16, #159744
 // CHECK-NEXT:    23a000:        61 08 00 ad     stp             q1, q2, [x3]
 // CHECK-NEXT:    23a004:        03 7e 10 9b     mul             x3, x16, x16
 // CHECK-FIX:     23a008:        29 28 00 14     b       #41124
 // CHECK-NOFIX:   23a008:        0e 06 40 f9     ldr     x14, [x16, #8]
 // CHECK-NEXT:    23a00c:        c0 03 5f d6     ret
         .section .text.21, "ax", %progbits
         .balign 4096
         .globl t4_ffc_stpsimd
         .type t4_ffc_stpsimd, %function
         .space 4096 - 4
 t4_ffc_stpsimd:
         adrp x16, dat3
         stp q1,q2, [x3, #0]
         mul x3, x16, x16
         ldr x14, [x16, #8]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23BFFC in unpatched output.
 // CHECK: t4_ffc_stnp:
-// CHECK-NEXT:    23bffc:        a7 00 00 b0     adrp    x7, #86016
+// CHECK-NEXT:    23bffc:        27 01 00 b0     adrp    x7, #151552
 // CHECK-NEXT:    23c000:        61 08 00 a8     stnp            x1, x2, [x3]
 // CHECK-NEXT:    23c004:        1f 20 03 d5     nop
 // CHECK-FIX:     23c008:        2b 20 00 14     b       #32940
 // CHECK-NOFIX:   23c008:        ea 00 40 f9     ldr             x10, [x7]
 // CHECK-NEXT:    23c00c:        c0 03 5f d6     ret
         .section .text.22, "ax", %progbits
         .balign 4096
         .globl t4_ffc_stnp
         .type t4_ffc_stnp, %function
         .space 4096 - 4
 t4_ffc_stnp:
         adrp x7, dat1
         stnp x1,x2, [x3, #0]
         nop
         ldr x10, [x7, :got_lo12:dat1]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23DFFC in unpatched output.
 // CHECK: t4_ffc_st1:
-// CHECK-NEXT:    23dffc:        98 00 00 f0     adrp    x24, #77824
+// CHECK-NEXT:    23dffc:        18 01 00 f0     adrp    x24, #143360
 // CHECK-NEXT:    23e000:        20 80 00 4d     st1 { v0.s }[2], [x1]
 // CHECK-NEXT:    23e004:        f6 06 40 f9     ldr     x22, [x23, #8]
 // CHECK-FIX:     23e008:        2d 18 00 14     b       #24756
 // CHECK-NOFIX:   23e008:        18 ff 3f f9     str     x24, [x24, #32760]
 // CHECK-NEXT:    23e00c:        c0 03 5f d6     ret
         .section .text.23, "ax", %progbits
         .balign 4096
         .globl t4_ffc_st1
         .type t4_ffc_st1, %function
         .space 4096 - 4
 t4_ffc_st1:
         adrp x24, dat2
         st1 { v0.s }[2], [x1]
         ldr x22, [x23, :got_lo12:dat2]
         str x24, [x24, #32760]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23FFF8 in unpatched output.
 // CHECK: t3_ff8_ldr_once:
-// CHECK-NEXT:    23fff8:        80 00 00 b0     adrp    x0, #69632
+// CHECK-NEXT:    23fff8:        00 01 00 b0     adrp    x0, #135168
 // CHECK-NEXT:    23fffc:        20 70 82 4c     st1     { v0.16b }, [x1], x2
 // CHECK-FIX:     240000:        31 10 00 14     b       #16580
 // CHECK-NOFIX:   240000:        01 08 40 f9     ldr     x1, [x0, #16]
 // CHECK-NEXT:    240004:        02 08 40 f9     ldr     x2, [x0, #16]
 // CHECK-NEXT:    240008:        c0 03 5f d6     ret
         .section .text.24, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldr_once
         .type t3_ff8_ldr_once, %function
         .space 4096 - 8
 t3_ff8_ldr_once:
         adrp x0, dat3
         st1 { v0.16b }, [x1], x2
         ldr x1, [x0, #16]
         ldr x2, [x0, #16]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 241FF8 in unpatched output.
 // CHECK: t3_ff8_ldxr:
-// CHECK-NEXT:    241ff8:        60 00 00 f0     adrp    x0, #61440
+// CHECK-NEXT:    241ff8:        e0 00 00 f0     adrp    x0, #126976
 // CHECK-NEXT:    241ffc:        03 7c 5f c8     ldxr    x3, [x0]
 // CHECK-FIX:     242000:        33 08 00 14     b       #8396
 // CHECK-NOFIX:   242000:        01 08 40 f9     ldr     x1, [x0, #16]
 // CHECK:         242004:        02 08 40 f9     ldr     x2, [x0, #16]
 // CHECK-NEXT:    242008:        c0 03 5f d6     ret
         .section .text.25, "ax", %progbits
         .balign 4096
         .globl t3_ff8_ldxr
         .type t3_ff8_ldxr, %function
         .space 4096 - 8
 t3_ff8_ldxr:
         adrp x0, dat3
         ldxr x3, [x0]
         ldr x1, [x0, #16]
         ldr x2, [x0, #16]
         ret
 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 243FF8 in unpatched output.
 // CHECK: t3_ff8_stxr:
-// CHECK-NEXT:    243ff8:        60 00 00 b0     adrp    x0, #53248
+// CHECK-NEXT:    243ff8:        e0 00 00 b0     adrp    x0, #118784
 // CHECK-NEXT:    243ffc:        03 7c 04 c8     stxr    w4, x3, [x0]
 // CHECK-FIX:     244000:        35 00 00 14     b       #212
 // CHECK-NOFIX:   244000:        01 08 40 f9     ldr     x1, [x0, #16]
 // CHECK:         244004:        02 08 40 f9     ldr     x2, [x0, #16]
 // CHECK-NEXT:    244008:        c0 03 5f d6     ret
         .section .text.26, "ax", %progbits
         .balign 4096
         .globl t3_ff8_stxr

lld/trunk/test/ELF/aarch64-cortex-a53-843419-thunk.s

 
 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 10FFC in unpatched output.
 // CHECK: t3_ff8_ldr:
 // CHECK-NEXT:    10ffc:        00 00 04 90     adrp    x0, #134217728
 // CHECK-NEXT:    11000:        21 00 40 f9     ldr     x1, [x1]
 // CHECK-NEXT:    11004:        02 00 00 14     b       #8
 // CHECK-NEXT:    11008:        c0 03 5f d6     ret
 // CHECK: __CortexA53843419_11004:
-// CHECK-NEXT:    1100c:        00 08 40 f9     ldr     x0, [x0, #16]
+// CHECK-NEXT:    1100c:        00 04 40 f9     ldr     x0, [x0, #8]
 // CHECK-NEXT:    11010:        fe ff ff 17     b       #-8
 
         .section .text.04, "ax", %progbits
         .globl far_away
         .type far_away, function
 far_away:
         ret
 
         .section .data
         .globl dat
 dat:    .quad 0

lld/trunk/test/ELF/aarch64-gnu-ifunc-address-pie.s

 # CHECK: 0000000000010004 main:
 # CHECK-NEXT:    10004: 08 00 00 90   adrp  x8, #0
 # x8 = 0x10000
 # CHECK-NEXT:    10008: 08 41 00 91   add x8, x8, #16
 # x8 = 0x10010 = .plt for myfunc
 # CHECK-NEXT:    1000c: c0 03 5f d6   ret
 # CHECK-NEXT: Disassembly of section .plt:
 # CHECK-NEXT: 0000000000010010 myfunc:
-# CHECK-NEXT:    10010: 90 00 00 90   adrp  x16, #65536
+# CHECK-NEXT:    10010: 10 01 00 90   adrp  x16, #131072
 # CHECK-NEXT:    10014: 11 02 40 f9   ldr x17, [x16]
 # CHECK-NEXT:    10018: 10 02 00 91   add x16, x16, #0
 # CHECK-NEXT:    1001c: 20 02 1f d6   br  x17
 
 # CHECK-RELOCS: Relocations [
 # CHECK-RELOCS-NEXT:   Section {{.*}} .rela.plt {
-# CHECK-RELOCS-NEXT:     0x20000 R_AARCH64_IRELATIVE - 0x10000
+# CHECK-RELOCS-NEXT:     0x30000 R_AARCH64_IRELATIVE - 0x10000
 # CHECK-RELOCS-NEXT:   }
 # CHECK-RELOCS-NEXT: ]

lld/trunk/test/ELF/aarch64-gnu-ifunc-plt.s

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %S/Inputs/shared2.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r -dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rela.plt {
-// CHECK:     0x220018 R_AARCH64_JUMP_SLOT bar2 0x0
-// CHECK-NEXT:     0x220020 R_AARCH64_JUMP_SLOT zed2 0x0
-// CHECK-NEXT:     0x220028 R_AARCH64_IRELATIVE - 0x210000
-// CHECK-NEXT:     0x220030 R_AARCH64_IRELATIVE - 0x210004
+// CHECK:     0x230018 R_AARCH64_JUMP_SLOT bar2 0x0
+// CHECK-NEXT:     0x230020 R_AARCH64_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:     0x230028 R_AARCH64_IRELATIVE - 0x210000
+// CHECK-NEXT:     0x230030 R_AARCH64_IRELATIVE - 0x210004
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Check that .got.plt entries point back to PLT header
 // GOTPLT: Contents of section .got.plt:
-// GOTPLT-NEXT:  220000 00000000 00000000 00000000 00000000
-// GOTPLT-NEXT:  220010 00000000 00000000 20002100 00000000
-// GOTPLT-NEXT:  220020 20002100 00000000 20002100 00000000
-// GOTPLT-NEXT:  220030 20002100 00000000
+// GOTPLT-NEXT:  230000 00000000 00000000 00000000 00000000
+// GOTPLT-NEXT:  230010 00000000 00000000 20002100 00000000
+// GOTPLT-NEXT:  230020 20002100 00000000 20002100 00000000
+// GOTPLT-NEXT:  230030 20002100 00000000
 
 // Check that the PLTRELSZ tag includes the IRELATIVE relocations
 // CHECK: DynamicSection [
 // CHECK:   0x0000000000000002 PLTRELSZ             96 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    210000: {{.*}} ret
 // DISASM:      bar:
 // DISASM-NEXT:    210004: {{.*}} ret
 // DISASM:      _start:
 // DISASM-NEXT:    210008: {{.*}} bl      #88
 // DISASM-NEXT:    21000c: {{.*}} bl      #100
 // DISASM-NEXT:    210010: {{.*}} bl      #48
 // DISASM-NEXT:    210014: {{.*}} bl      #60
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:    210020: {{.*}} stp     x16, x30, [sp, #-16]!
-// DISASM-NEXT:    210024: {{.*}} adrp    x16, #65536
+// DISASM-NEXT:    210024: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210028: {{.*}} ldr     x17, [x16, #16]
 // DISASM-NEXT:    21002c: {{.*}} add     x16, x16, #16
 // DISASM-NEXT:    210030: {{.*}} br      x17
 // DISASM-NEXT:    210034: {{.*}} nop
 // DISASM-NEXT:    210038: {{.*}} nop
 // DISASM-NEXT:    21003c: {{.*}} nop
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar2@plt:
-// DISASM-NEXT:    210040: {{.*}} adrp    x16, #65536
+// DISASM-NEXT:    210040: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210044: {{.*}} ldr     x17, [x16, #24]
 // DISASM-NEXT:    210048: {{.*}} add     x16, x16, #24
 // DISASM-NEXT:    21004c: {{.*}} br      x17
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed2@plt:
-// DISASM-NEXT:    210050: {{.*}} adrp    x16, #65536
+// DISASM-NEXT:    210050: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210054: {{.*}} ldr     x17, [x16, #32]
 // DISASM-NEXT:    210058: {{.*}} add     x16, x16, #32
 // DISASM-NEXT:    21005c: {{.*}} br      x17
-// DISASM-NEXT:    210060: {{.*}} adrp    x16, #65536
+// DISASM-NEXT:    210060: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210064: {{.*}} ldr     x17, [x16, #40]
 // DISASM-NEXT:    210068: {{.*}} add     x16, x16, #40
 // DISASM-NEXT:    21006c: {{.*}} br      x17
-// DISASM-NEXT:    210070: {{.*}} adrp    x16, #65536
+// DISASM-NEXT:    210070: {{.*}} adrp    x16, #131072
 // DISASM-NEXT:    210074: {{.*}} ldr     x17, [x16, #48]
 // DISASM-NEXT:    210078: {{.*}} add     x16, x16, #48
 // DISASM-NEXT:    21007c: {{.*}} br      x17
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:

lld/trunk/test/ELF/aarch64-ldprel-lo19-invalid.s

 # REQUIRES: aarch64
 
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-none %s -o %t.o
 # RUN: not ld.lld -shared %t.o -o /dev/null 2>&1 | FileCheck %s
 
-# CHECK: relocation R_AARCH64_LD_PREL_LO19 out of range: 2065536 is not in [-1048576, 1048575]
+# CHECK: relocation R_AARCH64_LD_PREL_LO19 out of range: 2131072 is not in [-1048576, 1048575]
 
   ldr x8, patatino
   .data
   .zero 2000000
 patatino:

lld/trunk/test/ELF/aarch64-load-alignment.s

 # REQUIRES: aarch64
 
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-none %s -o %t.o
 # RUN: not ld.lld -shared %t.o -o /dev/null 2>&1 | FileCheck %s
 
-# CHECK: improper alignment for relocation R_AARCH64_LD_PREL_LO19: 0x10005 is not aligned to 4 bytes
+# CHECK: improper alignment for relocation R_AARCH64_LD_PREL_LO19: 0x20005 is not aligned to 4 bytes
 
   ldr x8, patatino
   .data
   .zero 5
 patatino:

lld/trunk/test/ELF/aarch64-thunk-pi.s

 // CHECK-NEXT: 10000010:  10 00 f8 90   adrp  x16, #-268435456
 // CHECK-NEXT: 10000014:  10 82 03 91   add x16, x16, #224
 // CHECK-NEXT: 10000018:  00 02 1f d6   br  x16
 
 // CHECK: Disassembly of section .plt:
 // CHECK-NEXT: .plt:
 // CHECK-NEXT: 10000020:       f0 7b bf a9     stp     x16, x30, [sp, #-16]!
 // CHECK-NEXT: 10000024:       10 00 00 90     adrp    x16, #0
-// CHECK-NEXT: 10000028:       11 3a 40 f9     ldr     x17, [x16, #112]
-// CHECK-NEXT: 1000002c:       10 c2 01 91     add     x16, x16, #112
+// CHECK-NEXT: 10000028:       11 92 40 f9     ldr     x17, [x16, #288]
+// CHECK-NEXT: 1000002c:       10 82 04 91     add     x16, x16, #288
 // CHECK-NEXT: 10000030:       20 02 1f d6     br      x17
 // CHECK-NEXT: 10000034:       1f 20 03 d5     nop
 // CHECK-NEXT: 10000038:       1f 20 03 d5     nop
 // CHECK-NEXT: 1000003c:       1f 20 03 d5     nop
 // CHECK-EMPTY:
 // CHECK-NEXT:   high_target@plt:
 // CHECK-NEXT: 10000040:       10 00 00 90     adrp    x16, #0
-// CHECK-NEXT: 10000044:       11 3e 40 f9     ldr     x17, [x16, #120]
-// CHECK-NEXT: 10000048:       10 e2 01 91     add     x16, x16, #120
+// CHECK-NEXT: 10000044:       11 96 40 f9     ldr     x17, [x16, #296]
+// CHECK-NEXT: 10000048:       10 a2 04 91     add     x16, x16, #296
 // CHECK-NEXT: 1000004c:       20 02 1f d6     br      x17
 // CHECK-EMPTY:
 // CHECK-NEXT:   low_target@plt:
 // CHECK-NEXT: 10000050:       10 00 00 90     adrp    x16, #0
-// CHECK-NEXT: 10000054:       11 42 40 f9     ldr     x17, [x16, #128]
-// CHECK-NEXT: 10000058:       10 02 02 91     add     x16, x16, #128
+// CHECK-NEXT: 10000054:       11 9a 40 f9     ldr     x17, [x16, #304]
+// CHECK-NEXT: 10000058:       10 c2 04 91     add     x16, x16, #304
 // CHECK-NEXT: 1000005c:       20 02 1f d6     br      x17

lld/trunk/test/ELF/aarch64-tstbr14-reloc.s

 #DSOREL:      Section {
 #DSOREL:        Index:
 #DSOREL:        Name: .got.plt
 #DSOREL-NEXT:   Type: SHT_PROGBITS
 #DSOREL-NEXT:   Flags [
 #DSOREL-NEXT:     SHF_ALLOC
 #DSOREL-NEXT:     SHF_WRITE
 #DSOREL-NEXT:   ]
-#DSOREL-NEXT:   Address: 0x20000
-#DSOREL-NEXT:   Offset: 0x20000
+#DSOREL-NEXT:   Address: 0x30000
+#DSOREL-NEXT:   Offset: 0x30000
 #DSOREL-NEXT:   Size: 40
 #DSOREL-NEXT:   Link: 0
 #DSOREL-NEXT:   Info: 0
 #DSOREL-NEXT:   AddressAlignment: 8
 #DSOREL-NEXT:   EntrySize: 0
 #DSOREL-NEXT:  }
 #DSOREL:      Relocations [
 #DSOREL-NEXT:  Section ({{.*}}) .rela.plt {
-#DSOREL-NEXT:    0x20018 R_AARCH64_JUMP_SLOT _foo
-#DSOREL-NEXT:    0x20020 R_AARCH64_JUMP_SLOT _bar
+#DSOREL-NEXT:    0x30018 R_AARCH64_JUMP_SLOT _foo
+#DSOREL-NEXT:    0x30020 R_AARCH64_JUMP_SLOT _bar
 #DSOREL-NEXT:  }
 #DSOREL-NEXT:]
 
 #DSO:      Disassembly of section .text:
 #DSO-NEXT: _foo:
 #DSO-NEXT:  10000: {{.*}} nop
 #DSO-NEXT:  10004: {{.*}} nop
 #DSO-NEXT:  10008: {{.*}} nop

 # 0x10028 + 56 = 0x10060 = PLT[2]
 #DSO-NEXT:  1001c: {{.*}} tbnz w3, #15, #52
 #DSO-NEXT:  10020: {{.*}} tbnz w3, #15, #64
 #DSO-NEXT:  10024: {{.*}} tbz x6, #45, #44
 #DSO-NEXT:  10028: {{.*}} tbz x6, #45, #56
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-NEXT: .plt:
 #DSO-NEXT:  10030: {{.*}} stp x16, x30, [sp, #-16]!
-#DSO-NEXT:  10034: {{.*}} adrp x16, #65536
+#DSO-NEXT:  10034: {{.*}} adrp x16, #131072
 #DSO-NEXT:  10038: {{.*}} ldr x17, [x16, #16]
 #DSO-NEXT:  1003c: {{.*}} add x16, x16, #16
 #DSO-NEXT:  10040: {{.*}} br x17
 #DSO-NEXT:  10044: {{.*}} nop
 #DSO-NEXT:  10048: {{.*}} nop
 #DSO-NEXT:  1004c: {{.*}} nop
 #DSO-EMPTY:
 #DSO-NEXT:   _foo@plt:
-#DSO-NEXT:  10050: {{.*}} adrp x16, #65536
+#DSO-NEXT:  10050: {{.*}} adrp x16, #131072
 #DSO-NEXT:  10054: {{.*}} ldr x17, [x16, #24]
 #DSO-NEXT:  10058: {{.*}} add x16, x16, #24
 #DSO-NEXT:  1005c: {{.*}} br x17
 #DSO-EMPTY:
 #DSO-NEXT:   _bar@plt:
-#DSO-NEXT:  10060: {{.*}} adrp x16, #65536
+#DSO-NEXT:  10060: {{.*}} adrp x16, #131072
 #DSO-NEXT:  10064: {{.*}} ldr x17, [x16, #32]
 #DSO-NEXT:  10068: {{.*}} add x16, x16, #32
 #DSO-NEXT:  1006c: {{.*}} br x17
 
 .globl _start
 _start:
  tbnz w3, #15, _foo
  tbnz w3, #15, _bar
  tbz x6, #45, _foo
  tbz x6, #45, _bar

lld/trunk/test/ELF/amdgpu-relocs.s

 # CHECK-NEXT: R_AMDGPU_ABS64 weakref_alias_var2 0x0
 # CHECK-NEXT: }
 # CHECK-NEXT: ]
 
 # OBJDUMP: Contents of section .rodata:
 # OBJDUMP: d0f8ffff ffffffff
 
 # OBJDUMP: Contents of section nonalloc:
-# OBJDUMP-NEXT: 0000 00000000 04480000 00000000 08440000
-# OBJDUMP-NEXT: 00000000 0c400000
+# OBJDUMP-NEXT: 0000 00000000 14380000 00000000 18340000
+# OBJDUMP-NEXT: 00000000 1c300000

lld/trunk/test/ELF/arm-abs32-dyn.s

  .data
  .word foo
  .word bar
 
 // RUN: ld.lld -shared -o %t.so %t.o
 // RUN: llvm-readobj -symbols -dyn-relocations %t.so | FileCheck %s
 
 // CHECK:      Dynamic Relocations {
-// CHECK-NEXT:   0x1004 R_ARM_RELATIVE
-// CHECK-NEXT:   0x1000 R_ARM_ABS32 foo 0x0
+// CHECK-NEXT:   0x2004 R_ARM_RELATIVE
+// CHECK-NEXT:   0x2000 R_ARM_ABS32 foo 0x0
 // CHECK-NEXT: }
 
 // CHECK:      Symbols [
 // CHECK:        Symbol {
 // CHECK:          Name: bar
 // CHECK-NEXT:     Value: 0x1000
 
 // CHECK:        Symbol {
 // CHECK:          Name: foo
 // CHECK-NEXT:     Value: 0x1000

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

 
  .section .text.__aeabi_unwind_cpp_pr0, "ax", %progbits
  .global __aeabi_unwind_cpp_pr0
 __aeabi_unwind_cpp_pr0:
  bx lr
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section {{.*}} .rel.plt {
-// CHECK-NEXT:     0x200C R_ARM_JUMP_SLOT __gxx_personality_v0
+// 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

lld/trunk/test/ELF/arm-fpic-got.s

 
 // CHECK: Section {
 // CHECK:    Name: .got
 // CHECK-NEXT:    Type: SHT_PROGBITS
 // CHECK-NEXT:      Flags [
 // CHECK-NEXT:      SHF_ALLOC
 // CHECK-NEXT:      SHF_WRITE
 // CHECK-NEXT:    ]
-// CHECK-NEXT:    Address: 0x13000
+// CHECK-NEXT:    Address: 0x12000
 // CHECK-NEXT:    Offset:
 // CHECK-NEXT:    Size: 4
 // CHECK-NEXT:    Link:
 // CHECK-NEXT:    Info:
 // CHECK-NEXT:    AddressAlignment: 4
 // CHECK-NEXT:    EntrySize:
 
 // SYMBOLS:    Name: val
-// SYMBOLS-NEXT:    Value: 0x12000
+// SYMBOLS-NEXT:    Value: 0x13000
 // SYMBOLS-NEXT:    Size: 4
 // SYMBOLS-NEXT:    Binding: Global
 // SYMBOLS-NEXT:    Type: Object
 // SYMBOLS-NEXT:    Other:
 // SYMBOLS-NEXT:    Section: .data
 
 // CODE: Disassembly of section .text:
 // CODE-NEXT: _start:
 // CODE-NEXT:   11000:  08 00 9f e5     ldr     r0, [pc, #8]
 // CODE-NEXT:   11004:  00 00 9f e7     ldr     r0, [pc, r0]
 // CODE-NEXT:   11008:  00 00 90 e5     ldr     r0, [r0]
 // CODE-NEXT:   1100c:  1e ff 2f e1     bx      lr
 // CODE: $d.1:
-// 0x11004 + 0x1ff4 + 8 = 0x13000 = .got
-// CODE-NEXT:   11010:  f4 1f 00 00
+// 0x11004 + 0x0ff4 + 8 = 0x12000 = .got
+// CODE-NEXT:   11010:  f4 0f 00 00

lld/trunk/test/ELF/arm-gnu-ifunc-plt.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-linux-gnueabihf %S/Inputs/arm-shared.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=armv7a-linux-gnueabihf %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -triple=armv7a-linux-gnueabihf -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r -dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are last in the .got
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rel.dyn {
-// CHECK-NEXT:     0x13078 R_ARM_GLOB_DAT bar2 0x0
-// CHECK-NEXT:     0x1307C R_ARM_GLOB_DAT zed2 0x0
-// CHECK-NEXT:     0x13080 R_ARM_IRELATIVE - 0x0
-// CHECK-NEXT:     0x13084 R_ARM_IRELATIVE - 0x0
+// CHECK-NEXT:     0x12078 R_ARM_GLOB_DAT bar2 0x0
+// CHECK-NEXT:     0x1207C R_ARM_GLOB_DAT zed2 0x0
+// CHECK-NEXT:     0x12080 R_ARM_IRELATIVE - 0x0
+// CHECK-NEXT:     0x12084 R_ARM_IRELATIVE - 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section (5) .rel.plt {
-// CHECK-NEXT:     0x1200C R_ARM_JUMP_SLOT bar2 0x0
-// CHECK-NEXT:     0x12010 R_ARM_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:     0x1300C R_ARM_JUMP_SLOT bar2 0x0
+// CHECK-NEXT:     0x13010 R_ARM_JUMP_SLOT zed2 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Check that the GOT entries refer back to the ifunc resolver
-// GOTPLT: Contents of section .got.plt:
-// GOTPLT-NEXT:  12000 00000000 00000000 00000000 20100100
-// GOTPLT-NEXT:  12010 20100100
 // GOTPLT: Contents of section .got:
-// GOTPLT-NEXT:  13078 00000000 00000000 00100100 04100100
+// GOTPLT-NEXT:  12078 00000000 00000000 00100100 04100100
+// GOTPLT: Contents of section .got.plt:
+// GOTPLT-NEXT:  13000 00000000 00000000 00000000 20100100
+// GOTPLT-NEXT:  13010 20100100
 
 // DISASM: Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    11000:       1e ff 2f e1     bx      lr
 // DISASM: bar:
 // DISASM-NEXT:    11004:       1e ff 2f e1     bx      lr
 // DISASM: _start:
 // DISASM-NEXT:    11008:       14 00 00 eb     bl      #80
 // DISASM-NEXT:    1100c:       17 00 00 eb     bl      #92
 // DISASM: $d.1:
 // DISASM-NEXT:    11010:       00 00 00 00     .word   0x00000000
 // DISASM-NEXT:    11014:       04 00 00 00     .word   0x00000004
 // DISASM:         11018:       08 00 00 eb     bl      #32
 // DISASM-NEXT:    1101c:       0b 00 00 eb     bl      #44
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: $a:
 // DISASM-NEXT:    11020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // DISASM-NEXT:    11024:       00 e6 8f e2     add     lr, pc, #0, #12
-// DISASM-NEXT:    11028:       00 ea 8e e2     add     lr, lr, #0, #20
+// DISASM-NEXT:    11028:       01 ea 8e e2     add     lr, lr, #4096
 // DISASM-NEXT:    1102c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // DISASM: $d:
 // DISASM-NEXT:    11030:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM-NEXT:    11034:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM-NEXT:    11038:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM-NEXT:    1103c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM: $a:
 // DISASM-NEXT:    11040:       00 c6 8f e2     add     r12, pc, #0, #12
-// DISASM-NEXT:    11044:       00 ca 8c e2     add     r12, r12, #0, #20
+// DISASM-NEXT:    11044:       01 ca 8c e2     add     r12, r12, #4096
 // DISASM-NEXT:    11048:       c4 ff bc e5     ldr     pc, [r12, #4036]!
 // DISASM: $d:
 // DISASM-NEXT:    1104c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM: $a:
 // DISASM-NEXT:    11050:       00 c6 8f e2     add     r12, pc, #0, #12
-// DISASM-NEXT:    11054:       00 ca 8c e2     add     r12, r12, #0, #20
+// DISASM-NEXT:    11054:       01 ca 8c e2     add     r12, r12, #4096
 // DISASM-NEXT:    11058:       b8 ff bc e5     ldr     pc, [r12, #4024]!
 // DISASM: $d:
 // DISASM-NEXT:    1105c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM: $a:
 // DISASM-NEXT:    11060:       00 c6 8f e2     add     r12, pc, #0, #12
-// DISASM-NEXT:    11064:       02 ca 8c e2     add     r12, r12, #8192
+// DISASM-NEXT:    11064:       01 ca 8c e2     add     r12, r12, #4096
 // DISASM-NEXT:    11068:       18 f0 bc e5     ldr     pc, [r12, #24]!
 // DISASM: $d:
 // DISASM-NEXT:    1106c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DISASM: $a:
 // DISASM-NEXT:    11070:       00 c6 8f e2     add     r12, pc, #0, #12
-// DISASM-NEXT:    11074:       02 ca 8c e2     add     r12, r12, #8192
+// DISASM-NEXT:    11074:       01 ca 8c e2     add     r12, r12, #4096
 // DISASM-NEXT:    11078:       0c f0 bc e5     ldr     pc, [r12, #12]!
 // DISASM: $d:
 // DISASM-NEXT:   1107c:  d4 d4 d4 d4   .word 0xd4d4d4d4
 
 .syntax unified
 .text
 .type foo STT_GNU_IFUNC
 .globl foo

lld/trunk/test/ELF/arm-pie-relative.s

 
  .data
  .global sym
 sym:
  .word 0
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rel.dyn {
-// CHECK-NEXT:     0x3058 R_ARM_RELATIVE
+// CHECK-NEXT:     0x2058 R_ARM_RELATIVE
 
 // GOT: Contents of section .got:
-// GOT-NEXT:  3058 00200000
+// GOT-NEXT:  2058 00300000

lld/trunk/test/ELF/arm-plt-reloc.s

 // DSO-NEXT:     100c:       0b 00 00 ea     b       #44
 // S(0x1050) - P(0x1010) + A(-8) = 0x38 = 56
 // DSO-NEXT:     1010:       0e 00 00 eb     bl      #56
 // S(0x10160) - P(0x1014) + A(-8) = 0x44 = 68
 // DSO-NEXT:     1014:       11 00 00 0a     beq     #68
 // DSO-NEXT: Disassembly of section .plt:
 // DSO-NEXT: $a:
 // DSO-NEXT:     1020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // (0x1024 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfdc) = 0x2008 = .got.plt[3]
 // DSO-NEXT:     1024:       00 e6 8f e2     add     lr, pc, #0, #12
-// DSO-NEXT:     1028:       00 ea 8e e2     add     lr, lr, #0, #20
+// DSO-NEXT:     1028:       01 ea 8e e2     add     lr, lr, #4096
 // DSO-NEXT:     102c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // DSO: $d:
 // DSO-NEXT:     1030:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSO-NEXT:     1034:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSO-NEXT:     1038:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSO-NEXT:     103c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSO: $a:
 // (0x1040 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfc4) = 0x200c
 // DSO-NEXT:     1040:       00 c6 8f e2     add     r12, pc, #0, #12
-// DSO-NEXT:     1044:       00 ca 8c e2     add     r12, r12, #0, #20
+// DSO-NEXT:     1044:       01 ca 8c e2     add     r12, r12, #4096
 // DSO-NEXT:     1048:       c4 ff bc e5     ldr     pc, [r12, #4036]!
 // DSO: $d:
 // DSO-NEXT:     104c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSO: $a:
 // (0x1050 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfb8) = 0x2010
 // DSO-NEXT:     1050:       00 c6 8f e2     add     r12, pc, #0, #12
-// DSO-NEXT:     1054:       00 ca 8c e2     add     r12, r12, #0, #20
+// DSO-NEXT:     1054:       01 ca 8c e2     add     r12, r12, #4096
 // DSO-NEXT:     1058:       b8 ff bc e5     ldr     pc, [r12, #4024]!
 // DSO: $d:
 // DSO-NEXT:     105c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSO: $a:
 // (0x1060 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfac) = 0x2014
 // DSO-NEXT:     1060:       00 c6 8f e2     add     r12, pc, #0, #12
-// DSO-NEXT:     1064:       00 ca 8c e2     add     r12, r12, #0, #20
+// DSO-NEXT:     1064:       01 ca 8c e2     add     r12, r12, #4096
 // DSO-NEXT:     1068:       ac ff bc e5     ldr     pc, [r12, #4012]!
 // DSO: $d:
 // DSO-NEXT:     106c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 
 
 // DSOREL:    Name: .got.plt
 // DSOREL-NEXT:    Type: SHT_PROGBITS
 // DSOREL-NEXT:    Flags [
 // DSOREL-NEXT:      SHF_ALLOC
 // DSOREL-NEXT:      SHF_WRITE
 // DSOREL-NEXT:    ]
-// DSOREL-NEXT:    Address: 0x2000
+// DSOREL-NEXT:    Address: 0x3000
 // DSOREL-NEXT:    Offset:
 // DSOREL-NEXT:    Size: 24
 // DSOREL-NEXT:    Link:
 // DSOREL-NEXT:    Info:
 // DSOREL-NEXT:    AddressAlignment: 4
 // DSOREL-NEXT:    EntrySize:
 // DSOREL:  Relocations [
 // DSOREL-NEXT:  Section {{.*}} .rel.plt {
-// DSOREL-NEXT:    0x200C R_ARM_JUMP_SLOT func1 0x0
-// DSOREL-NEXT:    0x2010 R_ARM_JUMP_SLOT func2 0x0
-// DSOREL-NEXT:    0x2014 R_ARM_JUMP_SLOT func3 0x0
+// DSOREL-NEXT:    0x300C R_ARM_JUMP_SLOT func1 0x0
+// DSOREL-NEXT:    0x3010 R_ARM_JUMP_SLOT func2 0x0
+// DSOREL-NEXT:    0x3014 R_ARM_JUMP_SLOT func3 0x0
 
 // Test a large separation between the .plt and .got.plt
 // The .got.plt and .plt displacement is large but still within the range
 // of the short plt sequence.
 // RUN: echo "SECTIONS { \
 // RUN:       .text 0x1000 : { *(.text) } \
 // RUN:       .plt  0x2000 : { *(.plt) *(.plt.*) } \
 // RUN:       .got.plt 0x1100000 : { *(.got.plt) } \

lld/trunk/test/ELF/arm-thumb-interwork-shared.s

 // CHECK-NEXT:     1018:       c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:     101c:       fc 44   add     r12, pc
 // CHECK-NEXT:     101e:       60 47   bx      r12
 
 // PLT: Disassembly of section .plt:
 // PLT-NEXT: $a:
 // PLT-NEXT:     1020:  04 e0 2d e5     str     lr, [sp, #-4]!
 // PLT-NEXT:     1024:  00 e6 8f e2     add     lr, pc, #0, #12
-// PLT-NEXT:     1028:  00 ea 8e e2     add     lr, lr, #0, #20
+// PLT-NEXT:     1028:  01 ea 8e e2     add     lr, lr, #4096
 // PLT-NEXT:     102c:  dc ff be e5     ldr     pc, [lr, #4060]!
 // PLT: $d:
 // PLT-NEXT:     1030:  d4 d4 d4 d4     .word   0xd4d4d4d4
 // PLT-NEXT:     1034:  d4 d4 d4 d4     .word   0xd4d4d4d4
 // PLT-NEXT:     1038:  d4 d4 d4 d4     .word   0xd4d4d4d4
 // PLT-NEXT:     103c:  d4 d4 d4 d4     .word   0xd4d4d4d4
 // PLT: $a:
 // PLT-NEXT:     1040:  00 c6 8f e2     add     r12, pc, #0, #12
-// PLT-NEXT:     1044:  00 ca 8c e2     add     r12, r12, #0, #20
+// PLT-NEXT:     1044:  01 ca 8c e2     add     r12, r12, #4096
 // PLT-NEXT:     1048:  c4 ff bc e5     ldr     pc, [r12, #4036]!
 // PLT: $d:
 // PLT-NEXT:     104c:  d4 d4 d4 d4     .word   0xd4d4d4d4
 // PLT: $a:
 // PLT-NEXT:     1050:  00 c6 8f e2     add     r12, pc, #0, #12
-// PLT-NEXT:     1054:  00 ca 8c e2     add     r12, r12, #0, #20
+// PLT-NEXT:     1054:  01 ca 8c e2     add     r12, r12, #4096
 // PLT-NEXT:     1058:  b8 ff bc e5     ldr     pc, [r12, #4024]!
 // PLT: $d:
 // PLT-NEXT:     105c:  d4 d4 d4 d4     .word   0xd4d4d4d4
 

lld/trunk/test/ELF/arm-thumb-plt-range-thunk-os.s

 
 // CHECK3: far_preemptible:
 // CHECK3:  4000000:       00 f0 16 e8     blx     #44
 
 // CHECK4: Disassembly of section .plt:
 // CHECK4-NEXT: $a:
 // CHECK4-NEXT:  4000010: 04 e0 2d e5   str lr, [sp, #-4]!
 // CHECK4-NEXT:  4000014: 00 e6 8f e2   add lr, pc, #0, #12
-// CHECK4-NEXT:  4000018: 00 ea 8e e2   add lr, lr, #0, #20
+// CHECK4-NEXT:  4000018: 01 ea 8e e2   add lr, lr, #4096
 // CHECK4-NEXT:  400001c: ec ff be e5   ldr pc, [lr, #4076]!
 // CHECK4: $d:
 // CHECK4-NEXT:  4000020: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4-NEXT:  4000024: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4-NEXT:  4000028: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4-NEXT:  400002c: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4: $a:
 // CHECK4-NEXT:  4000030: 00 c6 8f e2   add r12, pc, #0, #12
-// CHECK4-NEXT:  4000034: 00 ca 8c e2   add r12, r12, #0, #20
+// CHECK4-NEXT:  4000034: 01 ca 8c e2   add r12, r12, #4096
 // CHECK4-NEXT:  4000038: d4 ff bc e5   ldr pc, [r12, #4052]!
 // CHECK4: $d:
 // CHECK4-NEXT:  400003c: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4: $a:
 // CHECK4-NEXT:  4000040: 00 c6 8f e2   add r12, pc, #0, #12
-// CHECK4-NEXT:  4000044: 00 ca 8c e2   add r12, r12, #0, #20
+// CHECK4-NEXT:  4000044: 01 ca 8c e2   add r12, r12, #4096
 // CHECK4-NEXT:  4000048: c8 ff bc e5   ldr pc, [r12, #4040]!
 // CHECK4: $d:
 // CHECK4-NEXT:  400004c: d4 d4 d4 d4   .word 0xd4d4d4d4
 // CHECK4: $a:
 // CHECK4-NEXT:  4000050: 00 c6 8f e2   add r12, pc, #0, #12
-// CHECK4-NEXT:  4000054: 00 ca 8c e2   add r12, r12, #0, #20
+// CHECK4-NEXT:  4000054: 01 ca 8c e2   add r12, r12, #4096
 // CHECK4-NEXT:  4000058: bc ff bc e5   ldr pc, [r12, #4028]!
 // CHECK4: $d:
 // CHECK4-NEXT:  400005c: d4 d4 d4 d4   .word 0xd4d4d4d4

lld/trunk/test/ELF/arm-thumb-plt-reloc.s

 // DSOTHUMB-NEXT:     1008:     00 f0 1a e8     blx     #52
 // 0x100c + 0x40 + 4 = 0x1050 = PLT func2
 // DSOTHUMB-NEXT:     100c:     00 f0 20 e8     blx     #64
 // 0x1010 + 0x4C + 4 = 0x1060 = PLT func3
 // DSOTHUMB-NEXT:     1010:     00 f0 26 e8     blx     #76
 // DSOARM: Disassembly of section .plt:
 // DSOARM-NEXT: $a:
 // DSOARM-NEXT:     1020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // (0x1024 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfdc) = 0x2008 = .got.plt[3]
 // DSOARM-NEXT:     1024:       00 e6 8f e2     add     lr, pc, #0, #12
-// DSOARM-NEXT:     1028:       00 ea 8e e2     add     lr, lr, #0, #20
+// DSOARM-NEXT:     1028:       01 ea 8e e2     add     lr, lr, #4096
 // DSOARM-NEXT:     102c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // DSOARM: $d:
 
 // DSOARM-NEXT:     1030:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSOARM-NEXT:     1034:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSOARM-NEXT:     1038:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSOARM-NEXT:     103c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSOARM: $a:
 // (0x1040 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfc4) = 0x200c
 // DSOARM-NEXT:     1040:       00 c6 8f e2     add     r12, pc, #0, #12
-// DSOARM-NEXT:     1044:       00 ca 8c e2     add     r12, r12, #0, #20
+// DSOARM-NEXT:     1044:       01 ca 8c e2     add     r12, r12, #4096
 // DSOARM-NEXT:     1048:       c4 ff bc e5     ldr     pc, [r12, #4036]!
 // DSOARM: $d:
 // DSOARM-NEXT:     104c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSOARM: $a:
 // (0x1050 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfb8) = 0x2010
 // DSOARM-NEXT:     1050:       00 c6 8f e2     add     r12, pc, #0, #12
-// DSOARM-NEXT:     1054:       00 ca 8c e2     add     r12, r12, #0, #20
+// DSOARM-NEXT:     1054:       01 ca 8c e2     add     r12, r12, #4096
 // DSOARM-NEXT:     1058:       b8 ff bc e5     ldr     pc, [r12, #4024]!
 // DSOARM: $d:
 // DSOARM-NEXT:     105c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // DSOARM: $a:
 // (0x1060 + 8) + (0 RoR 12) + (0 RoR 20) + (0xfac) = 0x2014
 // DSOARM-NEXT:     1060:       00 c6 8f e2     add     r12, pc, #0, #12
-// DSOARM-NEXT:     1064:       00 ca 8c e2     add     r12, r12, #0, #20
+// DSOARM-NEXT:     1064:       01 ca 8c e2     add     r12, r12, #4096
 // DSOARM-NEXT:     1068:       ac ff bc e5     ldr     pc, [r12, #4012]!
 // DSOARM: $d:
 // DSOARM-NEXT:     106c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 
 // DSOREL:    Name: .got.plt
 // DSOREL-NEXT:    Type: SHT_PROGBITS
 // DSOREL-NEXT:    Flags [
 // DSOREL-NEXT:      SHF_ALLOC
 // DSOREL-NEXT:      SHF_WRITE
 // DSOREL-NEXT:    ]
-// DSOREL-NEXT:    Address: 0x2000
+// DSOREL-NEXT:    Address: 0x3000
 // DSOREL-NEXT:    Offset:
 // DSOREL-NEXT:    Size: 24
 // DSOREL-NEXT:    Link:
 // DSOREL-NEXT:    Info:
 // DSOREL-NEXT:    AddressAlignment: 4
 // DSOREL-NEXT:    EntrySize:
 // DSOREL:  Relocations [
 // DSOREL-NEXT:  Section (4) .rel.plt {
-// DSOREL-NEXT:    0x200C R_ARM_JUMP_SLOT func1 0x0
-// DSOREL-NEXT:    0x2010 R_ARM_JUMP_SLOT func2 0x0
-// DSOREL-NEXT:    0x2014 R_ARM_JUMP_SLOT func3 0x0
+// DSOREL-NEXT:    0x300C R_ARM_JUMP_SLOT func1 0x0
+// DSOREL-NEXT:    0x3010 R_ARM_JUMP_SLOT func2 0x0
+// DSOREL-NEXT:    0x3014 R_ARM_JUMP_SLOT func3 0x0

lld/trunk/test/ELF/arm-thunk-multipass-plt.s

preemptible2:
         .section .text.11, "ax", %progbits
         .space (5 * 1024 * 1024)
 
 
 // CHECK-PLT: Disassembly of section .plt:
 // CHECK-PLT-NEXT: 0000000000d00020 $a:
 // CHECK-PLT-NEXT:   d00020:    04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECK-PLT-NEXT:   d00024:    00 e6 8f e2     add     lr, pc, #0, #12
-// CHECK-PLT-NEXT:   d00028:    00 ea 8e e2     add     lr, lr, #0, #20
+// CHECK-PLT-NEXT:   d00028:    01 ea 8e e2     add     lr, lr, #4096
 // CHECK-PLT-NEXT:   d0002c:    dc ff be e5     ldr     pc, [lr, #4060]!
 // CHECK-PLT: 0000000000d00030 $d:
 // CHECK-PLT-NEXT:   d00030:    d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK-PLT-NEXT:   d00034:    d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK-PLT-NEXT:   d00038:    d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK-PLT-NEXT:   d0003c:    d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK-PLT: 0000000000d00040 $a:
 // CHECK-PLT-NEXT:   d00040:    00 c6 8f e2     add     r12, pc, #0, #12
-// CHECK-PLT-NEXT:   d00044:    00 ca 8c e2     add     r12, r12, #0, #20
+// CHECK-PLT-NEXT:   d00044:    01 ca 8c e2     add     r12, r12, #4096
 // CHECK-PLT-NEXT:   d00048:    c4 ff bc e5     ldr     pc, [r12, #4036]!
 // CHECK-PLT: 0000000000d0004c $d:
 // CHECK-PLT-NEXT:   d0004c:    d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK-PLT: 0000000000d00050 $a:
 // CHECK-PLT-NEXT:   d00050:    00 c6 8f e2     add     r12, pc, #0, #12
-// CHECK-PLT-NEXT:   d00054:    00 ca 8c e2     add     r12, r12, #0, #20
+// CHECK-PLT-NEXT:   d00054:    01 ca 8c e2     add     r12, r12, #4096
 // CHECK-PLT-NEXT:   d00058:    b8 ff bc e5     ldr     pc, [r12, #4024]!
 // CHECK-PLT: 0000000000d0005c $d:
 // CHECK-PLT-NEXT:   d0005c:    d4 d4 d4 d4     .word   0xd4d4d4d4

lld/trunk/test/ELF/arm-thunk-re-add.s

 // CHECK2-NEXT:  1100014:       ff f6 f6 bf     b.w     #-1048596 <__ThumbV7PILongThunk_imported>
 // CHECK2-NEXT:  1100018:       3f f4 f6 af     beq.w   #-20 <__ThumbV7PILongThunk_imported>
 // CHECK2-NEXT:  110001c:       ff f6 f8 bf     b.w     #-1048592 <__ThumbV7PILongThunk_imported2>
 
 // CHECK3: Disassembly of section .plt:
 // CHECK3-NEXT: $a:
 // CHECK3-NEXT:  1100020:       04 e0 2d e5     str     lr, [sp, #-4]!
 // CHECK3-NEXT:  1100024:       00 e6 8f e2     add     lr, pc, #0, #12
-// CHECK3-NEXT:  1100028:       00 ea 8e e2     add     lr, lr, #0, #20
+// CHECK3-NEXT:  1100028:       01 ea 8e e2     add     lr, lr, #4096
 // CHECK3-NEXT:  110002c:       dc ff be e5     ldr     pc, [lr, #4060]!
 // CHECK3: $d:
 // CHECK3-NEXT:  1100030:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK3-NEXT:  1100034:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK3-NEXT:  1100038:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK3-NEXT:  110003c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK3: $a:
 // CHECK3-NEXT:  1100040:       00 c6 8f e2     add     r12, pc, #0, #12
-// CHECK3-NEXT:  1100044:       00 ca 8c e2     add     r12, r12, #0, #20
+// CHECK3-NEXT:  1100044:       01 ca 8c e2     add     r12, r12, #4096
 // CHECK3-NEXT:  1100048:       c4 ff bc e5     ldr     pc, [r12, #4036]!
 // CHECK3: $d:
 // CHECK3-NEXT:  110004c:       d4 d4 d4 d4     .word   0xd4d4d4d4
 // CHECK3: $a:
 // CHECK3-NEXT:  1100050:       00 c6 8f e2     add     r12, pc, #0, #12
-// CHECK3-NEXT:  1100054:       00 ca 8c e2     add     r12, r12, #0, #20
+// CHECK3-NEXT:  1100054:       01 ca 8c e2     add     r12, r12, #4096
 // CHECK3-NEXT:  1100058:       b8 ff bc e5     ldr     pc, [r12, #4024]!
 // CHECK3: $d:
 // CHECK3-NEXT:  110005c:       d4 d4 d4 d4     .word   0xd4d4d4d4

lld/trunk/test/ELF/arm-tls-norelax-gd-ie.s

 .L0:
  .globl __tls_get_addr
  bl __tls_get_addr
  bx lr
  .p2align 2
  .Lt0: .word   y(TLSGD) + (. - .L0 - 8)
 
 // CHECK: Dynamic Relocations {
-// CHECK-NEXT:   0x13078 R_ARM_TLS_DTPMOD32 y
-// CHECK-NEXT:   0x1307C R_ARM_TLS_DTPOFF32 y
-// CHECK-NEXT:   0x1200C R_ARM_JUMP_SLOT __tls_get_addr
+// CHECK-NEXT:   0x12078 R_ARM_TLS_DTPMOD32 y
+// CHECK-NEXT:   0x1207C R_ARM_TLS_DTPOFF32 y
+// CHECK-NEXT:   0x1300C R_ARM_JUMP_SLOT __tls_get_addr

lld/trunk/test/ELF/arm-tls-norelax-gd-le.s

 .section       .tbss,"awT",%nobits
  .p2align  2
 x:
  .space 4
  .type  x, %object
 
 // CHECK:       Contents of section .got:
 // Module index is always 1 for executable
-// CHECK-NEXT:  13060 01000000 00000000
+// CHECK-NEXT:  12060 01000000 00000000
 
 
 // Without any definition of __tls_get_addr we get an error
 // RUN: not ld.lld  %t.o -o %t 2>&1 | FileCheck --check-prefix=ERR %s
 // ERR: error: undefined symbol: __tls_get_addr

lld/trunk/test/ELF/arm-tls-norelax-ie-le.s

  .section       .tbss,"awT",%nobits
  .type  x1, %object
 x2:
  .space 4
  .type x2, %object
 
 // CHECK: Contents of section .got:
 // x1 at offset 0x20 from TP, x2 at offset 0x24 from TP. Offsets include TCB size of 0x20
-// CHECK-NEXT: 13064 20000000 24000000
+// CHECK-NEXT: 12064 20000000 24000000

lld/trunk/test/ELF/arm-tls-norelax-ld-le.s

  .space  4
  .section        .tdata,"awT",%progbits
  .p2align  2
  .type   x, %object
 x:
  .word   10
 
 // CHECK: Contents of section .got:
-// CHECK-NEXT:  13064 01000000 00000000
+// CHECK-NEXT:  12064 01000000 00000000

lld/trunk/test/ELF/combrelocs.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -shared %t.o -o %t.out
 # RUN: llvm-readobj -r --expand-relocs --dynamic-table %t.out | FileCheck %s
 
 # RUN: ld.lld -shared %t.o -o %t.out -z combreloc
 # RUN: llvm-readobj -r --expand-relocs --dynamic-table %t.out | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 # CHECK-NEXT:     Relocation {
-# CHECK-NEXT:       Offset: 0x1000
+# CHECK-NEXT:       Offset: 0x2000
 # CHECK-NEXT:       Type: R_X86_64_64
 # CHECK-NEXT:       Symbol: aaa (1)
 # CHECK-NEXT:       Addend: 0x0
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Relocation {
-# CHECK-NEXT:       Offset: 0x1018
+# CHECK-NEXT:       Offset: 0x2018
 # CHECK-NEXT:       Type: R_X86_64_64
 # CHECK-NEXT:       Symbol: aaa (1)
 # CHECK-NEXT:       Addend: 0x0
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Relocation {
-# CHECK-NEXT:       Offset: 0x1010
+# CHECK-NEXT:       Offset: 0x2010
 # CHECK-NEXT:       Type: R_X86_64_64
 # CHECK-NEXT:       Symbol: bbb (2)
 # CHECK-NEXT:       Addend: 0x0
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Relocation {
-# CHECK-NEXT:       Offset: 0x1008
+# CHECK-NEXT:       Offset: 0x2008
 # CHECK-NEXT:       Type: R_X86_64_64
 # CHECK-NEXT:       Symbol: ccc (3)
 # CHECK-NEXT:       Addend: 0x0
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Relocation {
-# CHECK-NEXT:       Offset: 0x1020
+# CHECK-NEXT:       Offset: 0x2020
 # CHECK-NEXT:       Type: R_X86_64_64
 # CHECK-NEXT:       Symbol: ddd (4)
 # CHECK-NEXT:       Addend: 0x0
 # CHECK-NEXT:     }
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK:      DynamicSection [
 # CHECK-NEXT:   Tag
 # CHECK-NOT:    RELACOUNT
 
 # RUN: ld.lld -z nocombreloc -shared %t.o -o %t.out
 # RUN: llvm-readobj -r --expand-relocs --dynamic-table %t.out | \
 # RUN:    FileCheck --check-prefix=NOCOMB %s
 
 # NOCOMB:      Relocations [
 # NOCOMB-NEXT:    Section ({{.*}}) .rela.dyn {
 # NOCOMB-NEXT:     Relocation {
-# NOCOMB-NEXT:       Offset: 0x1000
+# NOCOMB-NEXT:       Offset: 0x2000
 # NOCOMB-NEXT:       Type: R_X86_64_64
 # NOCOMB-NEXT:       Symbol: aaa (1)
 # NOCOMB-NEXT:       Addend: 0x0
 # NOCOMB-NEXT:     }
 # NOCOMB-NEXT:     Relocation {
-# NOCOMB-NEXT:       Offset: 0x1008
+# NOCOMB-NEXT:       Offset: 0x2008
 # NOCOMB-NEXT:       Type: R_X86_64_64
 # NOCOMB-NEXT:       Symbol: ccc (3)
 # NOCOMB-NEXT:       Addend: 0x0
 # NOCOMB-NEXT:     }
 # NOCOMB-NEXT:     Relocation {
-# NOCOMB-NEXT:       Offset: 0x1010
+# NOCOMB-NEXT:       Offset: 0x2010
 # NOCOMB-NEXT:       Type: R_X86_64_64
 # NOCOMB-NEXT:       Symbol: bbb (2)
 # NOCOMB-NEXT:       Addend: 0x0
 # NOCOMB-NEXT:     }
 # NOCOMB-NEXT:     Relocation {
-# NOCOMB-NEXT:       Offset: 0x1018
+# NOCOMB-NEXT:       Offset: 0x2018
 # NOCOMB-NEXT:       Type: R_X86_64_64
 # NOCOMB-NEXT:       Symbol: aaa (1)
 # NOCOMB-NEXT:       Addend: 0x0
 # NOCOMB-NEXT:     }
 # NOCOMB-NEXT:     Relocation {
-# NOCOMB-NEXT:       Offset: 0x1020
+# NOCOMB-NEXT:       Offset: 0x2020
 # NOCOMB-NEXT:       Type: R_X86_64_64
 # NOCOMB-NEXT:       Symbol: ddd (4)
 # NOCOMB-NEXT:       Addend: 0x0
 # NOCOMB-NEXT:     }
 # NOCOMB-NEXT:   }
 # NOCOMB-NEXT:  ]
 # NOCOMB:      DynamicSection [
 # NOCOMB-NEXT:   Tag
 # NOCOMB-NOT:    RELACOUNT
 
 .data
  .quad aaa
  .quad ccc
  .quad bbb
  .quad aaa
  .quad ddd

lld/trunk/test/ELF/copy-rel-pie.s

 // CHECK-NEXT: Address: 0x1010
 
 // CHECK:      Name: .bss
 // CHECK-NEXT: Type: SHT_NOBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x4000
+// CHECK-NEXT: Address: 0x3020
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rela.dyn {
-// CHECK-NEXT:     0x4000 R_X86_64_COPY foo 0x0
+// CHECK-NEXT:     0x3020 R_X86_64_COPY foo 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section (5) .rela.plt {
-// CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT bar 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // (0x1010 + 0x10) - 0x1005 = 27
-// 0x4000          - 0x100a = 12278
+// 0x3020          - 0x100a = 8214
 
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: _start:
 // DISASM-NEXT:     1000:       e8 1b 00 00 00  callq   27
-// DISASM-NEXT:     1005:       e8 f6 2f 00 00  callq   12278 <foo>
+// DISASM-NEXT:     1005:       e8 16 20 00 00  callq   8214 <foo>

lld/trunk/test/ELF/dynamic-got.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.o -o %t.so -shared
 // RUN: llvm-readobj -s -l -section-data -r %t.so | FileCheck %s
 
-// CHECK:     Name: .got.plt
-// CHECK-NEXT:     Type: SHT_PROGBITS
-// CHECK-NEXT:     Flags [
-// CHECK-NEXT:       SHF_ALLOC
-// CHECK-NEXT:       SHF_WRITE
-// CHECK-NEXT:     ]
-// CHECK-NEXT:     Address:
-// CHECK-NEXT:     Offset:
-// CHECK-NEXT:     Size:
-// CHECK-NEXT:     Link:
-// CHECK-NEXT:     Info:
-// CHECK-NEXT:     AddressAlignment:
-// CHECK-NEXT:     EntrySize:
-// CHECK-NEXT:     SectionData (
-// CHECK-NEXT:       0000: 00300000 00000000 00000000
-// CHECK-NEXT:     )
+// CHECK:      Name: .got
+// CHECK-NEXT: Type: SHT_PROGBITS
+// CHECK-NEXT: Flags [
+// CHECK-NEXT:   SHF_ALLOC
+// CHECK-NEXT:   SHF_WRITE
+// CHECK-NEXT: ]
+// CHECK-NEXT: Address:
+// CHECK-NEXT: Offset:
+// CHECK-NEXT: Size:
+// CHECK-NEXT: Link:
+// CHECK-NEXT: Info:
+// CHECK-NEXT: AddressAlignment:
+// CHECK-NEXT: EntrySize:
+// CHECK-NEXT: SectionData (
+// CHECK-NEXT:   0000: 00200000
+// CHECK-NEXT: )
 
-// CHECK:      Name: .got
-// CHECK-NEXT: Type: SHT_PROGBITS
-// CHECK-NEXT: Flags [
-// CHECK-NEXT:   SHF_ALLOC
-// CHECK-NEXT:   SHF_WRITE
-// CHECK-NEXT: ]
-// CHECK-NEXT: Address:
-// CHECK-NEXT: Offset:
-// CHECK-NEXT: Size:
-// CHECK-NEXT: Link:
-// CHECK-NEXT: Info:
-// CHECK-NEXT: AddressAlignment:
-// CHECK-NEXT: EntrySize:
-// CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 00300000
-// CHECK-NEXT: )
+// CHECK:     Name: .got.plt
+// CHECK-NEXT:     Type: SHT_PROGBITS
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       SHF_ALLOC
+// CHECK-NEXT:       SHF_WRITE
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address:
+// CHECK-NEXT:     Offset:
+// CHECK-NEXT:     Size:
+// CHECK-NEXT:     Link:
+// CHECK-NEXT:     Info:
+// CHECK-NEXT:     AddressAlignment:
+// CHECK-NEXT:     EntrySize:
+// CHECK-NEXT:     SectionData (
+// CHECK-NEXT:       0000: 00200000 00000000 00000000
+// CHECK-NEXT:     )
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rel.dyn {
-// CHECK-NEXT:     0x3050 R_386_RELATIVE - 0x0
+// CHECK-NEXT:     0x2050 R_386_RELATIVE - 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Type: PT_DYNAMIC
-// CHECK-NEXT: Offset: 0x3000
-// CHECK-NEXT: VirtualAddress: 0x3000
-// CHECK-NEXT: PhysicalAddress: 0x3000
+// CHECK-NEXT: Offset: 0x2000
+// CHECK-NEXT: VirtualAddress: 0x2000
+// CHECK-NEXT: PhysicalAddress: 0x2000
 
         calll   .L0$pb
 .L0$pb:
         popl    %eax
 .Ltmp0:
         addl    $_GLOBAL_OFFSET_TABLE_+(.Ltmp0-.L0$pb), %eax
         movl    _DYNAMIC@GOT(%eax), %eax

lld/trunk/test/ELF/dynamic-list-weak-archive.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/dynamic-list-weak-archive.s -o %t2.o
 # RUN: rm -f %t.a
 # RUN: llvm-ar rcs %t.a %t2.o
 # RUN: echo "{ zed; };" > %t.list
 # RUN: ld.lld -shared --dynamic-list %t.list %t1.o %t.a -o %t.so
 # RUN: llvm-readobj -r %t.so | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-# CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT foo
+# CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT foo
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 callq foo@PLT
 .weak foo

lld/trunk/test/ELF/dynamic-reloc-index.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
 // RUN: ld.lld %t.o %t2.so -o %t
 // RUN: llvm-readobj -r %t | FileCheck %s
 
 // We used to record the wrong symbol index for this test
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:     0x202018 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x203018 R_X86_64_JUMP_SLOT bar 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
         .global foobar
 foobar:
         .global zedx
 zedx:
         .global _start
 _start:
 .quad bar

lld/trunk/test/ELF/dynamic-reloc.s

 // CHECK-NEXT: Type: SHT_RELA
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: [[RELAADDR:.*]]
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: [[RELASIZE:.*]]
 // CHECK-NEXT: Link: 1
-// CHECK-NEXT: Info: 7
+// CHECK-NEXT: Info: 8
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 24
 
 // CHECK:      Name: .text
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x201000
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
 // CHECK-NEXT:     Relocation {
-// CHECK-NEXT:       Offset: 0x202018
+// CHECK-NEXT:       Offset: 0x203018
 // CHECK-NEXT:       Type: R_X86_64_JUMP_SLOT
 // CHECK-NEXT:       Symbol: bar
 // CHECK-NEXT:       Addend: 0x0
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK: DynamicSection [

lld/trunk/test/ELF/emit-relocs-merge.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --emit-relocs %t.o -o %t.so -shared
 # RUN: llvm-readobj -r %t.so | FileCheck %s
 
 # CHECK:       Relocations [
 # CHECK-NEXT:    Section ({{.*}}) .rela.dyn {
-# CHECK-NEXT:     0x1000 R_X86_64_64 zed 0x0
-# CHECK-NEXT:     0x1008 R_X86_64_64 zed 0x0
+# CHECK-NEXT:     0x2000 R_X86_64_64 zed 0x0
+# CHECK-NEXT:     0x2008 R_X86_64_64 zed 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section ({{.*}}) .rela.data {
-# CHECK-NEXT:     0x1000 R_X86_64_64 zed 0x0
-# CHECK-NEXT:     0x1008 R_X86_64_64 zed 0x0
+# CHECK-NEXT:     0x2000 R_X86_64_64 zed 0x0
+# CHECK-NEXT:     0x2008 R_X86_64_64 zed 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 .section        .data.foo,"aw",%progbits
 .quad zed
 .section        .data.bar,"aw",%progbits
 .quad zed

lld/trunk/test/ELF/emit-relocs-shared.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --hash-style=sysv --emit-relocs %t.o -o %t.so -shared
 # RUN: llvm-readobj -r %t.so | FileCheck %s
 
 .data
 .quad foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section {{.*}} .rela.dyn {
-# CHECK-NEXT:     0x1000 R_X86_64_64 foo 0x0
+# CHECK-NEXT:     0x2000 R_X86_64_64 foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {{.*}} .rela.data {
-# CHECK-NEXT:     0x1000 R_X86_64_64 foo 0x0
+# CHECK-NEXT:     0x2000 R_X86_64_64 foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

lld/trunk/test/ELF/executable-undefined-ignoreall.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld %t -o %tout --unresolved-symbols=ignore-all -pie
 # RUN: llvm-readobj -r %tout | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-# CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT foo 0x0
+# CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 _start:
 callq foo@PLT

lld/trunk/test/ELF/gc-sections-linker-defined-symbol.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 --gc-sections -shared
 # RUN: llvm-readobj --dyn-symbols %t.so | FileCheck %s
 
 # CHECK:      Name: _end
 # CHECK-NEXT: Value:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Binding: Global
 # CHECK-NEXT: Type: None
 # CHECK-NEXT: Other:
-# CHECK-NEXT: Section: .dynamic
+# CHECK-NEXT: Section: .data
 
         .data
         .globl g
         g:
         .quad _end

lld/trunk/test/ELF/global-offset-table-position-aarch64.s

 .global _start
 .type _start,@function
 _start:
  bl f
 .data
 .long _GLOBAL_OFFSET_TABLE_ - .
 
 // CHECK: Name: _GLOBAL_OFFSET_TABLE_ (11)
-// CHECK-NEXT:     Value: 0x20008
+// CHECK-NEXT:     Value: 0x30008
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: None (0x0)
 // CHECK-NEXT:     Other [ (0x2)
 // CHECK-NEXT:       STV_HIDDEN (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .got.plt

lld/trunk/test/ELF/global-offset-table-position-arm.s

 
 .global _start
 .type _start,%function
 _start:
  bl f
 .data
 
 // CHECK:     Name: _GLOBAL_OFFSET_TABLE_
-// CHECK-NEXT:     Value: 0x3068
+// CHECK-NEXT:     Value: 0x2068
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other [ (0x2)
 // CHECK-NEXT:       STV_HIDDEN (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .got

lld/trunk/test/ELF/global-offset-table-position-i386.s

 
 .global _start
 .type _start,@function
 _start:
 addl    $_GLOBAL_OFFSET_TABLE_, %eax
 calll   f@PLT
 
 // CHECK:     Name: _GLOBAL_OFFSET_TABLE_ (1)
-// CHECK-NEXT:     Value: 0x2000
+// CHECK-NEXT:     Value: 0x3000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: None (0x0)
 // CHECK-NEXT:     Other [ (0x2)
 // CHECK-NEXT:       STV_HIDDEN (0x2)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .got.plt

lld/trunk/test/ELF/global-offset-table-position.s

 .global _start
 .type _start,@function
 _start:
 callq f@PLT
 .data
 .long _GLOBAL_OFFSET_TABLE_ - .
 
 // CHECK:     Name: _GLOBAL_OFFSET_TABLE_
-// CHECK-NEXT:     Value: 0x2008
+// CHECK-NEXT:     Value: 0x3008
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None (0x0)
 // CHECK-NEXT:     Other [
 // CHECK-NEXT:       STV_HIDDEN
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Section: .got.plt

lld/trunk/test/ELF/global_offset_table_shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: ld.lld --hash-style=sysv -shared %t -o %t2
 // RUN: llvm-readobj -t %t2 | FileCheck %s
 .long _GLOBAL_OFFSET_TABLE_ - .
 
 // CHECK:      Name: _GLOBAL_OFFSET_TABLE_
-// CHECK-NEXT: Value: 0x2000
+// CHECK-NEXT: Value: 0x3000
 // CHECK-NEXT: Size: 0
 // CHECK-NEXT: Binding: Local
 // CHECK-NEXT: Type: None
 // CHECK-NEXT: Other [ (0x2)
 // CHECK-NEXT: STV_HIDDEN (0x2)
 // CHECK-NEXT:    ]
 // CHECK-NEXT: Section: .got.plt

lld/trunk/test/ELF/gnu-ifunc-canon.s

 // IREL1-REL3-NEXT: R_X86_64_RELATIVE
 // IREL1-REL3: .rela.plt
 // IREL1-REL3-NEXT: R_X86_64_IRELATIVE
 // IREL1-REL3-NOT: R_X86_64_
 
 // Make sure the static relocations look right, both with and without headers.
 // DUMP: Contents of section .plt:
 // DUMP-NEXT: 201010
-// DUMP: Contents of section .data:
-// DUMP-NEXT: 202000 10102000 00000000 11102000 00000000
 // DUMP: Contents of section .got:
-// DUMP-NEXT: 203000 10102000 00000000
+// DUMP-NEXT: 202000 10102000 00000000
+// DUMP: Contents of section .data:
+// DUMP-NEXT: 203000 10102000 00000000 11102000 00000000
 
 // DUMP2: Contents of section .plt:
 // DUMP2-NEXT: 201010
-// DUMP2: Contents of section .data:
-// DUMP2-NEXT: 202000 40102000 00000000 41102000 00000000
 // DUMP2: Contents of section .got:
-// DUMP2-NEXT: 203000 40102000 00000000
+// DUMP2-NEXT: 202000 40102000 00000000
+// DUMP2: Contents of section .data:
+// DUMP2-NEXT: 203000 40102000 00000000 41102000 00000000
 
 lea ifunc@gotpcrel(%rip), %rbx
 
 .type ifunc STT_GNU_IFUNC
 .globl ifunc
 ifunc:
 ret
 
 .data
 .8byte ifunc

lld/trunk/test/ELF/gnu-ifunc-dso.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/gnu-ifunc-dso.s -o %t1.o
 # RUN: ld.lld -shared %t1.o -o %t.so
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t2.o
 # RUN: ld.lld -shared %t2.o %t.so -o %t
 # RUN: llvm-readobj -dyn-relocations %t | FileCheck %s
 
 # CHECK:      Dynamic Relocations {
-# CHECK-NEXT:   0x1000 R_X86_64_64 foo 0x0
+# CHECK-NEXT:   0x2000 R_X86_64_64 foo 0x0
 # CHECK-NEXT: }
 
 .data
  .quad foo

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   VMA
 # CHECK:  .rela.plt   00000030 0000000000000210
-# CHECK:  .got.plt    00000010 0000000000002000
+# 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:   0x0000000000000002 PLTRELSZ             48
-# TAGS:   0x0000000000000003 PLTGOT               0x2000
+# TAGS:   0x0000000000000003 PLTGOT               0x3000
 # TAGS:   0x0000000000000014 PLTREL               RELA
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 

lld/trunk/test/ELF/gnu-ifunc-plt-i386.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %S/Inputs/shared2-x86-64.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r -dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rel.plt {
-// CHECK-NEXT:     0x40200C R_386_JUMP_SLOT bar2
-// CHECK-NEXT:     0x402010 R_386_JUMP_SLOT zed2
-// CHECK-NEXT:     0x402014 R_386_IRELATIVE
-// CHECK-NEXT:     0x402018 R_386_IRELATIVE
+// CHECK-NEXT:     0x40300C R_386_JUMP_SLOT bar2
+// CHECK-NEXT:     0x403010 R_386_JUMP_SLOT zed2
+// CHECK-NEXT:     0x403014 R_386_IRELATIVE
+// CHECK-NEXT:     0x403018 R_386_IRELATIVE
 
 // Check that IRELATIVE .got.plt entries point to ifunc resolver and not
 // back to the plt entry + 6.
 // GOTPLT: Contents of section .got.plt:
-// GOTPLT:       402000 00304000 00000000 00000000 36104000
-// GOTPLT-NEXT:  402010 46104000 00104000 01104000
+// GOTPLT:       403000 00204000 00000000 00000000 36104000
+// GOTPLT-NEXT:  403010 46104000 00104000 01104000
 
 // Check that the PLTRELSZ tag includes the IRELATIVE relocations
 // CHECK: DynamicSection [
 // CHECK:  0x00000002 PLTRELSZ             32 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    401000:       c3      retl
 // DISASM:      bar:
 // DISASM-NEXT:    401001:       c3      retl
 // DISASM:      _start:
 // DISASM-NEXT:    401002:       e8 49 00 00 00          calll   73
 // DISASM-NEXT:    401007:       e8 54 00 00 00          calll   84
 // DISASM-NEXT:    40100c:       e8 1f 00 00 00          calll   31
 // DISASM-NEXT:    401011:       e8 2a 00 00 00          calll   42
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:    401020:       ff 35 04 20 40 00       pushl   4202500
-// DISASM-NEXT:    401026:       ff 25 08 20 40 00       jmpl    *4202504
+// DISASM-NEXT:    401020:       ff 35 04 30 40 00       pushl   4206596
+// DISASM-NEXT:    401026:       ff 25 08 30 40 00       jmpl    *4206600
 // DISASM-NEXT:    40102c:       90      nop
 // DISASM-NEXT:    40102d:       90      nop
 // DISASM-NEXT:    40102e:       90      nop
 // DISASM-NEXT:    40102f:       90      nop
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar2@plt:
-// DISASM-NEXT:    401030:       ff 25 0c 20 40 00       jmpl    *4202508
+// DISASM-NEXT:    401030:       ff 25 0c 30 40 00       jmpl    *4206604
 // DISASM-NEXT:    401036:       68 00 00 00 00          pushl   $0
 // DISASM-NEXT:    40103b:       e9 e0 ff ff ff          jmp     -32 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed2@plt:
-// DISASM-NEXT:    401040:       ff 25 10 20 40 00       jmpl    *4202512
+// DISASM-NEXT:    401040:       ff 25 10 30 40 00       jmpl    *4206608
 // DISASM-NEXT:    401046:       68 08 00 00 00          pushl   $8
 // DISASM-NEXT:    40104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
-// DISASM-NEXT:    401050:       ff 25 14 20 40 00       jmpl    *4202516
+// DISASM-NEXT:    401050:       ff 25 14 30 40 00       jmpl    *4206612
 // DISASM-NEXT:    401056:       68 30 00 00 00          pushl   $48
 // DISASM-NEXT:    40105b:       e9 e0 ff ff ff          jmp     -32 <zed2@plt>
-// DISASM-NEXT:    401060:       ff 25 18 20 40 00       jmpl    *4202520
+// DISASM-NEXT:    401060:       ff 25 18 30 40 00       jmpl    *4206616
 // DISASM-NEXT:    401066:       68 38 00 00 00          pushl   $56
 // DISASM-NEXT:    40106b:       e9 d0 ff ff ff          jmp     -48 <zed2@plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret

lld/trunk/test/ELF/gnu-ifunc-plt.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/shared2-x86-64.s -o %t1.o
 // RUN: ld.lld %t1.o --shared -o %t.so
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.so %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-objdump -s %tout | FileCheck %s --check-prefix=GOTPLT
 // RUN: llvm-readobj -r -dynamic-table %tout | FileCheck %s
 
 // Check that the IRELATIVE relocations are after the JUMP_SLOT in the plt
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rela.plt {
-// CHECK-NEXT:     0x202018 R_X86_64_JUMP_SLOT bar2 0x0
-// CHECK-NEXT:     0x202020 R_X86_64_JUMP_SLOT zed2 0x0
-// CHECK-NEXT:     0x202028 R_X86_64_IRELATIVE - 0x201000
-// CHECK-NEXT:     0x202030 R_X86_64_IRELATIVE - 0x201001
+// CHECK-NEXT:     0x203018 R_X86_64_JUMP_SLOT bar2 0x0
+// CHECK-NEXT:     0x203020 R_X86_64_JUMP_SLOT zed2 0x0
+// CHECK-NEXT:     0x203028 R_X86_64_IRELATIVE - 0x201000
+// CHECK-NEXT:     0x203030 R_X86_64_IRELATIVE - 0x201001
 
 // Check that .got.plt entries point back to PLT header
 // GOTPLT: Contents of section .got.plt:
-// GOTPLT-NEXT:  202000 00302000 00000000 00000000 00000000
-// GOTPLT-NEXT:  202010 00000000 00000000 36102000 00000000
-// GOTPLT-NEXT:  202020 46102000 00000000 56102000 00000000
-// GOTPLT-NEXT:  202030 66102000 00000000
+// GOTPLT-NEXT:  203000 00202000 00000000 00000000 00000000
+// GOTPLT-NEXT:  203010 00000000 00000000 36102000 00000000
+// GOTPLT-NEXT:  203020 46102000 00000000 56102000 00000000
+// GOTPLT-NEXT:  203030 66102000 00000000
 
 // Check that the PLTRELSZ tag includes the IRELATIVE relocations
 // CHECK: DynamicSection [
 // CHECK:   0x0000000000000002 PLTRELSZ             96 (bytes)
 
 // Check that a PLT header is written and the ifunc entries appear last
 // DISASM: Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:   201000:       c3      retq
 // DISASM:      bar:
 // DISASM-NEXT:   201001:       c3      retq
 // DISASM:      _start:
 // DISASM-NEXT:   201002:       e8 49 00 00 00          callq   73
 // DISASM-NEXT:   201007:       e8 54 00 00 00          callq   84
 // DISASM-NEXT:   20100c:       e8 1f 00 00 00          callq   31
 // DISASM-NEXT:   201011:       e8 2a 00 00 00          callq   42
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:   201020:       ff 35 e2 0f 00 00       pushq   4066(%rip)
-// DISASM-NEXT:   201026:       ff 25 e4 0f 00 00       jmpq    *4068(%rip)
+// DISASM-NEXT:   201020:       ff 35 e2 1f 00 00       pushq   8162(%rip)
+// DISASM-NEXT:   201026:       ff 25 e4 1f 00 00       jmpq    *8164(%rip)
 // DISASM-NEXT:   20102c:       0f 1f 40 00     nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar2@plt:
-// DISASM-NEXT:   201030:       ff 25 e2 0f 00 00       jmpq    *4066(%rip)
+// DISASM-NEXT:   201030:       ff 25 e2 1f 00 00       jmpq    *8162(%rip)
 // DISASM-NEXT:   201036:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:   20103b:       e9 e0 ff ff ff          jmp     -32 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed2@plt:
-// DISASM-NEXT:   201040:       ff 25 da 0f 00 00       jmpq    *4058(%rip)
+// DISASM-NEXT:   201040:       ff 25 da 1f 00 00       jmpq    *8154(%rip)
 // DISASM-NEXT:   201046:       68 01 00 00 00          pushq   $1
 // DISASM-NEXT:   20104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
-// DISASM-NEXT:   201050:       ff 25 d2 0f 00 00       jmpq    *4050(%rip)
+// DISASM-NEXT:   201050:       ff 25 d2 1f 00 00       jmpq    *8146(%rip)
 // DISASM-NEXT:   201056:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:   20105b:       e9 e0 ff ff ff          jmp     -32 <zed2@plt>
-// DISASM-NEXT:   201060:       ff 25 ca 0f 00 00       jmpq    *4042(%rip)
+// DISASM-NEXT:   201060:       ff 25 ca 1f 00 00       jmpq    *8138(%rip)
 // DISASM-NEXT:   201066:       68 01 00 00 00          pushq   $1
 // DISASM-NEXT:   20106b:       e9 d0 ff ff ff          jmp     -48 <zed2@plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret

lld/trunk/test/ELF/gnu-ifunc-shared.s

 // DISASM-NEXT:     1002:       e8 49 00 00 00          callq   73
 // DISASM-NEXT:     1007:       e8 24 00 00 00          callq   36
 // DISASM-NEXT:     100c:       e8 2f 00 00 00          callq   47
 // DISASM-NEXT:     1011:       c3      retq
 // DISASM:     f2:
 // DISASM-NEXT:     1012:       c3      retq
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:     1020:       ff 35 e2 0f 00 00       pushq   4066(%rip)
-// DISASM-NEXT:     1026:       ff 25 e4 0f 00 00       jmpq    *4068(%rip)
+// DISASM-NEXT:     1020:       ff 35 e2 1f 00 00       pushq   8162(%rip)
+// DISASM-NEXT:     1026:       ff 25 e4 1f 00 00       jmpq    *8164(%rip)
 // DISASM-NEXT:     102c:       0f 1f 40 00     nopl    (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   fct2@plt:
-// DISASM-NEXT:     1030:       ff 25 e2 0f 00 00       jmpq    *4066(%rip)
+// DISASM-NEXT:     1030:       ff 25 e2 1f 00 00       jmpq    *8162(%rip)
 // DISASM-NEXT:     1036:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:     103b:       e9 e0 ff ff ff          jmp     -32 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   f2@plt:
-// DISASM-NEXT:     1040:       ff 25 da 0f 00 00       jmpq    *4058(%rip)
+// DISASM-NEXT:     1040:       ff 25 da 1f 00 00       jmpq    *8154(%rip)
 // DISASM-NEXT:     1046:       68 01 00 00 00          pushq   $1
 // DISASM-NEXT:     104b:       e9 d0 ff ff ff          jmp     -48 <.plt>
-// DISASM-NEXT:     1050:       ff 25 d2 0f 00 00       jmpq    *4050(%rip)
+// DISASM-NEXT:     1050:       ff 25 d2 1f 00 00       jmpq    *8146(%rip)
 // DISASM-NEXT:     1056:       68 00 00 00 00          pushq   $0
 // DISASM-NEXT:     105b:       e9 e0 ff ff ff          jmp     -32 <f2@plt>
 
 // CHECK: Relocations [
 // CHECK-NEXT:   Section (4) .rela.plt {
-// CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT fct2 0x0
-// CHECK-NEXT:     0x2020 R_X86_64_JUMP_SLOT f2 0x0
-// CHECK-NEXT:     0x2028 R_X86_64_IRELATIVE - 0x1000
+// CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT fct2 0x0
+// CHECK-NEXT:     0x3020 R_X86_64_JUMP_SLOT f2 0x0
+// CHECK-NEXT:     0x3028 R_X86_64_IRELATIVE - 0x1000
 
  // Hidden expect IRELATIVE
  .globl fct
  .hidden fct
  .type  fct, STT_GNU_IFUNC
 fct:
  ret
 

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

 // REQUIRES: aarch64
 // RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv -shared %t.o -o %t.so
 // RUN: llvm-readobj -s -r %t.so | FileCheck %s
 // RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x30090
+// CHECK-NEXT: Address: 0x20090
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x30090 R_AARCH64_GLOB_DAT dat 0x0
+// CHECK-NEXT:     0x20090 R_AARCH64_GLOB_DAT dat 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Page(0x20098) - Page(0x10000) = 0x10000 = 65536
 // 0x20098 & 0xff8 = 0x98 = 152
 
 // DISASM: main:
-// DISASM-NEXT:   10000:  00 01 00 90   adrp  x0, #131072
+// DISASM-NEXT:   10000:  80 00 00 90   adrp  x0, #65536
 // DISASM-NEXT:   10004: 00 48 40 f9   ldr x0, [x0, #144]
 
 .global main,foo,dat
 .text
 main:
     adrp x0, :got:dat
     ldr x0, [x0, :got_lo12:dat]
 .data
 dat:
     .word 42

lld/trunk/test/ELF/got-plt-header.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
 // RUN: llvm-readobj -s -section-data %t.so | FileCheck %s
 
         call foo@plt
 
 // Check that the first .got.plt entry has the address of the dynamic table.
 
+// CHECK:      Type: SHT_DYNAMIC
+// CHECK-NEXT: Flags [
+// CHECK-NEXT:   SHF_ALLOC
+// CHECK-NEXT:   SHF_WRITE
+// CHECK-NEXT: ]
+// CHECK-NEXT: Address: 0x2000
+
 // CHECK:      Name: .got.plt
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x2000
-// CHECK-NEXT: Offset: 0x2000
+// CHECK-NEXT: Address: 0x3000
+// CHECK-NEXT: Offset: 0x3000
 // CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 00300000 00000000 00000000 00000000
-
-// CHECK:      Type: SHT_DYNAMIC
-// CHECK-NEXT: Flags [
-// CHECK-NEXT:   SHF_ALLOC
-// CHECK-NEXT:   SHF_WRITE
-// CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x3000
+// CHECK-NEXT:   0000: 00200000 00000000 00000000 00000000

lld/trunk/test/ELF/got32x-i386.s

 ## register, it should be calculated as G + A. Using without base register
 ## is only allowed for non-PIC code.
 ##
 # RUN: ld.lld %S/Inputs/i386-got32x-baseless.elf -o %t1
 # RUN: llvm-objdump -section-headers -d %t1 | FileCheck %s
 
 ## 73728 == 0x12000 == ADDR(.got)
 # CHECK:       _start:
-# CHECK-NEXT:   401001: 8b 05 {{.*}} movl 4206592, %eax
-# CHECK-NEXT:   401007: 8b 1d {{.*}} movl 4206592, %ebx
+# CHECK-NEXT:   401001: 8b 05 {{.*}} movl 4202496, %eax
+# CHECK-NEXT:   401007: 8b 1d {{.*}} movl 4202496, %ebx
 # CHECK-NEXT:   40100d: 8b 80 {{.*}} movl -4(%eax), %eax
 # CHECK-NEXT:   401013: 8b 83 {{.*}} movl -4(%ebx), %eax
 # CHECK: Sections:
 # CHECK:  Name Size     VMA
-# CHECK:  .got 00000004 0000000000403000
+# CHECK:  .got 00000004 0000000000402000
 
 # RUN: not ld.lld %S/Inputs/i386-got32x-baseless.elf -o %t1 -pie 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ERR
 # ERR: error: can't create dynamic relocation R_386_GOT32X against symbol: foo in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output
 # ERR: error: can't create dynamic relocation R_386_GOT32X against symbol: foo in readonly segment; recompile object files with -fPIC or pass '-Wl,-z,notext' to allow text relocations in the output

lld/trunk/test/ELF/gotpc-relax-nopic.s

 # SEC-PIC:      Section {
 # SEC-PIC:        Index:
 # SEC-PIC:        Name: .got
 # SEC-PIC-NEXT:   Type: SHT_PROGBITS
 # SEC-PIC-NEXT:   Flags [
 # SEC-PIC-NEXT:     SHF_ALLOC
 # SEC-PIC-NEXT:     SHF_WRITE
 # SEC-PIC-NEXT:   ]
-# SEC-PIC-NEXT:   Address: 0x30A0
-# SEC-PIC-NEXT:   Offset: 0x30A0
+# SEC-PIC-NEXT:   Address: 0x20A0
+# SEC-PIC-NEXT:   Offset: 0x20A0
 # SEC-PIC-NEXT:   Size: 8
 # SEC-PIC-NEXT:   Link:
 # SEC-PIC-NEXT:   Info:
 # SEC-PIC-NEXT:   AddressAlignment:
 # SEC-PIC-NEXT:   EntrySize:
 # SEC-PIC-NEXT: }
 # SEC-PIC:      Relocations [
 # SEC-PIC-NEXT:   Section ({{.*}}) .rela.dyn {
-# SEC-PIC-NEXT:     0x30A0 R_X86_64_RELATIVE - 0x2000
+# SEC-PIC-NEXT:     0x20A0 R_X86_64_RELATIVE - 0x3000
 # SEC-PIC-NEXT:   }
 # SEC-PIC-NEXT: ]
 # SEC-PIC:      0x000000006FFFFFF9 RELACOUNT            1
 
 ## Check that there was no relaxation performed. All values refer to got entry.
 ## Ex: 0x1000 + 4249 + 7 = 0x20A0
 ##     0x102a + 4207 + 7 = 0x20A0
 # DISASM-PIC:      Disassembly of section .text:
 # DISASM-PIC-NEXT: _start:
-# DISASM-PIC-NEXT: 1000: {{.*}} adcq  8345(%rip), %rax
-# DISASM-PIC-NEXT: 1007: {{.*}} addq  8338(%rip), %rbx
-# DISASM-PIC-NEXT: 100e: {{.*}} andq  8331(%rip), %rcx
-# DISASM-PIC-NEXT: 1015: {{.*}} cmpq  8324(%rip), %rdx
-# DISASM-PIC-NEXT: 101c: {{.*}} orq   8317(%rip), %rdi
-# DISASM-PIC-NEXT: 1023: {{.*}} sbbq  8310(%rip), %rsi
-# DISASM-PIC-NEXT: 102a: {{.*}} subq  8303(%rip), %rbp
-# DISASM-PIC-NEXT: 1031: {{.*}} xorq  8296(%rip), %r8
-# DISASM-PIC-NEXT: 1038: {{.*}} testq %r15, 8289(%rip)
+# DISASM-PIC-NEXT: 1000: {{.*}} adcq  4249(%rip), %rax
+# DISASM-PIC-NEXT: 1007: {{.*}} addq  4242(%rip), %rbx
+# DISASM-PIC-NEXT: 100e: {{.*}} andq  4235(%rip), %rcx
+# DISASM-PIC-NEXT: 1015: {{.*}} cmpq  4228(%rip), %rdx
+# DISASM-PIC-NEXT: 101c: {{.*}} orq   4221(%rip), %rdi
+# DISASM-PIC-NEXT: 1023: {{.*}} sbbq  4214(%rip), %rsi
+# DISASM-PIC-NEXT: 102a: {{.*}} subq  4207(%rip), %rbp
+# DISASM-PIC-NEXT: 1031: {{.*}} xorq  4200(%rip), %r8
+# DISASM-PIC-NEXT: 1038: {{.*}} testq %r15, 4193(%rip)
 
 .data
 .type   bar, @object
 bar:
  .byte   1
  .size   bar, .-bar
 
 .text

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

 # R_HEX_GOT_11_X and R_HEX_GOT_32_6_X
 r2=add(pc,##_GLOBAL_OFFSET_TABLE_@PCREL)
 r0 = memw (r2+##bar@GOT)
 jumpr r0
 
 # R_HEX_GOT_16_X
 r0 = add(r1,##bar@GOT)
 
-# PLT: { immext(#65472
-# PLT: r28 = add(pc,##65488) }
+# PLT: { immext(#131008
+# PLT: r28 = add(pc,##131024) }
 # PLT: { r14 -= add(r28,#16)
 # PLT: r15 = memw(r28+#8)
 # PLT: r28 = memw(r28+#4) }
 # PLT: { r14 = asr(r14,#2)
 # PLT: jumpr r28 }
 # PLT: { trap0(#219) }
-# PLT: immext(#65472)
-# PLT: r14 = add(pc,##65472) }
+# PLT: immext(#131008)
+# PLT: r14 = add(pc,##131008) }
 # PLT: r28 = memw(r14+#0) }
 # PLT: jumpr r28 }
 
-# TEXT:  10000: 00 00 02 00 00020000
+# TEXT:  10000: 00 00 01 00 00010000
 # TEXT: {   call 0x10050 }
-# TEXT: r0 = add(r1,##65664) }
+# TEXT: r0 = add(r1,##-65408) }
 
 # GOT: .got:
-# GOT: 30080: 00 00 00 00 00000000 <unknown>
+# GOT: 20080: 00 00 00 00 00000000 <unknown>

lld/trunk/test/ELF/i386-gotpc.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv %t.o -o %t.so -shared
 // RUN: llvm-readobj -s %t.so | FileCheck %s
 // RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 
 movl $_GLOBAL_OFFSET_TABLE_, %eax
 
-// CHECK:     Name: .got.plt
+// CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x2000
+// CHECK-NEXT: Address: 0x2030
 
-// CHECK:      Name: .got
+// CHECK:     Name: .got.plt
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x3030
+// CHECK-NEXT: Address: 0x3000
 
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: .text:
-// DISASM-NEXT:    1000: {{.*}}         movl    $8240, %eax
-//                                              0x3030 - 0x1000 = 0x2030
+// DISASM-NEXT:    1000: {{.*}}         movl    $4144, %eax
+//                                              0x2030 - 0x1000 = 0x1030

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

 
 
 // CHECK:      Name: .data
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1000
-// CHECK-NEXT: Offset: 0x1000
+// 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: )

lld/trunk/test/ELF/i386-retpoline-nopic-linkerscript.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10:       ff 35 84 00 00 00       pushl   132
+// CHECK-NEXT: 10:       ff 35 ec 00 00 00       pushl   236
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       a1 88 00 00 00 movl    136, %eax
+// CHECK-NEXT: 17:       a1 f0 00 00 00 movl    240, %eax
 // CHECK-NEXT: 1c:       e8 0f 00 00 00  calll   15 <.plt+0x20>
 // CHECK-NEXT: 21:       f3 90   pause
 // CHECK-NEXT: 23:       0f ae e8        lfence
 // CHECK-NEXT: 26:       eb f9   jmp     -7 <.plt+0x11>
 // CHECK-NEXT: 28:       cc      int3
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 33:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 37:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 3b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 3d:       59      popl    %ecx
 // CHECK-NEXT: 3e:       c3      retl
 // CHECK-NEXT: 3f:       cc      int3
 // CHECK-NEXT: 40:       50      pushl   %eax
-// CHECK-NEXT: 41:       a1 8c 00 00 00  movl    140, %eax
+// CHECK-NEXT: 41:       a1 f4 00 00 00  movl    244, %eax
 // CHECK-NEXT: 46:       e8 e5 ff ff ff  calll   -27 <.plt+0x20>
 // CHECK-NEXT: 4b:       e9 d1 ff ff ff  jmp     -47 <.plt+0x11>
 // CHECK-NEXT: 50:       68 00 00 00 00  pushl   $0
 // CHECK-NEXT: 55:       e9 b6 ff ff ff  jmp     -74 <.plt>
 // CHECK-NEXT: 5a:       cc      int3
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
 // CHECK-NEXT: 60:       50      pushl   %eax
-// CHECK-NEXT: 61:       a1 90 00 00 00  movl    144, %eax
+// CHECK-NEXT: 61:       a1 f8 00 00 00  movl    248, %eax
 // CHECK-NEXT: 66:       e8 c5 ff ff ff  calll   -59 <.plt+0x20>
 // CHECK-NEXT: 6b:       e9 b1 ff ff ff  jmp     -79 <.plt+0x11>
 // CHECK-NEXT: 70:       68 08 00 00 00  pushl   $8
 // CHECK-NEXT: 75:       e9 96 ff ff ff  jmp     -106 <.plt>
 // CHECK-NEXT: 7a:       cc      int3
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/i386-retpoline-nopic.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 401010:       ff 35 04 20 40 00       pushl   4202500
+// CHECK-NEXT: 401010:       ff 35 04 30 40 00       pushl   4206596
 // CHECK-NEXT: 401016:       50      pushl   %eax
-// CHECK-NEXT: 401017:       a1 08 20 40 00  movl    4202504, %eax
+// CHECK-NEXT: 401017:       a1 08 30 40 00  movl    4206600, %eax
 // CHECK-NEXT: 40101c:       e8 0f 00 00 00  calll   15 <.plt+0x20>
 // CHECK-NEXT: 401021:       f3 90   pause
 // CHECK-NEXT: 401023:       0f ae e8        lfence
 // CHECK-NEXT: 401026:       eb f9   jmp     -7 <.plt+0x11>
 // CHECK-NEXT: 401028:       cc      int3
 // CHECK-NEXT: 401029:       cc      int3
 // CHECK-NEXT: 40102a:       cc      int3
 // CHECK-NEXT: 40102b:       cc      int3
 // CHECK-NEXT: 40102c:       cc      int3
 // CHECK-NEXT: 40102d:       cc      int3
 // CHECK-NEXT: 40102e:       cc      int3
 // CHECK-NEXT: 40102f:       cc      int3
 // CHECK-NEXT: 401030:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 401033:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 401037:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 40103b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 40103d:       59      popl    %ecx
 // CHECK-NEXT: 40103e:       c3      retl
 // CHECK-NEXT: 40103f:       cc      int3
 // CHECK-NEXT: 401040:       50      pushl   %eax
-// CHECK-NEXT: 401041:       a1 0c 20 40 00  movl    4202508, %eax
+// CHECK-NEXT: 401041:       a1 0c 30 40 00  movl    4206604, %eax
 // CHECK-NEXT: 401046:       e8 e5 ff ff ff  calll   -27 <.plt+0x20>
 // CHECK-NEXT: 40104b:       e9 d1 ff ff ff  jmp     -47 <.plt+0x11>
 // CHECK-NEXT: 401050:       68 00 00 00 00  pushl   $0
 // CHECK-NEXT: 401055:       e9 b6 ff ff ff  jmp     -74 <.plt>
 // CHECK-NEXT: 40105a:       cc      int3
 // CHECK-NEXT: 40105b:       cc      int3
 // CHECK-NEXT: 40105c:       cc      int3
 // CHECK-NEXT: 40105d:       cc      int3
 // CHECK-NEXT: 40105e:       cc      int3
 // CHECK-NEXT: 40105f:       cc      int3
 // CHECK-NEXT: 401060:       50      pushl   %eax
-// CHECK-NEXT: 401061:       a1 10 20 40 00  movl    4202512, %eax
+// CHECK-NEXT: 401061:       a1 10 30 40 00  movl    4206608, %eax
 // CHECK-NEXT: 401066:       e8 c5 ff ff ff  calll   -59 <.plt+0x20>
 // CHECK-NEXT: 40106b:       e9 b1 ff ff ff  jmp     -79 <.plt+0x11>
 // CHECK-NEXT: 401070:       68 08 00 00 00  pushl   $8
 // CHECK-NEXT: 401075:       e9 96 ff ff ff  jmp     -106 <.plt>
 // CHECK-NEXT: 40107a:       cc      int3
 // CHECK-NEXT: 40107b:       cc      int3
 // CHECK-NEXT: 40107c:       cc      int3
 // CHECK-NEXT: 40107d:       cc      int3
 // CHECK-NEXT: 40107e:       cc      int3
 // CHECK-NEXT: 40107f:       cc      int3
 
 // CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 00304000 00000000 00000000 50104000
+// CHECK-NEXT: 00204000 00000000 00000000 50104000
 // CHECK-NEXT: 70104000
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/i386-retpoline-pic-linkerscript.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt -pie --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10:       ff b3 84 00 00 00       pushl   132(%ebx)
+// CHECK-NEXT: 10:       ff b3 ec 00 00 00       pushl   236(%ebx)
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       8b 83 88 00 00 00 movl    136(%ebx), %eax
+// CHECK-NEXT: 17:       8b 83 f0 00 00 00 movl    240(%ebx), %eax
 // CHECK-NEXT: 1d:       e8 0e 00 00 00  calll   14 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
 // CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 33:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 37:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 3b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 3d:       59      popl    %ecx
 // CHECK-NEXT: 3e:       c3      retl
 // CHECK-NEXT: 3f:       cc      int3
 // CHECK-NEXT: 40:       50      pushl   %eax
-// CHECK-NEXT: 41:       8b 83 8c 00 00 00       movl    140(%ebx), %eax
+// CHECK-NEXT: 41:       8b 83 f4 00 00 00       movl    244(%ebx), %eax
 // CHECK-NEXT: 47:       e8 e4 ff ff ff  calll   -28 <.plt+0x20>
 // CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
 // CHECK-NEXT: 51:       68 00 00 00 00  pushl   $0
 // CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     -75 <.plt>
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
 // CHECK-NEXT: 60:       50      pushl   %eax
-// CHECK-NEXT: 61:       8b 83 90 00 00 00       movl    144(%ebx), %eax
+// CHECK-NEXT: 61:       8b 83 f8 00 00 00       movl    248(%ebx), %eax
 // CHECK-NEXT: 67:       e8 c4 ff ff ff  calll   -60 <.plt+0x20>
 // CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
 // CHECK-NEXT: 71:       68 08 00 00 00  pushl   $8
 // CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     -107 <.plt>
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/i386-retpoline-pic.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=i386-unknown-linux -position-independent %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 
 // RUN: ld.lld %t1.o %t2.so -o %t.exe -z retpolineplt -pie
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 1010:       ff b3 04 20 00 00       pushl   8196(%ebx)
+// CHECK-NEXT: 1010:       ff b3 04 30 00 00       pushl   12292(%ebx)
 // CHECK-NEXT: 1016:       50      pushl   %eax
-// CHECK-NEXT: 1017:       8b 83 08 20 00 00       movl    8200(%ebx), %eax
+// CHECK-NEXT: 1017:       8b 83 08 30 00 00       movl    12296(%ebx), %eax
 // CHECK-NEXT: 101d:       e8 0e 00 00 00  calll   14 <.plt+0x20>
 // CHECK-NEXT: 1022:       f3 90   pause
 // CHECK-NEXT: 1024:       0f ae e8        lfence
 // CHECK-NEXT: 1027:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 1029:       cc      int3
 // CHECK-NEXT: 102a:       cc      int3
 // CHECK-NEXT: 102b:       cc      int3
 // CHECK-NEXT: 102c:       cc      int3
 // CHECK-NEXT: 102d:       cc      int3
 // CHECK-NEXT: 102e:       cc      int3
 // CHECK-NEXT: 102f:       cc      int3
 // CHECK-NEXT: 1030:       89 0c 24        movl    %ecx, (%esp)
 // CHECK-NEXT: 1033:       8b 4c 24 04     movl    4(%esp), %ecx
 // CHECK-NEXT: 1037:       89 44 24 04     movl    %eax, 4(%esp)
 // CHECK-NEXT: 103b:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT: 103d:       59      popl    %ecx
 // CHECK-NEXT: 103e:       c3      retl
 // CHECK-NEXT: 103f:       cc      int3
 // CHECK-NEXT: 1040:       50      pushl   %eax
-// CHECK-NEXT: 1041:       8b 83 0c 20 00 00       movl    8204(%ebx), %eax
+// CHECK-NEXT: 1041:       8b 83 0c 30 00 00       movl    12300(%ebx), %eax
 // CHECK-NEXT: 1047:       e8 e4 ff ff ff  calll   -28 <.plt+0x20>
 // CHECK-NEXT: 104c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
 // CHECK-NEXT: 1051:       68 00 00 00 00  pushl   $0
 // CHECK-NEXT: 1056:       e9 b5 ff ff ff  jmp     -75 <.plt>
 // CHECK-NEXT: 105b:       cc      int3
 // CHECK-NEXT: 105c:       cc      int3
 // CHECK-NEXT: 105d:       cc      int3
 // CHECK-NEXT: 105e:       cc      int3
 // CHECK-NEXT: 105f:       cc      int3
 // CHECK-NEXT: 1060:       50      pushl   %eax
-// CHECK-NEXT: 1061:       8b 83 10 20 00 00       movl    8208(%ebx), %eax
+// CHECK-NEXT: 1061:       8b 83 10 30 00 00       movl    12304(%ebx), %eax
 // CHECK-NEXT: 1067:       e8 c4 ff ff ff  calll   -60 <.plt+0x20>
 // CHECK-NEXT: 106c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
 // CHECK-NEXT: 1071:       68 08 00 00 00  pushl   $8
 // CHECK-NEXT: 1076:       e9 95 ff ff ff  jmp     -107 <.plt>
 // CHECK-NEXT: 107b:       cc      int3
 // CHECK-NEXT: 107c:       cc      int3
 // CHECK-NEXT: 107d:       cc      int3
 // CHECK-NEXT: 107e:       cc      int3
 // CHECK-NEXT: 107f:       cc      int3
 
 // CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 2000 00300000 00000000 00000000 51100000
-// CHECK-NEXT: 2010 71100000
+// CHECK-NEXT: 3000 00200000 00000000 00000000 51100000
+// CHECK-NEXT: 3010 71100000
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/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 200000 000008 00  WA  0   0 2097152
-# CHECK: LOAD 0x200000 0x0000000000200000 0x0000000000200000 {{.*}} RW  0x200000
+# CHECK: .foo  PROGBITS  0000000000200000 201000 000008 00  WA  0   0 2097152
+# CHECK: LOAD 0x001048 0x0000000000000048 0x0000000000000048 {{.*}} RW  0x200000

lld/trunk/test/ELF/linkerscript/emit-reloc.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { .rela.dyn : { *(.rela.data) } }" > %t.script
 # RUN: ld.lld --hash-style=sysv -T %t.script --emit-relocs %t.o -o %t.so -shared
 # RUN: llvm-readobj -r %t.so | FileCheck %s
 
 .data
 .quad .foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-# CHECK-NEXT:     0x68 R_X86_64_64 .foo 0x0
+# CHECK-NEXT:     0xF8 R_X86_64_64 .foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section ({{.*}}) .rela.data {
-# CHECK-NEXT:     0x68 R_X86_64_64 .foo 0x0
+# CHECK-NEXT:     0xF8 R_X86_64_64 .foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

lld/trunk/test/ELF/linkerscript/orphan.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: echo "SECTIONS {       \
 # RUN:  .text : { *(.text) }  \
 # RUN:  .rw1 : { *(.rw1) }    \
 # RUN:  .rw2 : { *(.rw2) }    \
 # RUN:  .rw3 : { *(.rw3) }    \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t
 # RUN: llvm-objdump -section-headers %t1 | FileCheck %s
 
-## .jcr is a relro section and should be placed after other RW sections.
+## .jcr is a relro section and should be placed before other RW sections.
 ## .bss is SHT_NOBITS section and should be last RW section, so some space
 ## in ELF file could be saved.
 # CHECK:       0               00000000 0000000000000000
 # CHECK-NEXT:  1 .text         00000000 0000000000000000 TEXT
-# CHECK-NEXT:  2 .rw1          00000008 0000000000000000 DATA
-# CHECK-NEXT:  3 .rw2          00000008 0000000000000008 DATA
-# CHECK-NEXT:  4 .rw3          00000008 0000000000000010 DATA
-# CHECK-NEXT:  5 .jcr          00000008 0000000000000018 DATA
+# CHECK-NEXT:  2 .jcr          00000008 0000000000000000 DATA
+# CHECK-NEXT:  3 .rw1          00000008 0000000000000008 DATA
+# CHECK-NEXT:  4 .rw2          00000008 0000000000000010 DATA
+# CHECK-NEXT:  5 .rw3          00000008 0000000000000018 DATA
 # CHECK-NEXT:  6 .bss          00000008 0000000000000020 BSS
 
 .section .rw1, "aw"
  .quad 0
 
 .section .rw2, "aw"
  .quad 0
 
 .section .rw3, "aw"
  .quad 0
 
 .section .jcr, "aw"
  .quad 0
 
 .section .bss, "aw",@nobits
  .quad 0

lld/trunk/test/ELF/linkerscript/out-of-order.s

 
 # Also note, it is absolutely *illegal* to have section addresses of
 # the same segment in none-increasing order, authors of linker scripts
 # must take responsibility to make sure this does not happen.
 
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size     VMA              Type
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK-NEXT:   1 .data         00000008 0000000000004000
-# CHECK-NEXT:   2 .dynamic      00000060 0000000000004008
+# CHECK-NEXT:   1 .dynamic      00000060 0000000000000000
+# CHECK-NEXT:   2 .data         00000008 0000000000004000
 # CHECK-NEXT:   3 .dynsym       00000018 0000000000002000
 # CHECK-NEXT:   4 .dynstr       00000001 0000000000002018
 # CHECK-NEXT:   5 .hash         00000010 000000000000201c
 # CHECK-NEXT:   6 .text         00000008 000000000000202c
 
 .quad 0
 .data
 .quad 0
 

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

 # 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 0x000100 0x000100 R E 0x1000
+# BAD-LMA-NEXT:  LOAD           0x001100 0x0000000000000100 0x0000000000000100 0x000070 0x000070 RW  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
+# BAD-LMA:  01     .text .dynamic
+# BAD-LMA:  02     .sec1
 
 # Now try a script where the virtual memory addresses overlap but ensure that the
 # load addresses don't:
 # RUN: echo "SECTIONS { \
 # RUN:   .sec1 0x8000 : AT(0x8000) { sec1_start = .; *(.first_sec) sec1_end = .;} \
 # RUN:   .sec2 0x8020 : AT(0x8800) { sec2_start = .; *(.second_sec) sec2_end = .;} \
 # RUN: }" > %t-vaddr.script
 # RUN: not ld.lld -o %t.so --script %t-vaddr.script %t.o -shared 2>&1 | FileCheck %s -check-prefix VADDR-OVERLAP-ERR
 # VADDR-OVERLAP-ERR:      error: section .sec1 virtual address range overlaps with .sec2
 # VADDR-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x8000, 0x80FF]
 # VADDR-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x8020, 0x811F]
 
 # 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 0x000100 0x000100 R E 0x1000
+# BAD-VADDR-NEXT:  LOAD           0x001100 0x0000000000000100 0x0000000000000100 0x000070 0x000070 RW  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
+# BAD-VADDR:  01     .text .dynamic
+# BAD-VADDR:  02     .sec1
 
 # Finally check the case where both LMA and vaddr overlap
 
 # 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 [0x2000, 0x20FF]
-# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x2040, 0x213F]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec1 range is [0x9000, 0x90FF]
+# BOTH-OVERLAP-ERR-NEXT: >>> .sec2 range is [0x9040, 0x913F]
 # 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 002000 000100 00  WA  0   0  1
-# BAD-BOTH: .sec2             PROGBITS        0000000000008040 002040 000100 00  WA  0   0  1
+# 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-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           0x002000 0x0000000000008000 0x0000000000008000 0x0001b0 0x0001b0 RW  0x1000
+# BAD-BOTH-NEXT:  LOAD           0x001100 0x0000000000000100 0x0000000000000100 0x008040 0x008040 RW  0x1000
 # BAD-BOTH-LABEL: Section to Segment mapping:
-# BAD-BOTH:   01     .sec1 .sec2 .dynamic
+# BAD-BOTH:   01     .text .dynamic .sec1 .sec2
 
 .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/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: 0x228
+# CHECK-NEXT: Value: 0x288
 
 # CHECK:      Name: foo2
-# CHECK-NEXT: Value: 0x230
+# CHECK-NEXT: Value: 0x290
 
 # CHECK:      Name: foo3
-# CHECK-NEXT: Value: 0x234
+# CHECK-NEXT: Value: 0x294
 
 .section .foo.1,"a"
  .long 1
 
 .section .foo.2,"aw"
  .long 2
 
  .section .bar,"aw"
  .long 3

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: .hash    {{.*}}   A
 # CHECK-NEXT: .dynstr  {{.*}}   A
 # CHECK-NEXT: .text    {{.*}}   AX
-# CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
+# CHECK-NEXT: foo      {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

lld/trunk/test/ELF/linkerscript/version-linker-symbol.s

 # REQUIRES: x86
 
 # RUN: echo "VER1 { global: _end; foo ; local: * ; } ;" > %t.script
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
 # RUN: llvm-readobj -dyn-symbols %t.so | FileCheck %s
 
 # CHECK:      Name: _end@@VER1
 # CHECK-NEXT: Value: 0
 # CHECK-NEXT: Size: 0
 # CHECK-NEXT: Binding: Global
 # CHECK-NEXT: Type: None
 # CHECK-NEXT: Other: 0
-# CHECK-NEXT: Section: .dynamic
+# CHECK-NEXT: Section: .data
 
 # CHECK:      Name: foo@@VER1
 # CHECK-NEXT: Value: 0
 # CHECK-NEXT: Size: 0
 # CHECK-NEXT: Binding: Global
 # CHECK-NEXT: Type: None
 # CHECK-NEXT: Other: 0
 # CHECK-NEXT: Section: .text
 
 .global foo
 foo:
         .data
         .quad _end
         .quad foo

lld/trunk/test/ELF/lto/undefined-puts.ll

define i32 @_start() {
   ret i32 0
 }
 
 declare i32 @printf(i8*, ...)
 
 ; Check that puts symbol is present in the dynamic symbol table and
 ; there's a relocation for it.
 ; CHECK: Dynamic Relocations {
-; CHECK-NEXT:  0x202018 R_X86_64_JUMP_SLOT puts 0x0
+; CHECK-NEXT:  0x203018 R_X86_64_JUMP_SLOT puts 0x0
 ; CHECK-NEXT: }
 
 ; CHECK: DynamicSymbols [
 ; CHECK: Symbol {
 ; CHECK:    Name: puts

lld/trunk/test/ELF/lto/visibility.ll

 ; CHECK-NEXT: Binding: Local
 ; CHECK-NEXT: Type: None
 ; CHECK-NEXT: Other [ (0x2)
 ; CHECK-NEXT:   STV_HIDDEN
 ; CHECK-NEXT: ]
 ; CHECK-NEXT: Section: .text
 
 ; CHECK:      Name: a
-; CHECK-NEXT: Value: 0x2000
+; CHECK-NEXT: Value: 0x3000
 ; CHECK-NEXT: Size: 0
 ; CHECK-NEXT: Binding: Local
 ; CHECK-NEXT: Type: None
 ; CHECK-NEXT: Other [ (0x2)
 ; CHECK-NEXT:   STV_HIDDEN
 ; CHECK-NEXT: ]
 ; CHECK-NEXT: Section: .data
 

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

 // CHECK-NEXT: 20102c           20102c        0     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
 // CHECK-NEXT: 20102c           20102c        0     1                 bah
 // CHECK-NEXT: 20102c           20102c        1     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
 // CHECK-NEXT: 20102c           20102c        0     1                 baz
 // CHECK-NEXT: 201030           201030       30    16 .plt
 // CHECK-NEXT: 201030           201030       30    16         <internal>:(.plt)
 // CHECK-NEXT: 201040           201040        0     1                 sharedFunc1
 // CHECK-NEXT: 201050           201050        0     1                 sharedFunc2
-// CHECK-NEXT: 202000           202000       28     8 .got.plt
-// CHECK-NEXT: 202000           202000       28     8         <internal>:(.got.plt)
-// CHECK-NEXT: 203000           203000      100     8 .dynamic
-// CHECK-NEXT: 203000           203000      100     8         <internal>:(.dynamic)
-// CHECK-NEXT: 204000           204000       10    16 .bss
-// CHECK-NEXT: 204000           204000        4    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
-// CHECK-NEXT: 204000           204000        4     1                 common
-// CHECK-NEXT: 204004           204004        4     1         <internal>:(.bss)
-// CHECK-NEXT: 204004           204004        4     1                 sharedFoo
-// CHECK-NEXT: 204008           204008        8     1         <internal>:(.bss)
-// CHECK-NEXT: 204008           204008        8     1                 sharedBar
+// CHECK-NEXT: 202000           202000      100     8 .dynamic
+// CHECK-NEXT: 202000           202000      100     8         <internal>:(.dynamic)
+// CHECK-NEXT: 203000           203000       28     8 .got.plt
+// CHECK-NEXT: 203000           203000       28     8         <internal>:(.got.plt)
+// CHECK-NEXT: 203030           203030       10    16 .bss
+// CHECK-NEXT: 203030           203030        4    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
+// CHECK-NEXT: 203030           203030        4     1                 common
+// CHECK-NEXT: 203034           203034        4     1         <internal>:(.bss)
+// CHECK-NEXT: 203034           203034        4     1                 sharedFoo
+// CHECK-NEXT: 203038           203038        8     1         <internal>:(.bss)
+// CHECK-NEXT: 203038           203038        8     1                 sharedBar
 // CHECK-NEXT:      0                0        8     1 .comment
 // CHECK-NEXT:      0                0        8     1         <internal>:(.comment)
 // CHECK-NEXT:      0                0      198     8 .symtab
 // CHECK-NEXT:      0                0      198     8         <internal>:(.symtab)
 // CHECK-NEXT:      0                0       84     1 .shstrtab
 // CHECK-NEXT:      0                0       84     1         <internal>:(.shstrtab)
 // CHECK-NEXT:      0                0       6d     1 .strtab
 // CHECK-NEXT:      0                0       6d     1         <internal>:(.strtab)
 
 
 // RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=/ 2>&1 \
 // RUN:  | FileCheck -check-prefix=FAIL %s
 // FAIL: cannot open map file /

lld/trunk/test/ELF/merge-section-types.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t
 // RUN: llvm-readobj -s %t | FileCheck %s
 
 // CHECK:      Name: .foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x1000
-// CHECK-NEXT: Offset: 0x1000
+// CHECK-NEXT: Address: 0x2000
+// CHECK-NEXT: Offset: 0x2000
 // CHECK-NEXT: Size: 16
 
 .section .foo, "aw", @progbits, unique, 1
 .quad 0
 
 .section .foo, "aw", @nobits, unique, 2
 .quad 0

lld/trunk/test/ELF/mips-mgot.s

 # REQUIRES: mips
 # Check MIPS multi-GOT layout.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t0.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %p/Inputs/mips-mgot-1.s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %p/Inputs/mips-mgot-2.s -o %t2.o
 # RUN: ld.lld -shared -mips-got-size 52 %t0.o %t1.o %t2.o -o %t.so
 # RUN: llvm-objdump -s -section=.got -t %t.so | FileCheck %s
 # RUN: llvm-readobj -r -dt -mips-plt-got %t.so | FileCheck -check-prefix=GOT %s
 
 # CHECK:      Contents of section .got:
-# CHECK-NEXT:  60000 00000000 80000000 00010000 00010030
-# CHECK-NEXT:  60010 00000000 00000004 00020000 00030000
-# CHECK-NEXT:  60020 00040000 00050000 00060000 00070000
-# CHECK-NEXT:  60030 00000000 00000000 00000000 00000000
-# CHECK-NEXT:  60040 00000000 00000000 00000000
+# CHECK-NEXT:  70000 00000000 80000000 00010000 00010030
+# CHECK-NEXT:  70010 00000000 00000004 00030000 00040000
+# CHECK-NEXT:  70020 00050000 00060000 00070000 00080000
+# CHECK-NEXT:  70030 00000000 00000000 00000000 00000000
+# CHECK-NEXT:  70040 00000000 00000000 00000000
 
 # CHECK: SYMBOL TABLE:
 # CHECK: 00000000 l    O .tdata          00000000 loc0
 # CHECK: 00010000        .text           00000000 foo0
 # CHECK: 00000000 g    O .tdata          00000000 tls0
 # CHECK: 00010020        .text           00000000 foo1
 # CHECK: 00000004 g    O .tdata          00000000 tls1
 # CHECK: 00010030        .text           00000000 foo2
 # CHECK: 00000008 g    O .tdata          00000000 tls2
 
 # GOT:      Relocations [
 # GOT-NEXT:   Section (7) .rel.dyn {
-# GOT-NEXT:     0x60018 R_MIPS_REL32 - 0x0
-# GOT-NEXT:     0x6001C R_MIPS_REL32 - 0x0
-# GOT-NEXT:     0x60020 R_MIPS_REL32 - 0x0
-# GOT-NEXT:     0x60024 R_MIPS_REL32 - 0x0
-# GOT-NEXT:     0x60028 R_MIPS_REL32 - 0x0
-# GOT-NEXT:     0x6002C R_MIPS_REL32 - 0x0
-# GOT-NEXT:     0x60030 R_MIPS_REL32 foo0 0x0
-# GOT-NEXT:     0x60034 R_MIPS_REL32 foo2 0x0
-# GOT-NEXT:     0x60044 R_MIPS_TLS_DTPMOD32 - 0x0
-# GOT-NEXT:     0x60010 R_MIPS_TLS_TPREL32 tls0 0x0
-# GOT-NEXT:     0x60038 R_MIPS_TLS_TPREL32 tls0 0x0
-# GOT-NEXT:     0x6003C R_MIPS_TLS_DTPMOD32 tls0 0x0
-# GOT-NEXT:     0x60040 R_MIPS_TLS_DTPREL32 tls0 0x0
-# GOT-NEXT:     0x60014 R_MIPS_TLS_TPREL32 tls1 0x0
+# GOT-NEXT:     0x70018 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x7001C R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x70020 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x70024 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x70028 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x7002C R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x70030 R_MIPS_REL32 foo0 0x0
+# GOT-NEXT:     0x70034 R_MIPS_REL32 foo2 0x0
+# GOT-NEXT:     0x70044 R_MIPS_TLS_DTPMOD32 - 0x0
+# GOT-NEXT:     0x70010 R_MIPS_TLS_TPREL32 tls0 0x0
+# GOT-NEXT:     0x70038 R_MIPS_TLS_TPREL32 tls0 0x0
+# GOT-NEXT:     0x7003C R_MIPS_TLS_DTPMOD32 tls0 0x0
+# GOT-NEXT:     0x70040 R_MIPS_TLS_DTPREL32 tls0 0x0
+# GOT-NEXT:     0x70014 R_MIPS_TLS_TPREL32 tls1 0x0
 # GOT-NEXT:   }
 # GOT-NEXT: ]
 
 # GOT:      DynamicSymbols [
 # GOT:        Symbol {
 # GOT:          Name: foo0
 # GOT-NEXT:     Value: 0x10000
 # GOT:        }
 # GOT-NEXT:   Symbol {
 # GOT-NEXT:     Name: foo2
 # GOT-NEXT:     Value: 0x10030
 # GOT:        }
 # GOT-NEXT: ]
 
 # GOT:      Primary GOT {
-# GOT-NEXT:   Canonical gp value: 0x67FF0
+# GOT-NEXT:   Canonical gp value: 0x77FF0
 # GOT-NEXT:   Reserved entries [
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address:
 # GOT-NEXT:       Access: -32752
 # GOT-NEXT:       Initial: 0x0
 # GOT-NEXT:       Purpose: Lazy resolver
 # GOT-NEXT:     }
 # GOT-NEXT:     Entry {

lld/trunk/test/ELF/mips-tls-64.s

 # DIS:      __start:
 # DIS-NEXT:    20000:   24 62 80 30   addiu   $2, $3, -32720
 # DIS-NEXT:    20004:   24 62 80 20   addiu   $2, $3, -32736
 # DIS-NEXT:    20008:   24 62 80 40   addiu   $2, $3, -32704
 # DIS-NEXT:    2000c:   24 62 80 50   addiu   $2, $3, -32688
 # DIS-NEXT:    20010:   24 62 80 28   addiu   $2, $3, -32728
 
 # DIS:      Contents of section .got:
-# DIS-NEXT:  30010 00000000 00000000 80000000 00000000
-# DIS-NEXT:  30020 00000000 00000000 ffffffff ffff9004
-# DIS-NEXT:  30030 00000000 00000000 00000000 00000000
-# DIS-NEXT:  30040 00000000 00000001 00000000 00000000
-# DIS-NEXT:  30050 00000000 00000001 ffffffff ffff8004
+# DIS-NEXT:  40010 00000000 00000000 80000000 00000000
+# DIS-NEXT:  40020 00000000 00000000 ffffffff ffff9004
+# DIS-NEXT:  40030 00000000 00000000 00000000 00000000
+# DIS-NEXT:  40040 00000000 00000001 00000000 00000000
+# DIS-NEXT:  40050 00000000 00000001 ffffffff ffff8004
 
 # DIS: 0000000000000000 l     O .tdata          00000000 loc
 # DIS: 0000000000000004 g     O .tdata          00000000 bar
 # DIS: 0000000000000000 g     O *UND*           00000000 foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rel.dyn {
-# CHECK-NEXT:     0x30020 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# CHECK-NEXT:     0x30030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# CHECK-NEXT:     0x30038 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# CHECK-NEXT:     0x40020 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# CHECK-NEXT:     0x40030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# CHECK-NEXT:     0x40038 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Primary GOT {
-# CHECK-NEXT:   Canonical gp value: 0x38000
+# CHECK-NEXT:   Canonical gp value: 0x48000
 # CHECK-NEXT:   Reserved entries [
 # CHECK:        ]
 # CHECK-NEXT:   Local entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Global entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Number of TLS and multi-GOT entries: 8
 #               ^-- -32736 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  foo
 #               ^-- -32728 R_MIPS_TLS_GOTTPREL VA - 0x7000 bar
 #               ^-- -32720 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 foo
 #               ^-- -32712                     R_MIPS_TLS_DTPREL64 foo
 #               ^-- -32704 R_MIPS_TLS_LDM      1 loc
 #               ^-- -32696                     0 loc
 #               ^-- -32688 R_MIPS_TLS_GD       1 bar
 #               ^-- -32680                     VA - 0x8000 bar
 
 # DIS-SO:      Contents of section .got:
-# DIS-SO-NEXT:  20000 00000000 00000000 80000000 00000000
-# DIS-SO-NEXT:  20010 00000000 00000000 00000000 00000004
-# DIS-SO-NEXT:  20020 00000000 00000000 00000000 00000000
-# DIS-SO-NEXT:  20030 00000000 00000000 00000000 00000000
-# DIS-SO-NEXT:  20040 00000000 00000000 00000000 00000000
+# DIS-SO-NEXT:  30000 00000000 00000000 80000000 00000000
+# DIS-SO-NEXT:  30010 00000000 00000000 00000000 00000004
+# DIS-SO-NEXT:  30020 00000000 00000000 00000000 00000000
+# DIS-SO-NEXT:  30030 00000000 00000000 00000000 00000000
+# DIS-SO-NEXT:  30040 00000000 00000000 00000000 00000000
 
 # SO:      Relocations [
 # SO-NEXT:   Section (7) .rel.dyn {
-# SO-NEXT:     0x20030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE - 0x0
-# SO-NEXT:     0x20018 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
-# SO-NEXT:     0x20040 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
-# SO-NEXT:     0x20048 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
-# SO-NEXT:     0x20010 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# SO-NEXT:     0x20020 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# SO-NEXT:     0x20028 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x30030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE - 0x0
+# SO-NEXT:     0x30018 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
+# SO-NEXT:     0x30040 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
+# SO-NEXT:     0x30048 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
+# SO-NEXT:     0x30010 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x30020 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x30028 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # SO-NEXT:   }
 # SO-NEXT: ]
 # SO-NEXT: Primary GOT {
-# SO-NEXT:   Canonical gp value: 0x27FF0
+# SO-NEXT:   Canonical gp value: 0x37FF0
 # SO-NEXT:   Reserved entries [
 # SO:        ]
 # SO-NEXT:   Local entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Global entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Number of TLS and multi-GOT entries: 8
 #            ^-- -32736 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  foo

lld/trunk/test/ELF/mips-tls-static-64.s

 # REQUIRES: mips
 # Check handling TLS related relocations and symbols when linking
 # a 64-bit static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
 # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
 
 # CHECK:      Contents of section .data:
-# CHECK-NEXT:  30000 00020004 ffffffff ffff8004 ffffffff
-# CHECK-NEXT:  30010 ffff9004
+# CHECK-NEXT:  40000 00020004 ffffffff ffff8004 ffffffff
+# CHECK-NEXT:  40010 ffff9004
 #
 # CHECK: SYMBOL TABLE:
 # CHECK: 0000000000020004        .text           00000000 __tls_get_addr
 # CHECK: 0000000000000000 g    O .tdata          00000000 tls1
 
   .text
   .global __start
 __start:

lld/trunk/test/ELF/mips-tls-static.s

 # REQUIRES: mips
 # Check handling TLS related relocations and symbols when linking
 # a static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
 # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
 
 # CHECK:      Contents of section .data:
-# CHECK-NEXT:  30000 0002000c ffff8004 ffff9004
+# CHECK-NEXT:  40000 0002000c ffff8004 ffff9004
 # CHECK:      Contents of section .got:
-# CHECK-NEXT:  30010 00000000 80000000 ffff9000 00000001
-# CHECK-NEXT:  30020 ffff8000 00000001 00000000
+# CHECK-NEXT:  40010 00000000 80000000 ffff9000 00000001
+# CHECK-NEXT:  40020 ffff8000 00000001 00000000
 #
 # CHECK: SYMBOL TABLE:
 # CHECK: 0002000c        .text           00000000 __tls_get_addr
 # CHECK: 00000000 g    O .tdata          00000000 tls1
 
   .text
   .global __start
 __start:

lld/trunk/test/ELF/mips-tls.s

 # DIS:      __start:
 # DIS-NEXT:    20000:   24 62 80 20   addiu   $2, $3, -32736
 # DIS-NEXT:    20004:   24 62 80 18   addiu   $2, $3, -32744
 # DIS-NEXT:    20008:   24 62 80 28   addiu   $2, $3, -32728
 # DIS-NEXT:    2000c:   24 62 80 30   addiu   $2, $3, -32720
 # DIS-NEXT:    20010:   24 62 80 1c   addiu   $2, $3, -32740
 
 # DIS:      Contents of section .got:
-# DIS-NEXT:  30010 00000000 80000000 00000000 ffff9004
-# DIS-NEXT:  30020 00000000 00000000 00000001 00000000
-# DIS-NEXT:  30030 00000001 ffff8004
+# DIS-NEXT:  40010 00000000 80000000 00000000 ffff9004
+# DIS-NEXT:  40020 00000000 00000000 00000001 00000000
+# DIS-NEXT:  40030 00000001 ffff8004
 
 # DIS: 00000000 l    O .tdata          00000000 loc
 # DIS: 00000004 g    O .tdata          00000000 bar
 # DIS: 00000000 g    O *UND*           00000000 foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rel.dyn {
-# CHECK-NEXT:     0x30018 R_MIPS_TLS_TPREL32 foo 0x0
-# CHECK-NEXT:     0x30020 R_MIPS_TLS_DTPMOD32 foo 0x0
-# CHECK-NEXT:     0x30024 R_MIPS_TLS_DTPREL32 foo 0x0
+# CHECK-NEXT:     0x40018 R_MIPS_TLS_TPREL32 foo 0x0
+# CHECK-NEXT:     0x40020 R_MIPS_TLS_DTPMOD32 foo 0x0
+# CHECK-NEXT:     0x40024 R_MIPS_TLS_DTPREL32 foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Primary GOT {
-# CHECK-NEXT:   Canonical gp value: 0x38000
+# CHECK-NEXT:   Canonical gp value: 0x48000
 # CHECK-NEXT:   Reserved entries [
 # CHECK:        ]
 # CHECK-NEXT:   Local entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Global entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Number of TLS and multi-GOT entries: 8
 #               ^-- -32744 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  foo
 #               ^-- -32740 R_MIPS_TLS_GOTTPREL VA - 0x7000 bar
 #               ^-- -32736 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 foo
 #               ^-- -32732                     R_MIPS_TLS_DTPREL32 foo
 #               ^-- -32728 R_MIPS_TLS_LDM      1 loc
 #               ^-- -32724                     0 loc
 #               ^-- -32720 R_MIPS_TLS_GD       1 bar
 #               ^-- -32716                     VA - 0x8000 bar
 
 # DIS-SO:      Contents of section .got:
-# DIS-SO-NEXT:  20000 00000000 80000000 00000000 00000004
-# DIS-SO-NEXT:  20010 00000000 00000000 00000000 00000000
-# DIS-SO-NEXT:  20020 00000000 00000000
+# DIS-SO-NEXT:  30000 00000000 80000000 00000000 00000004
+# DIS-SO-NEXT:  30010 00000000 00000000 00000000 00000000
+# DIS-SO-NEXT:  30020 00000000 00000000
 
 # SO:      Relocations [
 # SO-NEXT:   Section (7) .rel.dyn {
-# SO-NEXT:     0x20018 R_MIPS_TLS_DTPMOD32 - 0x0
-# SO-NEXT:     0x2000C R_MIPS_TLS_TPREL32 bar 0x0
-# SO-NEXT:     0x20020 R_MIPS_TLS_DTPMOD32 bar 0x0
-# SO-NEXT:     0x20024 R_MIPS_TLS_DTPREL32 bar 0x0
-# SO-NEXT:     0x20008 R_MIPS_TLS_TPREL32 foo 0x0
-# SO-NEXT:     0x20010 R_MIPS_TLS_DTPMOD32 foo 0x0
-# SO-NEXT:     0x20014 R_MIPS_TLS_DTPREL32 foo 0x0
+# SO-NEXT:     0x30018 R_MIPS_TLS_DTPMOD32 - 0x0
+# SO-NEXT:     0x3000C R_MIPS_TLS_TPREL32 bar 0x0
+# SO-NEXT:     0x30020 R_MIPS_TLS_DTPMOD32 bar 0x0
+# SO-NEXT:     0x30024 R_MIPS_TLS_DTPREL32 bar 0x0
+# SO-NEXT:     0x30008 R_MIPS_TLS_TPREL32 foo 0x0
+# SO-NEXT:     0x30010 R_MIPS_TLS_DTPMOD32 foo 0x0
+# SO-NEXT:     0x30014 R_MIPS_TLS_DTPREL32 foo 0x0
 # SO-NEXT:   }
 # SO-NEXT: ]
 # SO-NEXT: Primary GOT {
-# SO-NEXT:   Canonical gp value: 0x27FF0
+# SO-NEXT:   Canonical gp value: 0x37FF0
 # SO-NEXT:   Reserved entries [
 # SO:        ]
 # SO-NEXT:   Local entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Global entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Number of TLS and multi-GOT entries: 8
 #            ^-- -32744 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  foo

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

 // REQUIRES: arm, aarch64
 
 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-android %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so --pack-dyn-relocs=android
 // RUN: llvm-readobj -s %t.so | FileCheck %s
 
 // This test is making sure the Android packed relocation support doesn't
 // cause an infinite loop due to the size of the section oscillating
 // (because the size of the section impacts the layout of the following
 // sections).
 
 // 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:    Size: 21
+// 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: 0x225
-// CHECK-NEXT:    Offset: 0x225
+// CHECK-NEXT:    Address: 0x226
+// CHECK-NEXT:    Offset: 0x226
 // 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:    Size: 0
 
-// CHECK:         Name: foo (62)
+// 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: 0x10004
-// CHECK-NEXT:    Offset: 0x10004
+// CHECK-NEXT:    Address: 0x20004
+// CHECK-NEXT:    Offset: 0x20004
 // CHECK-NEXT:    Size: 12
 
 
 .data
 .long 0
 
 .section foo,"aw"
 foof:

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

 // REQUIRES: arm, aarch64
 
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-shared.s -o %t.a32.so.o
 // RUN: ld.lld -shared %t.a32.so.o -o %t.a32.so
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.a32
 // RUN: ld.lld -pie --pack-dyn-relocs=none %t.a32 %t.a32.so -o %t2.a32
 // RUN: llvm-readobj -relocations %t2.a32 | FileCheck --check-prefix=UNPACKED32 %s
 
 // Unpacked should have the relative relocations in their natural order.
 // UNPACKED32:          Section ({{.+}}) .rel.dyn {
-// UNPACKED32-NEXT:     0x1000 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1004 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1008 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x100C R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1010 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1014 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1018 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x101C R_ARM_RELATIVE - 0x0
-
-// UNPACKED32-NEXT:     0x1024 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1028 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x102C R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1030 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1034 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1038 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x103C R_ARM_RELATIVE - 0x0
-
-// UNPACKED32-NEXT:     0x1044 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1048 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x104C R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1050 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1054 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1058 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x105C R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1060 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1064 R_ARM_RELATIVE - 0x0
-
-// UNPACKED32-NEXT:     0x1069 R_ARM_RELATIVE - 0x0
-// UNPACKED32-NEXT:     0x1020 R_ARM_ABS32 bar2 0x0
-// UNPACKED32-NEXT:     0x1040 R_ARM_ABS32 zed2 0x0
+// UNPACKED32-NEXT:     0x2000 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2004 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2008 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x200C R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2010 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2014 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2018 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x201C R_ARM_RELATIVE - 0x0
+
+// UNPACKED32-NEXT:     0x2024 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2028 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x202C R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2030 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2034 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2038 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x203C R_ARM_RELATIVE - 0x0
+
+// UNPACKED32-NEXT:     0x2044 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2048 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x204C R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2050 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2054 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2058 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x205C R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2060 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2064 R_ARM_RELATIVE - 0x0
+
+// UNPACKED32-NEXT:     0x2069 R_ARM_RELATIVE - 0x0
+// UNPACKED32-NEXT:     0x2020 R_ARM_ABS32 bar2 0x0
+// UNPACKED32-NEXT:     0x2040 R_ARM_ABS32 zed2 0x0
 // UNPACKED32-NEXT:     }
 
 // RUN: ld.lld -pie --pack-dyn-relocs=android %t.a32 %t.a32.so -o %t3.a32
 // RUN: llvm-readobj -s -dynamic-table %t3.a32 | FileCheck --check-prefix=ANDROID32-HEADERS %s
 // RUN: llvm-readobj -relocations %t3.a32 | FileCheck --check-prefix=ANDROID32 %s
 
 // ANDROID32-HEADERS:       Index: 1
 // ANDROID32-HEADERS-NEXT:  Name: .dynsym

 // ANDROID32-HEADERS-NEXT:  EntrySize: 1
 
 // ANDROID32-HEADERS: 0x6000000F ANDROID_REL          [[ADDR]]
 // ANDROID32-HEADERS: 0x60000010 ANDROID_RELSZ        [[SIZE]]
 
 // Packed should have the larger groups of relative relocations first,
 // i.e. the 8 and 9 followed by the 7.
 // ANDROID32:          Section ({{.+}}) .rel.dyn {
-// ANDROID32-NEXT:     0x1000 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1004 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1008 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x100C R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1010 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1014 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1018 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x101C R_ARM_RELATIVE - 0x0
-
-// ANDROID32-NEXT:     0x1044 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1048 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x104C R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1050 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1054 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1058 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x105C R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1060 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1064 R_ARM_RELATIVE - 0x0
-
-// ANDROID32-NEXT:     0x1024 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1028 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x102C R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1030 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1034 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1038 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x103C R_ARM_RELATIVE - 0x0
-
-// ANDROID32-NEXT:     0x1069 R_ARM_RELATIVE - 0x0
-// ANDROID32-NEXT:     0x1020 R_ARM_ABS32 bar2 0x0
-// ANDROID32-NEXT:     0x1040 R_ARM_ABS32 zed2 0x0
+// ANDROID32-NEXT:     0x2000 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2004 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2008 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x200C R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2010 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2014 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2018 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x201C R_ARM_RELATIVE - 0x0
+
+// ANDROID32-NEXT:     0x2044 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2048 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x204C R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2050 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2054 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2058 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x205C R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2060 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2064 R_ARM_RELATIVE - 0x0
+
+// ANDROID32-NEXT:     0x2024 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2028 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x202C R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2030 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2034 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2038 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x203C R_ARM_RELATIVE - 0x0
+
+// ANDROID32-NEXT:     0x2069 R_ARM_RELATIVE - 0x0
+// ANDROID32-NEXT:     0x2020 R_ARM_ABS32 bar2 0x0
+// ANDROID32-NEXT:     0x2040 R_ARM_ABS32 zed2 0x0
 // ANDROID32-NEXT:     }
 
 // RUN: ld.lld -pie --pack-dyn-relocs=relr %t.a32 %t.a32.so -o %t4.a32
 // RUN: llvm-readobj -s -dynamic-table %t4.a32 | FileCheck --check-prefix=RELR32-HEADERS %s
 // RUN: llvm-readobj -relocations -raw-relr %t4.a32 | FileCheck --check-prefix=RAW-RELR32 %s
 // RUN: llvm-readobj -relocations %t4.a32 | FileCheck --check-prefix=RELR32 %s
 
 // RELR32-HEADERS:       Index: 1

 
 // RELR32-HEADERS:       0x00000024 RELR                 [[ADDR]]
 // RELR32-HEADERS:       0x00000023 RELRSZ               0x8
 // RELR32-HEADERS:       0x00000025 RELRENT              0x4
 
 // SHT_RELR section contains address/bitmap entries
 // encoding the offsets for relative relocation.
 // RAW-RELR32:           Section ({{.+}}) .relr.dyn {
-// RAW-RELR32-NEXT:      0x1000
+// RAW-RELR32-NEXT:      0x2000
 // RAW-RELR32-NEXT:      0x3FEFEFF
 // RAW-RELR32-NEXT:      }
 
 // Decoded SHT_RELR section is same as UNPACKED,
 // but contains only the relative relocations.
 // Any relative relocations with odd offset stay in SHT_REL.
 // RELR32:               Section ({{.+}}) .rel.dyn {
-// RELR32-NEXT:          0x1069 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1020 R_ARM_ABS32 bar2 0x0
-// RELR32-NEXT:          0x1040 R_ARM_ABS32 zed2 0x0
+// RELR32-NEXT:          0x2069 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2020 R_ARM_ABS32 bar2 0x0
+// RELR32-NEXT:          0x2040 R_ARM_ABS32 zed2 0x0
 // RELR32-NEXT:          }
 // RELR32-NEXT:          Section ({{.+}}) .relr.dyn {
-// RELR32-NEXT:          0x1000 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1004 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1008 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x100C R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1010 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1014 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1018 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x101C R_ARM_RELATIVE - 0x0
-
-// RELR32-NEXT:          0x1024 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1028 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x102C R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1030 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1034 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1038 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x103C R_ARM_RELATIVE - 0x0
-
-// RELR32-NEXT:          0x1044 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1048 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x104C R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1050 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1054 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1058 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x105C R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1060 R_ARM_RELATIVE - 0x0
-// RELR32-NEXT:          0x1064 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2000 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2004 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2008 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x200C R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2010 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2014 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2018 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x201C R_ARM_RELATIVE - 0x0
+
+// RELR32-NEXT:          0x2024 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2028 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x202C R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2030 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2034 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2038 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x203C R_ARM_RELATIVE - 0x0
+
+// RELR32-NEXT:          0x2044 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2048 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x204C R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2050 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2054 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2058 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x205C R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2060 R_ARM_RELATIVE - 0x0
+// RELR32-NEXT:          0x2064 R_ARM_RELATIVE - 0x0
 // RELR32-NEXT:          }
 
 // RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %p/Inputs/shared2.s -o %t.a64.so.o
 // RUN: ld.lld -shared %t.a64.so.o -o %t.a64.so
 // RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-linux %s -o %t.a64
 // RUN: ld.lld -pie --pack-dyn-relocs=none %t.a64 %t.a64.so -o %t2.a64
 // RUN: llvm-readobj -relocations %t2.a64 | FileCheck --check-prefix=UNPACKED64 %s
 
 // UNPACKED64:          Section ({{.+}}) .rela.dyn {
-// UNPACKED64-NEXT:     0x10000 R_AARCH64_RELATIVE - 0x1
-// UNPACKED64-NEXT:     0x10008 R_AARCH64_RELATIVE - 0x2
-// UNPACKED64-NEXT:     0x10010 R_AARCH64_RELATIVE - 0x3
-// UNPACKED64-NEXT:     0x10018 R_AARCH64_RELATIVE - 0x4
-// UNPACKED64-NEXT:     0x10020 R_AARCH64_RELATIVE - 0x5
-// UNPACKED64-NEXT:     0x10028 R_AARCH64_RELATIVE - 0x6
-// UNPACKED64-NEXT:     0x10030 R_AARCH64_RELATIVE - 0x7
-// UNPACKED64-NEXT:     0x10038 R_AARCH64_RELATIVE - 0x8
-
-// UNPACKED64-NEXT:     0x10048 R_AARCH64_RELATIVE - 0x1
-// UNPACKED64-NEXT:     0x10050 R_AARCH64_RELATIVE - 0x2
-// UNPACKED64-NEXT:     0x10058 R_AARCH64_RELATIVE - 0x3
-// UNPACKED64-NEXT:     0x10060 R_AARCH64_RELATIVE - 0x4
-// UNPACKED64-NEXT:     0x10068 R_AARCH64_RELATIVE - 0x5
-// UNPACKED64-NEXT:     0x10070 R_AARCH64_RELATIVE - 0x6
-// UNPACKED64-NEXT:     0x10078 R_AARCH64_RELATIVE - 0x7
-
-// UNPACKED64-NEXT:     0x10088 R_AARCH64_RELATIVE - 0x1
-// UNPACKED64-NEXT:     0x10090 R_AARCH64_RELATIVE - 0x2
-// UNPACKED64-NEXT:     0x10098 R_AARCH64_RELATIVE - 0x3
-// UNPACKED64-NEXT:     0x100A0 R_AARCH64_RELATIVE - 0x4
-// UNPACKED64-NEXT:     0x100A8 R_AARCH64_RELATIVE - 0x5
-// UNPACKED64-NEXT:     0x100B0 R_AARCH64_RELATIVE - 0x6
-// UNPACKED64-NEXT:     0x100B8 R_AARCH64_RELATIVE - 0x7
-// UNPACKED64-NEXT:     0x100C0 R_AARCH64_RELATIVE - 0x8
-// UNPACKED64-NEXT:     0x100C8 R_AARCH64_RELATIVE - 0x9
-
-// UNPACKED64-NEXT:     0x100D1 R_AARCH64_RELATIVE - 0xA
-// UNPACKED64-NEXT:     0x10040 R_AARCH64_ABS64 bar2 0x1
-// UNPACKED64-NEXT:     0x10080 R_AARCH64_ABS64 zed2 0x0
+// UNPACKED64-NEXT:     0x20000 R_AARCH64_RELATIVE - 0x1
+// UNPACKED64-NEXT:     0x20008 R_AARCH64_RELATIVE - 0x2
+// UNPACKED64-NEXT:     0x20010 R_AARCH64_RELATIVE - 0x3
+// UNPACKED64-NEXT:     0x20018 R_AARCH64_RELATIVE - 0x4
+// UNPACKED64-NEXT:     0x20020 R_AARCH64_RELATIVE - 0x5
+// UNPACKED64-NEXT:     0x20028 R_AARCH64_RELATIVE - 0x6
+// UNPACKED64-NEXT:     0x20030 R_AARCH64_RELATIVE - 0x7
+// UNPACKED64-NEXT:     0x20038 R_AARCH64_RELATIVE - 0x8
+
+// UNPACKED64-NEXT:     0x20048 R_AARCH64_RELATIVE - 0x1
+// UNPACKED64-NEXT:     0x20050 R_AARCH64_RELATIVE - 0x2
+// UNPACKED64-NEXT:     0x20058 R_AARCH64_RELATIVE - 0x3
+// UNPACKED64-NEXT:     0x20060 R_AARCH64_RELATIVE - 0x4
+// UNPACKED64-NEXT:     0x20068 R_AARCH64_RELATIVE - 0x5
+// UNPACKED64-NEXT:     0x20070 R_AARCH64_RELATIVE - 0x6
+// UNPACKED64-NEXT:     0x20078 R_AARCH64_RELATIVE - 0x7
+
+// UNPACKED64-NEXT:     0x20088 R_AARCH64_RELATIVE - 0x1
+// UNPACKED64-NEXT:     0x20090 R_AARCH64_RELATIVE - 0x2
+// UNPACKED64-NEXT:     0x20098 R_AARCH64_RELATIVE - 0x3
+// UNPACKED64-NEXT:     0x200A0 R_AARCH64_RELATIVE - 0x4
+// UNPACKED64-NEXT:     0x200A8 R_AARCH64_RELATIVE - 0x5
+// UNPACKED64-NEXT:     0x200B0 R_AARCH64_RELATIVE - 0x6
+// UNPACKED64-NEXT:     0x200B8 R_AARCH64_RELATIVE - 0x7
+// UNPACKED64-NEXT:     0x200C0 R_AARCH64_RELATIVE - 0x8
+// UNPACKED64-NEXT:     0x200C8 R_AARCH64_RELATIVE - 0x9
+
+// UNPACKED64-NEXT:     0x200D1 R_AARCH64_RELATIVE - 0xA
+// UNPACKED64-NEXT:     0x20040 R_AARCH64_ABS64 bar2 0x1
+// UNPACKED64-NEXT:     0x20080 R_AARCH64_ABS64 zed2 0x0
 // UNPACKED64-NEXT:     }
 
 // RUN: ld.lld -pie --pack-dyn-relocs=android %t.a64 %t.a64.so -o %t3.a64
 // RUN: llvm-readobj -s -dynamic-table %t3.a64 | FileCheck --check-prefix=ANDROID64-HEADERS %s
 // RUN: llvm-readobj -relocations %t3.a64 | FileCheck --check-prefix=ANDROID64 %s
 
 // ANDROID64-HEADERS:       Index: 1
 // ANDROID64-HEADERS-NEXT:  Name: .dynsym

 // ANDROID64-HEADERS-NEXT:  Info: 0
 // ANDROID64-HEADERS-NEXT:  AddressAlignment: 8
 // ANDROID64-HEADERS-NEXT:  EntrySize: 1
 
 // ANDROID64-HEADERS: 0x0000000060000011 ANDROID_RELA          [[ADDR]]
 // ANDROID64-HEADERS: 0x0000000060000012 ANDROID_RELASZ        [[SIZE]]
 
 // ANDROID64:          Section ({{.+}}) .rela.dyn {
-// ANDROID64-NEXT:     0x10000 R_AARCH64_RELATIVE - 0x1
-// ANDROID64-NEXT:     0x10008 R_AARCH64_RELATIVE - 0x2
-// ANDROID64-NEXT:     0x10010 R_AARCH64_RELATIVE - 0x3
-// ANDROID64-NEXT:     0x10018 R_AARCH64_RELATIVE - 0x4
-// ANDROID64-NEXT:     0x10020 R_AARCH64_RELATIVE - 0x5
-// ANDROID64-NEXT:     0x10028 R_AARCH64_RELATIVE - 0x6
-// ANDROID64-NEXT:     0x10030 R_AARCH64_RELATIVE - 0x7
-// ANDROID64-NEXT:     0x10038 R_AARCH64_RELATIVE - 0x8
-
-// ANDROID64-NEXT:     0x10088 R_AARCH64_RELATIVE - 0x1
-// ANDROID64-NEXT:     0x10090 R_AARCH64_RELATIVE - 0x2
-// ANDROID64-NEXT:     0x10098 R_AARCH64_RELATIVE - 0x3
-// ANDROID64-NEXT:     0x100A0 R_AARCH64_RELATIVE - 0x4
-// ANDROID64-NEXT:     0x100A8 R_AARCH64_RELATIVE - 0x5
-// ANDROID64-NEXT:     0x100B0 R_AARCH64_RELATIVE - 0x6
-// ANDROID64-NEXT:     0x100B8 R_AARCH64_RELATIVE - 0x7
-// ANDROID64-NEXT:     0x100C0 R_AARCH64_RELATIVE - 0x8
-// ANDROID64-NEXT:     0x100C8 R_AARCH64_RELATIVE - 0x9
-
-// ANDROID64-NEXT:     0x10048 R_AARCH64_RELATIVE - 0x1
-// ANDROID64-NEXT:     0x10050 R_AARCH64_RELATIVE - 0x2
-// ANDROID64-NEXT:     0x10058 R_AARCH64_RELATIVE - 0x3
-// ANDROID64-NEXT:     0x10060 R_AARCH64_RELATIVE - 0x4
-// ANDROID64-NEXT:     0x10068 R_AARCH64_RELATIVE - 0x5
-// ANDROID64-NEXT:     0x10070 R_AARCH64_RELATIVE - 0x6
-// ANDROID64-NEXT:     0x10078 R_AARCH64_RELATIVE - 0x7
-
-// ANDROID64-NEXT:     0x100D1 R_AARCH64_RELATIVE - 0xA
-// ANDROID64-NEXT:     0x10040 R_AARCH64_ABS64 bar2 0x1
-// ANDROID64-NEXT:     0x10080 R_AARCH64_ABS64 zed2 0x0
+// ANDROID64-NEXT:     0x20000 R_AARCH64_RELATIVE - 0x1
+// ANDROID64-NEXT:     0x20008 R_AARCH64_RELATIVE - 0x2
+// ANDROID64-NEXT:     0x20010 R_AARCH64_RELATIVE - 0x3
+// ANDROID64-NEXT:     0x20018 R_AARCH64_RELATIVE - 0x4
+// ANDROID64-NEXT:     0x20020 R_AARCH64_RELATIVE - 0x5
+// ANDROID64-NEXT:     0x20028 R_AARCH64_RELATIVE - 0x6
+// ANDROID64-NEXT:     0x20030 R_AARCH64_RELATIVE - 0x7
+// ANDROID64-NEXT:     0x20038 R_AARCH64_RELATIVE - 0x8
+
+// ANDROID64-NEXT:     0x20088 R_AARCH64_RELATIVE - 0x1
+// ANDROID64-NEXT:     0x20090 R_AARCH64_RELATIVE - 0x2
+// ANDROID64-NEXT:     0x20098 R_AARCH64_RELATIVE - 0x3
+// ANDROID64-NEXT:     0x200A0 R_AARCH64_RELATIVE - 0x4
+// ANDROID64-NEXT:     0x200A8 R_AARCH64_RELATIVE - 0x5
+// ANDROID64-NEXT:     0x200B0 R_AARCH64_RELATIVE - 0x6
+// ANDROID64-NEXT:     0x200B8 R_AARCH64_RELATIVE - 0x7
+// ANDROID64-NEXT:     0x200C0 R_AARCH64_RELATIVE - 0x8
+// ANDROID64-NEXT:     0x200C8 R_AARCH64_RELATIVE - 0x9
+
+// ANDROID64-NEXT:     0x20048 R_AARCH64_RELATIVE - 0x1
+// ANDROID64-NEXT:     0x20050 R_AARCH64_RELATIVE - 0x2
+// ANDROID64-NEXT:     0x20058 R_AARCH64_RELATIVE - 0x3
+// ANDROID64-NEXT:     0x20060 R_AARCH64_RELATIVE - 0x4
+// ANDROID64-NEXT:     0x20068 R_AARCH64_RELATIVE - 0x5
+// ANDROID64-NEXT:     0x20070 R_AARCH64_RELATIVE - 0x6
+// ANDROID64-NEXT:     0x20078 R_AARCH64_RELATIVE - 0x7
+
+// ANDROID64-NEXT:     0x200D1 R_AARCH64_RELATIVE - 0xA
+// ANDROID64-NEXT:     0x20040 R_AARCH64_ABS64 bar2 0x1
+// ANDROID64-NEXT:     0x20080 R_AARCH64_ABS64 zed2 0x0
 // ANDROID64-NEXT:     }
 
 // RUN: ld.lld -pie --pack-dyn-relocs=relr %t.a64 %t.a64.so -o %t4.a64
 // RUN: llvm-readobj -s -dynamic-table %t4.a64 | FileCheck --check-prefix=RELR64-HEADERS %s
 // RUN: llvm-readobj -relocations -raw-relr %t4.a64 | FileCheck --check-prefix=RAW-RELR64 %s
 // RUN: llvm-readobj -relocations %t4.a64 | FileCheck --check-prefix=RELR64 %s
 
 // RELR64-HEADERS:       Index: 1

 
 // RELR64-HEADERS:       0x0000000000000024 RELR                 [[ADDR]]
 // RELR64-HEADERS:       0x0000000000000023 RELRSZ               0x10
 // RELR64-HEADERS:       0x0000000000000025 RELRENT              0x8
 
 // SHT_RELR section contains address/bitmap entries
 // encoding the offsets for relative relocation.
 // RAW-RELR64:           Section ({{.+}}) .relr.dyn {
-// RAW-RELR64-NEXT:      0x10000
+// RAW-RELR64-NEXT:      0x20000
 // RAW-RELR64-NEXT:      0x3FEFEFF
 // RAW-RELR64-NEXT:      }
 
 // Decoded SHT_RELR section is same as UNPACKED,
 // but contains only the relative relocations.
 // Any relative relocations with odd offset stay in SHT_RELA.
 // RELR64:               Section ({{.+}}) .rela.dyn {
-// RELR64-NEXT:          0x100D1 R_AARCH64_RELATIVE - 0xA
-// RELR64-NEXT:          0x10040 R_AARCH64_ABS64 bar2 0x1
-// RELR64-NEXT:          0x10080 R_AARCH64_ABS64 zed2 0x0
+// RELR64-NEXT:          0x200D1 R_AARCH64_RELATIVE - 0xA
+// RELR64-NEXT:          0x20040 R_AARCH64_ABS64 bar2 0x1
+// RELR64-NEXT:          0x20080 R_AARCH64_ABS64 zed2 0x0
 // RELR64-NEXT:          }
 // RELR64-NEXT:          Section ({{.+}}) .relr.dyn {
-// RELR64-NEXT:          0x10000 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10008 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10010 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10018 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10020 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10028 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10030 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10038 R_AARCH64_RELATIVE - 0x0
-
-// RELR64-NEXT:          0x10048 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10050 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10058 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10060 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10068 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10070 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10078 R_AARCH64_RELATIVE - 0x0
-
-// RELR64-NEXT:          0x10088 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10090 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x10098 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x100A0 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x100A8 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x100B0 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x100B8 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x100C0 R_AARCH64_RELATIVE - 0x0
-// RELR64-NEXT:          0x100C8 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20000 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20008 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20010 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20018 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20020 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20028 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20030 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20038 R_AARCH64_RELATIVE - 0x0
+
+// RELR64-NEXT:          0x20048 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20050 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20058 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20060 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20068 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20070 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20078 R_AARCH64_RELATIVE - 0x0
+
+// RELR64-NEXT:          0x20088 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20090 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x20098 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x200A0 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x200A8 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x200B0 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x200B8 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x200C0 R_AARCH64_RELATIVE - 0x0
+// RELR64-NEXT:          0x200C8 R_AARCH64_RELATIVE - 0x0
 // RELR64-NEXT:          }
 
 .data
 .align 2
 .dc.a __ehdr_start + 1
 .dc.a __ehdr_start + 2
 .dc.a __ehdr_start + 3
 .dc.a __ehdr_start + 4

lld/trunk/test/ELF/pack-dyn-relocs2.s

 // REQUIRES: arm, aarch64
 
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %p/Inputs/arm-shared.s -o %t.so.o
 // RUN: ld.lld -shared %t.so.o -o %t.so
 
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.o
 // RUN: ld.lld -pie --pack-dyn-relocs=relr %t.o %t.so -o %t.exe
 // RUN: llvm-readobj -relocations %t.exe | FileCheck %s
 
 // CHECK:      Section (5) .relr.dyn {
-// CHECK-NEXT:   0x1000 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1004 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1008 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x100C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1010 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1014 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1018 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x101C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1020 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1024 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1028 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x102C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1030 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1034 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1038 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x103C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1040 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1044 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1048 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x104C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1050 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1054 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1058 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x105C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1060 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1064 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1068 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x106C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1070 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1074 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1078 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x107C R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1080 R_ARM_RELATIVE - 0x0
-// CHECK-NEXT:   0x1084 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2000 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2004 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2008 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x200C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2010 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2014 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2018 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x201C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2020 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2024 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2028 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x202C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2030 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2034 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2038 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x203C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2040 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2044 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2048 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x204C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2050 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2054 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2058 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x205C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2060 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2064 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2068 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x206C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2070 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2074 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2078 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x207C R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2080 R_ARM_RELATIVE - 0x0
+// CHECK-NEXT:   0x2084 R_ARM_RELATIVE - 0x0
 // CHECK-NEXT: }
 
 // RUN: llvm-readobj -s -dynamic-table %t.exe | FileCheck --check-prefix=HEADER %s
 // HEADER: 0x00000023 RELRSZ 0xC
 
 .data
 .align 2
 .dc.a __ehdr_start

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

 // CHECKDSO-NEXT:     AddressAlignment: 16
 
 // CHECKDSO:     Name: .got.plt
 // CHECKDSO-NEXT:     Type: SHT_PROGBITS
 // CHECKDSO-NEXT:     Flags [
 // CHECKDSO-NEXT:       SHF_ALLOC
 // CHECKDSO-NEXT:       SHF_WRITE
 // CHECKDSO-NEXT:     ]
-// CHECKDSO-NEXT:     Address: 0x20000
+// CHECKDSO-NEXT:     Address: 0x30000
 // CHECKDSO-NEXT:     Offset:
 // CHECKDSO-NEXT:     Size: 48
 // CHECKDSO-NEXT:     Link:
 // CHECKDSO-NEXT:     Info:
 // CHECKDSO-NEXT:     AddressAlignment: 8
 
 // CHECKDSO: Relocations [
 // CHECKDSO-NEXT:   Section ({{.*}}) .rela.plt {
 
-// &(.got.plt[3]) = 0x20000 + 3 * 8 = 0x30018
-// CHECKDSO-NEXT:     0x20018 R_AARCH64_JUMP_SLOT foo
+// &(.got.plt[3]) = 0x30000 + 3 * 8 = 0x30018
+// CHECKDSO-NEXT:     0x30018 R_AARCH64_JUMP_SLOT foo
 
-// &(.got.plt[4]) = 0x20000 + 4 * 8 = 0x30020
-// CHECKDSO-NEXT:     0x20020 R_AARCH64_JUMP_SLOT bar
+// &(.got.plt[4]) = 0x30000 + 4 * 8 = 0x30020
+// CHECKDSO-NEXT:     0x30020 R_AARCH64_JUMP_SLOT bar
 
-// &(.got.plt[5]) = 0x20000 + 5 * 8 = 0x30028
-// CHECKDSO-NEXT:     0x20028 R_AARCH64_JUMP_SLOT weak
+// &(.got.plt[5]) = 0x30000 + 5 * 8 = 0x30028
+// CHECKDSO-NEXT:     0x30028 R_AARCH64_JUMP_SLOT weak
 // CHECKDSO-NEXT:   }
 // CHECKDSO-NEXT: ]
 
 // DUMPDSO: Contents of section .got.plt:
 // .got.plt[0..2] = 0 (reserved)
 // .got.plt[3..5] = .plt = 0x10010
-// DUMPDSO-NEXT: 20000 00000000 00000000 00000000 00000000  ................
-// DUMPDSO-NEXT: 20010 00000000 00000000 10000100 00000000  ................
-// DUMPDSO-NEXT: 20020 10000100 00000000 10000100 00000000  ................
+// DUMPDSO-NEXT: 30000 00000000 00000000 00000000 00000000  ................
+// DUMPDSO-NEXT: 30010 00000000 00000000 10000100 00000000  ................
+// DUMPDSO-NEXT: 30020 10000100 00000000 10000100 00000000  ................
 
 // DISASMDSO: _start:
 // 0x10030 - 0x10000 = 0x30 = 48
 // DISASMDSO-NEXT:     10000: 0c 00 00 14   b #48
 // 0x10040 - 0x10004 = 0x3c = 60
 // DISASMDSO-NEXT:     10004: 0f 00 00 14   b #60
 // 0x10050 - 0x10008 = 0x48 = 72
 // DISASMDSO-NEXT:     10008: 12 00 00 14   b #72
 
 // DISASMDSO: foo:
 // DISASMDSO-NEXT:     1000c: 1f 20 03 d5   nop
 
 // DISASMDSO: Disassembly of section .plt:
 // DISASMDSO-NEXT: .plt:
 // DISASMDSO-NEXT:     10010: f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x3000 + 2 * 8 = 0x3010
-// Page(0x20010) - Page(0x10014) = 0x20000 - 0x10000 = 0x10000 = 65536
-// DISASMDSO-NEXT:     10014: 90 00 00 90   adrp  x16, #65536
+// Page(0x30010) - Page(0x10014) = 0x30000 - 0x10000 = 0x20000 = 131072
+// DISASMDSO-NEXT:     10014: 10 01 00 90   adrp  x16, #131072
 // 0x3010 & 0xFFF = 0x10 = 16
 // DISASMDSO-NEXT:     10018: 11 0a 40 f9 ldr x17, [x16, #16]
 // DISASMDSO-NEXT:     1001c: 10 42 00 91   add x16, x16, #16
 // DISASMDSO-NEXT:     10020: 20 02 1f d6   br  x17
 // DISASMDSO-NEXT:     10024: 1f 20 03 d5   nop
 // DISASMDSO-NEXT:     10028: 1f 20 03 d5   nop
 // DISASMDSO-NEXT:     1002c: 1f 20 03 d5   nop
 
 // foo@plt
-// Page(0x30018) - Page(0x10030) = 0x20000 - 0x10000 = 0x10000 = 65536
+// Page(0x30018) - Page(0x10030) = 0x30000 - 0x10000 = 0x20000 = 131072
 // DISASMDSO-EMPTY:
 // DISASMDSO-NEXT:   foo@plt:
-// DISASMDSO-NEXT:     10030: 90 00 00 90   adrp  x16, #65536
+// DISASMDSO-NEXT:     10030: 10 01 00 90   adrp  x16, #131072
 // 0x3018 & 0xFFF = 0x18 = 24
 // DISASMDSO-NEXT:     10034: 11 0e 40 f9   ldr x17, [x16, #24]
 // DISASMDSO-NEXT:     10038: 10 62 00 91   add x16, x16, #24
 // DISASMDSO-NEXT:     1003c: 20 02 1f d6   br  x17
 
 // bar@plt
-// Page(0x30020) - Page(0x10040) = 0x20000 - 0x10000 = 0x10000 = 65536
+// Page(0x30020) - Page(0x10040) = 0x30000 - 0x10000 = 0x20000 = 131072
 // DISASMDSO-EMPTY:
 // DISASMDSO-NEXT:   bar@plt:
-// DISASMDSO-NEXT:     10040: 90 00 00 90   adrp  x16, #65536
+// DISASMDSO-NEXT:     10040: 10 01 00 90   adrp  x16, #131072
 // 0x3020 & 0xFFF = 0x20 = 32
 // DISASMDSO-NEXT:     10044: 11 12 40 f9   ldr x17, [x16, #32]
 // DISASMDSO-NEXT:     10048: 10 82 00 91   add x16, x16, #32
 // DISASMDSO-NEXT:     1004c: 20 02 1f d6   br  x17
 
 // weak@plt
-// Page(0x30028) - Page(0x10050) = 0x20000 - 0x10000 = 0x10000 = 65536
+// Page(0x30028) - Page(0x10050) = 0x30000 - 0x10000 = 0x20000 = 131072
 // DISASMDSO-EMPTY:
 // DISASMDSO-NEXT:   weak@plt:
-// DISASMDSO-NEXT:     10050: 90 00 00 90   adrp  x16, #65536
+// DISASMDSO-NEXT:     10050: 10 01 00 90   adrp  x16, #131072
 // 0x3028 & 0xFFF = 0x28 = 40
 // DISASMDSO-NEXT:     10054: 11 16 40 f9   ldr x17, [x16, #40]
 // DISASMDSO-NEXT:     10058: 10 a2 00 91   add x16, x16, #40
 // DISASMDSO-NEXT:     1005c: 20 02 1f d6   br  x17
 
 // CHECKEXE:     Name: .plt
 // CHECKEXE-NEXT:     Type: SHT_PROGBITS
 // CHECKEXE-NEXT:     Flags [
 // CHECKEXE-NEXT:       SHF_ALLOC
 // CHECKEXE-NEXT:       SHF_EXECINSTR
 // CHECKEXE-NEXT:     ]
 // CHECKEXE-NEXT:     Address: 0x210010
 // CHECKEXE-NEXT:     Offset:
 // CHECKEXE-NEXT:     Size: 64
 // CHECKEXE-NEXT:     Link:
 // CHECKEXE-NEXT:     Info:
 // CHECKEXE-NEXT:     AddressAlignment: 16
 
 // CHECKEXE:     Name: .got.plt
 // CHECKEXE-NEXT:     Type: SHT_PROGBITS
 // CHECKEXE-NEXT:     Flags [
 // CHECKEXE-NEXT:       SHF_ALLOC
 // CHECKEXE-NEXT:       SHF_WRITE
 // CHECKEXE-NEXT:     ]
-// CHECKEXE-NEXT:     Address: 0x220000
+// CHECKEXE-NEXT:     Address: 0x230000
 // CHECKEXE-NEXT:     Offset:
 // CHECKEXE-NEXT:     Size: 40
 // CHECKEXE-NEXT:     Link:
 // CHECKEXE-NEXT:     Info:
 // CHECKEXE-NEXT:     AddressAlignment: 8
 
 // CHECKEXE: Relocations [
 // CHECKEXE-NEXT:   Section ({{.*}}) .rela.plt {
 
-// &(.got.plt[3]) = 0x220000 + 3 * 8 = 0x220018
-// CHECKEXE-NEXT:     0x220018 R_AARCH64_JUMP_SLOT bar 0x0
+// &(.got.plt[3]) = 0x230000 + 3 * 8 = 0x230018
+// CHECKEXE-NEXT:     0x230018 R_AARCH64_JUMP_SLOT bar 0x0
 
-// &(.got.plt[4]) = 0x220000 + 4 * 8 = 0x220020
-// CHECKEXE-NEXT:     0x220020 R_AARCH64_JUMP_SLOT weak 0x0
+// &(.got.plt[4]) = 0x230000 + 4 * 8 = 0x230020
+// CHECKEXE-NEXT:     0x230020 R_AARCH64_JUMP_SLOT weak 0x0
 // CHECKEXE-NEXT:   }
 // CHECKEXE-NEXT: ]
 
 // DUMPEXE: Contents of section .got.plt:
 // .got.plt[0..2] = 0 (reserved)
 // .got.plt[3..4] = .plt = 0x40010
-// DUMPEXE-NEXT:  220000 00000000 00000000 00000000 00000000
-// DUMPEXE-NEXT:  220010 00000000 00000000 10002100 00000000
-// DUMPEXE-NEXT:  220020 10002100 00000000
+// DUMPEXE-NEXT:  230000 00000000 00000000 00000000 00000000
+// DUMPEXE-NEXT:  230010 00000000 00000000 10002100 00000000
+// DUMPEXE-NEXT:  230020 10002100 00000000
 
 // DISASMEXE: _start:
 // 0x21000c - 0x210000 = 0xc = 12
 // DISASMEXE-NEXT:    210000: 03 00 00 14   b #12
 // 0x210030 - 0x210004 = 0x2c = 44
 // DISASMEXE-NEXT:    210004: 0b 00 00 14   b #44
 // 0x210040 - 0x210008 = 0x38 = 56
 // DISASMEXE-NEXT:    210008: 0e 00 00 14   b #56
 
 // DISASMEXE: foo:
 // DISASMEXE-NEXT:    21000c: 1f 20 03 d5   nop
 
 // DISASMEXE: Disassembly of section .plt:
 // DISASMEXE-NEXT: .plt:
 // DISASMEXE-NEXT:    210010: f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x2200B0 + 2 * 8 = 0x2200C0
-// Page(0x220010) - Page(0x210014) = 0x220000 - 0x210000 = 0x10000 = 65536
-// DISASMEXE-NEXT:    210014: 90 00 00 90   adrp  x16, #65536
+// Page(0x230010) - Page(0x210014) = 0x230000 - 0x210000 = 0x20000 = 131072
+// DISASMEXE-NEXT:    210014: 10 01 00 90   adrp  x16, #131072
 // 0x120c0 & 0xFFF = 0xC0 = 192
 // DISASMEXE-NEXT:    210018: 11 0a 40 f9   ldr x17, [x16, #16]
 // DISASMEXE-NEXT:    21001c: 10 42 00 91   add x16, x16, #16
 // DISASMEXE-NEXT:    210020: 20 02 1f d6   br  x17
 // DISASMEXE-NEXT:    210024: 1f 20 03 d5   nop
 // DISASMEXE-NEXT:    210028: 1f 20 03 d5   nop
 // DISASMEXE-NEXT:    21002c: 1f 20 03 d5   nop
 
 // bar@plt
-// Page(0x40018) - Page(0x210030) = 0x220000 - 0x210000 = 0x10000 = 65536
+// Page(0x230018) - Page(0x210030) = 0x230000 - 0x210000 = 0x20000 = 131072
 // DISASMEXE-EMPTY:
 // DISASMEXE-NEXT:   bar@plt:
-// DISASMEXE-NEXT:    210030: 90 00 00 90   adrp  x16, #65536
+// DISASMEXE-NEXT:    210030: 10 01 00 90   adrp  x16, #131072
 // DISASMEXE-NEXT:    210034: 11 0e 40 f9   ldr x17, [x16, #24]
 // DISASMEXE-NEXT:    210038: 10 62 00 91   add x16, x16, #24
 // DISASMEXE-NEXT:    21003c: 20 02 1f d6   br  x17
 
 // weak@plt
-// Page(0x40020) - Page(0x210040) = 0x220000 - 0x210000 = 0x10000 = 65536
+// Page(0x230020) - Page(0x210040) = 0x230000 - 0x210000 = 0x20000 = 131072
 // DISASMEXE-EMPTY:
 // DISASMEXE-NEXT:   weak@plt:
-// DISASMEXE-NEXT:    210040: 90 00 00 90   adrp  x16, #65536
+// DISASMEXE-NEXT:    210040: 10 01 00 90   adrp  x16, #131072
 // DISASMEXE-NEXT:    210044: 11 12 40 f9   ldr x17, [x16, #32]
 // DISASMEXE-NEXT:    210048: 10 82 00 91   add x16, x16, #32
 // DISASMEXE-NEXT:    21004c: 20 02 1f d6   br  x17
 
 .global _start,foo,bar
 .weak weak
 _start:
   b foo
   b bar
   b weak
 
 .section .text2,"ax",@progbits
 foo:
   nop

lld/trunk/test/ELF/plt-i686.s

 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Name: .got.plt
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x402000
-// CHECK-NEXT: Offset: 0x2000
+// CHECK-NEXT: Address: 0x403000
+// CHECK-NEXT: Offset: 0x3000
 // CHECK-NEXT: Size: 20
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize: 0
 
 // 0x12000 + got.plt.reserved(12) = 0x1200C
 // 0x12000 + got.plt.reserved(12) + 4 = 0x12010
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rel.plt {
-// CHECK-NEXT:     0x40200C R_386_JUMP_SLOT bar 0x0
-// CHECK-NEXT:     0x402010 R_386_JUMP_SLOT zed 0x0
+// CHECK-NEXT:     0x40300C R_386_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x403010 R_386_JUMP_SLOT zed 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
 // 16 is the size of PLT[0]
 // (0x401010 + 16) - (0x401000 + 1) - 4 = 27
 // (0x401010 + 16) - (0x401005 + 1) - 4 = 22
 // (0x401020 + 16) - (0x40100a + 1) - 4 = 33
 
 // DISASM:       local:
 // DISASM-NEXT:  401000: {{.*}}
 // DISASM-NEXT:  401002: {{.*}}
 // DISASM:       _start:
 // 0x401013 + 5 - 24 = 0x401000
 // DISASM-NEXT: 401004: e9 27 00 00 00 jmp 39
 // DISASM-NEXT: 401009: e9 22 00 00 00 jmp 34
 // DISASM-NEXT: 40100e: e9 2d 00 00 00 jmp 45
 // DISASM-NEXT: 401013: e9 e8 ff ff ff jmp -24
 
 // 0x401010 - 0x40102b - 5 = -32
 // 0x401010 - 0x40103b - 5 = -48
-// 4202500 = 0x402004 = .got.plt (0x402000) + 4
-// 4202504 = 0x402008 = .got.plt (0x402000) + 8
-// 4202508 = 0x40200C = .got.plt (0x402000) + got.plt.reserved(12)
-// 4202512 = 0x402010 = .got.plt (0x402000) + got.plt.reserved(12) + 4
+// 4206596 = 0x403004 = .got.plt (0x403000) + 4
+// 4206600 = 0x403008 = .got.plt (0x403000) + 8
+// 4206604 = 0x40300C = .got.plt (0x403000) + got.plt.reserved(12)
+// 4206608 = 0x403010 = .got.plt (0x403000) + got.plt.reserved(12) + 4
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:    401020: ff 35 04 20 40 00 pushl 4202500
-// DISASM-NEXT:    401026: ff 25 08 20 40 00 jmpl *4202504
+// DISASM-NEXT:    401020: ff 35 04 30 40 00 pushl 4206596
+// DISASM-NEXT:    401026: ff 25 08 30 40 00 jmpl *4206600
 // DISASM-NEXT:    40102c: 90 nop
 // DISASM-NEXT:    40102d: 90 nop
 // DISASM-NEXT:    40102e: 90 nop
 // DISASM-NEXT:    40102f: 90 nop
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar@plt:
-// DISASM-NEXT:    401030: ff 25 0c 20 40 00 jmpl *4202508
+// DISASM-NEXT:    401030: ff 25 0c 30 40 00 jmpl *4206604
 // DISASM-NEXT:    401036: 68 00 00 00 00 pushl $0
 // DISASM-NEXT:    40103b: e9 e0 ff ff ff jmp -32 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed@plt:
-// DISASM-NEXT:    401040: ff 25 10 20 40 00 jmpl *4202512
+// DISASM-NEXT:    401040: ff 25 10 30 40 00 jmpl *4206608
 // DISASM-NEXT:    401046: 68 08 00 00 00 pushl $8
 // DISASM-NEXT:    40104b: e9 d0 ff ff ff jmp -48 <.plt>
 
 // CHECKSHARED:        Name: .plt
 // CHECKSHARED-NEXT:   Type: SHT_PROGBITS
 // CHECKSHARED-NEXT:   Flags [
 // CHECKSHARED-NEXT:     SHF_ALLOC
 // CHECKSHARED-NEXT:     SHF_EXECINSTR
 // CHECKSHARED-NEXT:   ]
 // CHECKSHARED-NEXT:   Address: 0x1020
 // CHECKSHARED-NEXT:   Offset: 0x1020
 // CHECKSHARED-NEXT:   Size: 48
 // CHECKSHARED-NEXT:   Link: 0
 // CHECKSHARED-NEXT:   Info: 0
 // CHECKSHARED-NEXT:   AddressAlignment: 16
 // CHECKSHARED-NEXT:   EntrySize: 0
 // CHECKSHARED-NEXT:   }
 // CHECKSHARED:        Name: .got.plt
 // CHECKSHARED-NEXT:   Type: SHT_PROGBITS
 // CHECKSHARED-NEXT:   Flags [
 // CHECKSHARED-NEXT:     SHF_ALLOC
 // CHECKSHARED-NEXT:     SHF_WRITE
 // CHECKSHARED-NEXT:   ]
-// CHECKSHARED-NEXT:   Address: 0x2000
-// CHECKSHARED-NEXT:   Offset: 0x2000
+// CHECKSHARED-NEXT:   Address: 0x3000
+// CHECKSHARED-NEXT:   Offset: 0x3000
 // CHECKSHARED-NEXT:   Size: 20
 // CHECKSHARED-NEXT:   Link: 0
 // CHECKSHARED-NEXT:   Info: 0
 // CHECKSHARED-NEXT:   AddressAlignment: 4
 // CHECKSHARED-NEXT:   EntrySize: 0
 // CHECKSHARED-NEXT:   }
 
-// 0x2000 + got.plt.reserved(12) = 0x200C
-// 0x2000 + got.plt.reserved(12) + 4 = 0x2010
+// 0x3000 + got.plt.reserved(12) = 0x300C
+// 0x3000 + got.plt.reserved(12) + 4 = 0x3010
 // CHECKSHARED:        Relocations [
 // CHECKSHARED-NEXT:     Section ({{.*}}) .rel.plt {
-// CHECKSHARED-NEXT:       0x200C R_386_JUMP_SLOT bar 0x0
-// CHECKSHARED-NEXT:       0x2010 R_386_JUMP_SLOT zed 0x0
+// CHECKSHARED-NEXT:       0x300C R_386_JUMP_SLOT bar 0x0
+// CHECKSHARED-NEXT:       0x3010 R_386_JUMP_SLOT zed 0x0
 // CHECKSHARED-NEXT:     }
 // CHECKSHARED-NEXT:   ]
 
 // DISASMSHARED:       local:
 // DISASMSHARED-NEXT:  1000: {{.*}}
 // DISASMSHARED-NEXT:  1002: {{.*}}
 // DISASMSHARED:       _start:
 // 0x1013 + 5 - 24 = 0x1000
 // DISASMSHARED-NEXT:  1004: e9 27 00 00 00 jmp 39
 // DISASMSHARED-NEXT:  1009: e9 22 00 00 00 jmp 34
 // DISASMSHARED-NEXT:  100e: e9 2d 00 00 00 jmp 45
 // DISASMSHARED-NEXT:  1013: e9 e8 ff ff ff jmp -24
 // DISASMSHARED-NEXT:  Disassembly of section .plt:
 // DISASMSHARED-NEXT:  .plt:
-// DISASMSHARED-NEXT:  1020: ff b3 04 20 00 00 pushl 8196(%ebx)
-// DISASMSHARED-NEXT:  1026: ff a3 08 20 00 00 jmpl *8200(%ebx)
+// DISASMSHARED-NEXT:  1020: ff b3 04 30 00 00 pushl 12292(%ebx)
+// DISASMSHARED-NEXT:  1026: ff a3 08 30 00 00 jmpl *12296(%ebx)
 // DISASMSHARED-NEXT:  102c: 90 nop
 // DISASMSHARED-NEXT:  102d: 90 nop
 // DISASMSHARED-NEXT:  102e: 90 nop
 // DISASMSHARED-NEXT:  102f: 90 nop
-// DISASMSHARED-NEXT:  1030: ff a3 0c 20 00 00 jmpl *8204(%ebx)
+// DISASMSHARED-NEXT:  1030: ff a3 0c 30 00 00 jmpl *12300(%ebx)
 // DISASMSHARED-NEXT:  1036: 68 00 00 00 00     pushl $0
 // DISASMSHARED-NEXT:  103b: e9 e0 ff ff ff     jmp -32 <.plt>
-// DISASMSHARED-NEXT:  1040: ff a3 10 20 00 00 jmpl *8208(%ebx)
+// DISASMSHARED-NEXT:  1040: ff a3 10 30 00 00 jmpl *12304(%ebx)
 // DISASMSHARED-NEXT:  1046: 68 08 00 00 00     pushl $8
 // DISASMSHARED-NEXT:  104b: e9 d0 ff ff ff     jmp -48 <.plt>
 
 // DISASMPIE:      Disassembly of section .plt:
 // DISASMPIE-NEXT: .plt:
-// DISASMPIE-NEXT:   1020:  ff b3 04 20 00 00 pushl 8196(%ebx)
-// DISASMPIE-NEXT:   1026:  ff a3 08 20 00 00 jmpl *8200(%ebx)
+// DISASMPIE-NEXT:   1020:  ff b3 04 30 00 00 pushl 12292(%ebx)
+// DISASMPIE-NEXT:   1026:  ff a3 08 30 00 00 jmpl *12296(%ebx)
 // DISASMPIE-NEXT:   102c:  90 nop
 // DISASMPIE-NEXT:   102d:  90 nop
 // DISASMPIE-NEXT:   102e:  90 nop
 // DISASMPIE-NEXT:   102f:  90 nop
-// DISASMPIE-NEXT:   1030:  ff a3 0c 20 00 00 jmpl *8204(%ebx)
+// DISASMPIE-NEXT:   1030:  ff a3 0c 30 00 00 jmpl *12300(%ebx)
 // DISASMPIE-NEXT:   1036:  68 00 00 00 00 pushl $0
 // DISASMPIE-NEXT:   103b:  e9 e0 ff ff ff jmp -32 <.plt>
-// DISASMPIE-NEXT:   1040:  ff a3 10 20 00 00 jmpl *8208(%ebx)
+// DISASMPIE-NEXT:   1040:  ff a3 10 30 00 00 jmpl *12304(%ebx)
 // DISASMPIE-NEXT:   1046:  68 08 00 00 00 pushl $8
 // DISASMPIE-NEXT:   104b:  e9 d0 ff ff ff jmp -48 <.plt>
 
 local:
 .long 0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp local@plt

lld/trunk/test/ELF/plt.s

 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 64
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT bar 0x0
-// CHECK-NEXT:     0x2020 R_X86_64_JUMP_SLOT zed 0x0
-// CHECK-NEXT:     0x2028 R_X86_64_JUMP_SLOT _start 0x0
+// CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x3020 R_X86_64_JUMP_SLOT zed 0x0
+// CHECK-NEXT:     0x3028 R_X86_64_JUMP_SLOT _start 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK2:      Name: .plt
 // CHECK2-NEXT: Type: SHT_PROGBITS
 // CHECK2-NEXT: Flags [
 // CHECK2-NEXT:   SHF_ALLOC
 // CHECK2-NEXT:   SHF_EXECINSTR
 // CHECK2-NEXT: ]
 // CHECK2-NEXT: Address: 0x201020
 // CHECK2-NEXT: Offset:
 // CHECK2-NEXT: Size: 48
 // CHECK2-NEXT: Link: 0
 // CHECK2-NEXT: Info: 0
 // CHECK2-NEXT: AddressAlignment: 16
 
 // CHECK2:      Relocations [
 // CHECK2-NEXT:   Section ({{.*}}) .rela.plt {
-// CHECK2-NEXT:     0x202018 R_X86_64_JUMP_SLOT bar 0x0
-// CHECK2-NEXT:     0x202020 R_X86_64_JUMP_SLOT zed 0x0
+// CHECK2-NEXT:     0x203018 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK2-NEXT:     0x203020 R_X86_64_JUMP_SLOT zed 0x0
 // CHECK2-NEXT:   }
 // CHECK2-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
 // 0x1030 - (0x1000 + 5) = 43
 // 0x1030 - (0x1005 + 5) = 38
 // 0x1040 - (0x100a + 5) = 49
 // 0x1048 - (0x100a + 5) = 60
 
 // DISASM:      _start:
 // DISASM-NEXT:   1000:  e9 {{.*}}       jmp  43
 // DISASM-NEXT:   1005:  e9 {{.*}}       jmp  38
 // DISASM-NEXT:   100a:  e9 {{.*}}       jmp  49
 // DISASM-NEXT:   100f:  e9 {{.*}}       jmp  60
 
-// 0x2018 - 0x1036  = 4066
-// 0x2020 - 0x1046  = 4058
-// 0x2028 - 0x1056  = 4050
+// 0x3018 - 0x1036  = 8162
+// 0x3020 - 0x1046  = 8154
+// 0x3028 - 0x1056  = 8146
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:   1020:  ff 35 e2 0f 00 00  pushq 4066(%rip)
-// DISASM-NEXT:   1026:  ff 25 e4 0f 00 00  jmpq *4068(%rip)
+// DISASM-NEXT:   1020:  ff 35 e2 1f 00 00  pushq 8162(%rip)
+// DISASM-NEXT:   1026:  ff 25 e4 1f 00 00  jmpq *8164(%rip)
 // DISASM-NEXT:   102c:  0f 1f 40 00        nopl (%rax)
 // DISASM-EMPTY:
 // DISASM-NEXT:   bar@plt:
-// DISASM-NEXT:   1030:  ff 25 e2 0f 00 00  jmpq *4066(%rip)
+// DISASM-NEXT:   1030:  ff 25 e2 1f 00 00  jmpq *8162(%rip)
 // DISASM-NEXT:   1036:  68 00 00 00 00     pushq $0
 // DISASM-NEXT:   103b:  e9 e0 ff ff ff     jmp -32 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   zed@plt:
-// DISASM-NEXT:   1040:  ff 25 da 0f 00 00  jmpq *4058(%rip)
+// DISASM-NEXT:   1040:  ff 25 da 1f 00 00  jmpq *8154(%rip)
 // DISASM-NEXT:   1046:  68 01 00 00 00     pushq $1
 // DISASM-NEXT:   104b:  e9 d0 ff ff ff     jmp -48 <.plt>
 // DISASM-EMPTY:
 // DISASM-NEXT:   _start@plt:
-// DISASM-NEXT:   1050:  ff 25 d2 0f 00 00  jmpq *4050(%rip)
+// DISASM-NEXT:   1050:  ff 25 d2 1f 00 00  jmpq *8146(%rip)
 // DISASM-NEXT:   1056:  68 02 00 00 00     pushq $2
 // DISASM-NEXT:   105b:  e9 c0 ff ff ff     jmp -64 <.plt>
 
 // 0x201030 - (0x201000 + 1) - 4 = 43
 // 0x201030 - (0x201005 + 1) - 4 = 38
 // 0x201040 - (0x20100a + 1) - 4 = 49
 // 0x201000 - (0x20100f + 1) - 4 = -20
 
 // DISASM2:      _start:
 // DISASM2-NEXT:   201000:  e9 {{.*}}     jmp  43
 // DISASM2-NEXT:   201005:  e9 {{.*}}     jmp  38
 // DISASM2-NEXT:   20100a:  e9 {{.*}}     jmp  49
 // DISASM2-NEXT:   20100f:  e9 {{.*}}     jmp  -20
 
 // 0x202018 - 0x201036  = 4066
 // 0x202020 - 0x201046  = 4058
 
 // DISASM2:      Disassembly of section .plt:
 // DISASM2-NEXT: .plt:
-// DISASM2-NEXT:  201020:  ff 35 e2 0f 00 00   pushq 4066(%rip)
-// DISASM2-NEXT:  201026:  ff 25 e4 0f 00 00   jmpq *4068(%rip)
+// DISASM2-NEXT:  201020:  ff 35 e2 1f 00 00   pushq 8162(%rip)
+// DISASM2-NEXT:  201026:  ff 25 e4 1f 00 00   jmpq *8164(%rip)
 // DISASM2-NEXT:  20102c:  0f 1f 40 00         nopl  (%rax)
 // DISASM2-EMPTY:
 // DISASM2-NEXT:   bar@plt:
-// DISASM2-NEXT:  201030:  ff 25 e2 0f 00 00   jmpq *4066(%rip)
+// DISASM2-NEXT:  201030:  ff 25 e2 1f 00 00   jmpq *8162(%rip)
 // DISASM2-NEXT:  201036:  68 00 00 00 00      pushq $0
 // DISASM2-NEXT:  20103b:  e9 e0 ff ff ff      jmp -32 <.plt>
 // DISASM2-EMPTY:
 // DISASM2-NEXT:   zed@plt:
-// DISASM2-NEXT:  201040:  ff 25 da 0f 00 00   jmpq *4058(%rip)
+// DISASM2-NEXT:  201040:  ff 25 da 1f 00 00   jmpq *8154(%rip)
 // DISASM2-NEXT:  201046:  68 01 00 00 00      pushq $1
 // DISASM2-NEXT:  20104b:  e9 d0 ff ff ff      jmp -48 <.plt>
 // DISASM2-NOT:   2010C0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

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

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-freebsd %s -o %t
 # RUN: ld.lld %t -o %t2 -shared
 # RUN: llvm-readobj -r %t2 | FileCheck %s
 
 .data
   .long foo
 
 // CHECK:      Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:   0x1000 R_PPC_ADDR32 foo 0x0
+// CHECK-NEXT:   0x2000 R_PPC_ADDR32 foo 0x0
 // CHECK-NEXT: }

lld/trunk/test/ELF/ppc64-call-reach.s

 # CHECK:  10010024: {{.*}}  b  .+33554428
 
 # NEGOFFSET-LABEL: test
 # NEGOFFSET:  10010014: {{.*}}  bl .-33554432
 # NEGOFFSET:  10010024: {{.*}}  b  .+33554432
 
 # .branch_lt[0]
 # THUNK-LABEL: __long_branch_callee:
-# THUNK-NEXT: 10010000: {{.*}} addis 12, 2, -1
+# THUNK-NEXT: 10010000: {{.*}} addis 12, 2, 1
 # THUNK-NEXT:                  ld 12, -32768(12)
 # THUNK-NEXT:                  mtctr 12
 # THUNK-NEXT:                  bctr
 
 # .branch_lt[1]
 # THUNK-LABEL: __long_branch_tail_callee:
-# THUNK-NEXT: 10010010: {{.*}} addis 12, 2, -1
+# THUNK-NEXT: 10010010: {{.*}} addis 12, 2, 1
 # THUNK-NEXT:                  ld 12, -32760(12)
 # THUNK-NEXT:                  mtctr 12
 # THUNK-NEXT:                  bctr
 
 # Each call now branches to a thunk, and although it is printed as positive
 # the offset is interpreted as a signed 26 bit value so 67108812 is actually
 # -52.
 # THUNK-LABEL: test:
 # THUNK: 10010034: {{.*}}  bl .-52
 # THUNK: 10010044: {{.*}}  b .+67108812
 
 # The offset from the TOC to the .branch_lt section  is (-1 << 16) - 32768.
 #                Name             Type            Address          Off    Size
-# BRANCHLT:     .branch_lt        PROGBITS        0000000010020000 020000 000010
-# BRANCHLT:     .got              PROGBITS        0000000010030000 030000 000008
+# BRANCHLT:     .got              PROGBITS        0000000010020000 020000 000008
+# BRANCHLT:     .branch_lt        PROGBITS        0000000010030000 030000 000010
 # BRANCHLT-NOT: .plt
 

lld/trunk/test/ELF/ppc64-func-entry-points.s

 # Check that foo_external_diff has a global entry point and we branch to
 # foo_external_diff+8. Also check that foo_external_same has no global entry
 # point and we branch to start of foo_external_same.
 
 // CHECK: _start:
 // CHECK: 10010020:       {{.*}}     bl .+144
 // CHECK: 10010034:       {{.*}}     bl .+84
 // CHECK: foo_external_diff:
-// CHECK-NEXT: 10010080:       {{.*}}     addis 2, 12, 2
+// CHECK-NEXT: 10010080:       {{.*}}     addis 2, 12, 1
 // CHECK-NEXT: 10010084:       {{.*}}     addi 2, 2, 32640
 // CHECK-NEXT: 10010088:       {{.*}}     nop
 // CHECK: foo_external_same:
 // CHECK-NEXT: 100100b0:       {{.*}}     add 3, 4, 3

lld/trunk/test/ELF/ppc64-got-indirect.s

 # RELOCS-BE:]
 
 # Verify that the global variable access is done through the correct
 # toc entry:
 # r2 = .TOC. = 0x10038000.
 # r3 = r2 - 32760 = 0x10030008 -> .toc entry for glob.
 
 # CHECK: _start:
-# CHECK-NEXT: 10010000:  {{.*}}   addis 2, 12, 3
+# CHECK-NEXT: 10010000:  {{.*}}   addis 2, 12, 2
 # CHECK-NEXT: 10010004:  {{.*}}   addi 2, 2, -32768
 # CHECK-NEXT: 10010008:  {{.*}}   nop
 # CHECK-NEXT: 1001000c:  {{.*}}   ld 3, -32760(2)
 # CHECK: 1001001c:  {{.*}}   lwa 3, 0(3)
 
-# CHECK-LE: Disassembly of section .data:
-# CHECK-LE-NEXT: glob:
-# CHECK-LE-NEXT: 10020000:       37 00 00 00
-
 # CHECK-LE: Disassembly of section .got:
 # CHECK-LE-NEXT: .got:
-# CHECK-LE-NEXT: 10030000:       00 80 03 10
-# CHECK-LE-NEXT: 10030004:       00 00 00 00
+# CHECK-LE-NEXT: 10020000:       00 80 02 10
+# CHECK-LE-NEXT: 10020004:       00 00 00 00
 
 # Verify that .toc comes right after .got
 # CHECK-LE: Disassembly of section .toc:
-# CHECK-LE: 10030008:       00 00 02 10
+# CHECK-LE: 10020008:       00 00 03 10
 
-# CHECK-BE: Disassembly of section .data:
-# CHECK-BE-NEXT: glob:
-# CHECK-BE-NEXT: 10020000:       00 00 00 37
+# CHECK-LE: Disassembly of section .data:
+# CHECK-LE-NEXT: glob:
+# CHECK-LE-NEXT: 10030000:       37 00 00 00
 
 # CHECK-BE: Disassembly of section .got:
 # CHECK-BE-NEXT: .got:
-# CHECK-BE-NEXT: 10030000:       00 00 00 00
-# CHECK-BE-NEXT: 10030004:       10 03 80 00
+# CHECK-BE-NEXT: 10020000:       00 00 00 00
+# CHECK-BE-NEXT: 10020004:       10 02 80 00
 
 # Verify that .toc comes right after .got
 # CHECK-BE: Disassembly of section .toc:
-# CHECK-BE: 10030008:       00 00 00 00
-# CHECK-BE: 1003000c:       10 02 00 00
+# CHECK-BE: 10020008:       00 00 00 00
+# CHECK-BE: 1002000c:       10 03 00 00
+
+# CHECK-BE: Disassembly of section .data:
+# CHECK-BE-NEXT: glob:
+# CHECK-BE-NEXT: 10030000:       00 00 00 37

lld/trunk/test/ELF/ppc64-long-branch.s

 # REQUIRES: ppc
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-func-global-entry.s -o %t2.o
 # RUN: ld.lld  -shared %t2.o  -o %t3.so
 # RUN: ld.lld --no-toc-optimize %t.o %t3.so -o %t
 # RUN: llvm-objdump -d -start-address=0x10010000 -stop-address=0x10010018 %t | FileCheck %s -check-prefix=CALLEE_DUMP
 # RUN: llvm-objdump -d -start-address=0x12010020 -stop-address=0x12010084 %t | FileCheck %s -check-prefix=CALLER_DUMP
-# RUN: llvm-objdump -D -start-address=0x12020008 -stop-address=0x12020010 %t | FileCheck %s -check-prefix=BRANCH_LT_LE
+# RUN: llvm-objdump -D -start-address=0x12030008 -stop-address=0x12030010 %t | FileCheck %s -check-prefix=BRANCH_LT_LE
 # RUN: llvm-readelf --sections %t | FileCheck %s -check-prefix=SECTIONS
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-func-global-entry.s -o %t2.o
 # RUN: ld.lld  -shared %t2.o  -o %t3.so
 # RUN: ld.lld --no-toc-optimize %t.o %t3.so -o %t
 # RUN: llvm-objdump -d -start-address=0x10010000 -stop-address=0x10010018 %t | FileCheck %s -check-prefix=CALLEE_DUMP
 # RUN: llvm-objdump -d -start-address=0x12010020 -stop-address=0x12010084 %t | FileCheck %s -check-prefix=CALLER_DUMP
-# RUN: llvm-objdump -D -start-address=0x12020008 -stop-address=0x12020010 %t | FileCheck %s -check-prefix=BRANCH_LT_BE
+# RUN: llvm-objdump -D -start-address=0x12030008 -stop-address=0x12030010 %t | FileCheck %s -check-prefix=BRANCH_LT_BE
 # RUN: llvm-readelf --sections %t | FileCheck %s -check-prefix=SECTIONS
 
         .text
         .abiversion 2
         .protected callee
         .globl callee
         .p2align 4
         .type callee,@function
a:
         .global b
         .p2align 2
 b:
         .long 33
         .size b, 4
 
 # Verify address of the callee
 # CALLEE_DUMP: callee:
-# CALLEE_DUMP:   10010000:  {{.*}}  addis 2, 12, 515
+# CALLEE_DUMP:   10010000:  {{.*}}  addis 2, 12, 514
 # CALLEE_DUMP:   10010004:  {{.*}}  addi 2, 2, -32544
 # CALLEE_DUMP:   10010008:  {{.*}}  addis 4, 2, 0
 
 # Verify the address of _start, and the call to the long-branch thunk.
 # CALLER_DUMP: _start:
-# CALLER_DUMP:   12010020:  {{.*}}  addis 2, 12, 3
+# CALLER_DUMP:   12010020:  {{.*}}  addis 2, 12, 2
 # CALLER_DUMP:   12010038:  {{.*}}  bl .+56
 
 # Verify the thunks contents: TOC-pointer + offset = .branch_lt[0]
 #                             0x120380e8  + (-2 << 16 + 32552) = 0x12020008
 # CALLER_DUMP: __long_branch_callee:
-# CALLER_DUMP:   12010060:  {{.*}}  addis 12, 2, -2
+# CALLER_DUMP:   12010060:  {{.*}}  addis 12, 2, 0
 # CALLER_DUMP:   12010064:  {{.*}}  ld 12, 32552(12)
 # CALLER_DUMP:   12010068:  {{.*}}  mtctr 12
 # CALLER_DUMP:   1201006c:  {{.*}}  bctr
 
 # BRANCH_LT_LE:     Disassembly of section .branch_lt:
 # BRANCH_LT_LE-NEXT:  .branch_lt:
-# BRANCH_LT_LE-NEXT:  12020008:   08 00 01 10
-# BRANCH_LT_LE-NEXT:  1202000c:   00 00 00 00
+# BRANCH_LT_LE-NEXT:  12030008:   08 00 01 10
+# BRANCH_LT_LE-NEXT:  1203000c:   00 00 00 00
 
 # BRANCH_LT_BE:     Disassembly of section .branch_lt:
 # BRANCH_LT_BE-NEXT:  .branch_lt:
-# BRANCH_LT_BE-NEXT:  12020008:   00 00 00 00
-# BRANCH_LT_BE-NEXT:  1202000c:   10 01 00 08
+# BRANCH_LT_BE-NEXT:  12030008:   00 00 00 00
+# BRANCH_LT_BE-NEXT:  1203000c:   10 01 00 08
 
 #            [Nr] Name        Type            Address          Off     Size
-# SECTIONS:  [ 9] .branch_lt  PROGBITS        0000000012020008 2020008 000008
-# SECTIONS:  [11] .got        PROGBITS        00000000120300e0 20300e0 000008
+# SECTIONS:  [ 9] .got        PROGBITS        00000000120200e0 20200e0 000008
+# SECTIONS:  [12] .branch_lt  PROGBITS        0000000012030008 2030008 000008

lld/trunk/test/ELF/ppc64-shared-long_branch.s

a:
         .globl b
         .p2align 2
 b:
         .long 33
         .size b, 4
 
 # Verify address of the callee
 # CALLEE_DUMP: callee:
-# CALLEE_DUMP:   10000:  {{.*}}  addis 2, 12, 515
+# CALLEE_DUMP:   10000:  {{.*}}  addis 2, 12, 514
 # CALLEE_DUMP:   10004:  {{.*}}  addi 2, 2, -32528
 # CALLEE_DUMP:   10008:  {{.*}}  addis 4, 2, 0
 
 # Verify the address of _start, and the call to the long-branch thunk.
 # CALLER_DUMP: _start:
-# CALLER_DUMP:   2010020:  {{.*}}  addis 2, 12, 3
+# CALLER_DUMP:   2010020:  {{.*}}  addis 2, 12, 2
 # CALLER_DUMP:   2010038:  {{.*}}  bl .+56
 
 # Verify the thunks contents: TOC-pointer + offset = .branch_lt[0]
-#                             0x20380F0   + 32552  = 0x2040018
+#                             0x20280F0   + 32560  = 0x2030020
 # CALLER_DUMP: __long_branch_callee:
 # CALLER_DUMP:   2010060:  {{.*}}  addis 12, 2, 0
-# CALLER_DUMP:   2010064:  {{.*}}  ld 12, 32552(12)
+# CALLER_DUMP:   2010064:  {{.*}}  ld 12, 32560(12)
 # CALLER_DUMP:   2010068:  {{.*}}  mtctr 12
 # CALLER_DUMP:   201006c:  {{.*}}  bctr
 
 # .got section is at address 0x20300f0 so TOC pointer points to 0x20400F0.
 # .plt section has a 2 entry header and a single entry for the long branch.
 #            [Nr] Name        Type            Address          Off     Size
-# SECTIONS:  [11] .got        PROGBITS        00000000020300f0 20300f0 000008
-# SECTIONS:  [13] .plt        NOBITS          0000000002040000 2030108 000018
-# SECTIONS:  [14] .branch_lt  NOBITS          0000000002040018 2030108 000008
+# SECTIONS:  [10] .got        PROGBITS        00000000020200f0 20200f0 000008
+# SECTIONS:  [13] .plt        NOBITS          0000000002030008 2030008 000018
+# SECTIONS:  [14] .branch_lt  NOBITS          0000000002030020 2030008 000008
 
 # There is a relative dynamic relocation for (.plt + 16 bytes), with a base
 # address equal to callees local entry point (0x10000 + 8).
 # DYNRELOC: Relocation section '.rela.dyn' at offset 0x{{[0-9a-f]+}} contains 3 entries:
 # DYNRELOC:    Offset             Info             Type               Symbol's Value
-# DYNRELOC:    0000000002040018   0000000000000016 R_PPC64_RELATIVE   10008
+# DYNRELOC:    0000000002030020   0000000000000016 R_PPC64_RELATIVE   10008

lld/trunk/test/ELF/ppc64-toc-rel.s

 # Want to check _start for the values used to build the offset from the TOC base
 # to global_a. The .TOC. symbol is expected at address 0x10030000, and the
 # TOC base is address-of(.TOC.) + 0x8000.  The expected offset is:
 # 0x10020000(global_a) - 0x10038000(Toc base) = -0x18000(Offset)
 # which gets materialized into r3 as ((-1 << 16) - 32768).
 
 # CHECK:      Disassembly of section .text:
 # CHECK-NEXT: _start:
-# CHECK:      10010008:       {{.*}}     addis 3, 2, -1
+# CHECK:      10010008:       {{.*}}     addis 3, 2, 1
 # CHECK-NEXT: 1001000c:       {{.*}}     addi 3, 3, -32768
 
 # CHECK:      Disassembly of section .data:
 # CHECK-NEXT: global_a:
-# CHECK-NEXT: 10020000:       {{.*}}
+# CHECK-NEXT: 10030000:       {{.*}}
 
 # CHECK-LE:      Disassembly of section .got:
 # CHECK-LE-NEXT: .got:
-# CHECK-LE-NEXT: 10030000:       00 80 03 10
+# CHECK-LE-NEXT: 10020000:       00 80 02 10
 
 # CHECK-BE:      Disassembly of section .got:
 # CHECK-BE-NEXT: .got:
-# CHECK-BE-NEXT: 10030000:       00 00 00 00
-# CHECK-BE-NEXT: 10030004:       10 03 80 00
+# CHECK-BE-NEXT: 10020000:       00 00 00 00
+# CHECK-BE-NEXT: 10020004:       10 02 80 00

lld/trunk/test/ELF/pr34660.s

 # REQUIRES: aarch64
 
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-none %s -o %t.o
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t
 # RUN: llvm-objdump %t -d | FileCheck %s --check-prefix=DISASM
 # RUN: llvm-readelf %t --symbols | FileCheck %s --check-prefix=SYM
 
 # It would be much easier to understand/read this test if llvm-objdump would print
 # the immediates in hex.
 # IMM = hex(65540) = 0x10004
 # PC = 0x10000
 # As the relocation is PC-relative, IMM + PC = 0x20004 which is the VA of the
 # correct symbol.
 
 # DISASM: Disassembly of section .text:
 # DISASM-NEXT: $x.0:
-# DISASM-NEXT:   10000:       28 00 08 58     ldr     x8, #65540
+# DISASM-NEXT:   10000:       28 00 10 58     ldr     x8, #131076
 
 # SYM: Symbol table '.symtab'
-# SYM:  0000000000020004     0 NOTYPE  LOCAL  DEFAULT    5 patatino
+# SYM:  0000000000030004     0 NOTYPE  LOCAL  DEFAULT    6 patatino
 
   ldr x8, patatino
   .data
   .zero 4
 patatino:

lld/trunk/test/ELF/rel-offset.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -shared
 // RUN: llvm-readobj -r  %t | FileCheck %s
 
         .section        .data.foo,"aw",@progbits
         .quad   foo
 
         .section        .data.zed,"aw",@progbits
         .quad   foo
 
 // CHECK:      Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:   0x1000 R_X86_64_64 foo 0x0
-// CHECK-NEXT:   0x1008 R_X86_64_64 foo 0x0
+// CHECK-NEXT:   0x2000 R_X86_64_64 foo 0x0
+// CHECK-NEXT:   0x2008 R_X86_64_64 foo 0x0
 // CHECK-NEXT: }

lld/trunk/test/ELF/relative-dynamic-reloc-pie.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld -pie %t.o -o %t.pie
 # RUN: llvm-readobj -r -dyn-symbols %t.pie | FileCheck %s
 
 ## Test that we create R_X86_64_RELATIVE relocations with -pie.
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-# CHECK-NEXT:     0x2000 R_X86_64_RELATIVE - 0x2000
-# CHECK-NEXT:     0x2008 R_X86_64_RELATIVE - 0x2008
-# CHECK-NEXT:     0x2010 R_X86_64_RELATIVE - 0x2009
+# CHECK-NEXT:     0x3000 R_X86_64_RELATIVE - 0x3000
+# CHECK-NEXT:     0x3008 R_X86_64_RELATIVE - 0x3008
+# CHECK-NEXT:     0x3010 R_X86_64_RELATIVE - 0x3009
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 .globl _start
 _start:
 nop
 
  .data
 foo:
  .quad foo
 
 .hidden bar
 .global bar
 bar:
  .quad bar
  .quad bar + 1

lld/trunk/test/ELF/relative-dynamic-reloc-ppc64.s

 // REQUIRES: ppc
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 
 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 
 // Test that we create R_PPC64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x[[FOO_ADDR:.*]] R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x[[BAR_ADDR:.*]] R_PPC64_RELATIVE - 0x[[BAR_ADDR]]
-// CHECK-NEXT:     0x10010 R_PPC64_RELATIVE - 0x10009
+// CHECK-NEXT:     0x20010 R_PPC64_RELATIVE - 0x20009
 // CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[ZED_ADDR:.*]]
 // CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
-// CHECK-NEXT:     0x10028 R_PPC64_ADDR64 external 0x0
+// CHECK-NEXT:     0x20028 R_PPC64_ADDR64 external 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK:        Name: foo
 // CHECK-NEXT:   Value: 0x[[FOO_ADDR]]
 // CHECK:        Name: bar
 // CHECK-NEXT:   Value: 0x[[BAR_ADDR]]

lld/trunk/test/ELF/relative-dynamic-reloc.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 
 // Test that we create R_X86_64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x[[FOO_ADDR:.*]] R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x[[BAR_ADDR:.*]] R_X86_64_RELATIVE - 0x[[BAR_ADDR]]
-// CHECK-NEXT:     0x1010 R_X86_64_RELATIVE - 0x1009
+// CHECK-NEXT:     0x2010 R_X86_64_RELATIVE - 0x2009
 // CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[ZED_ADDR:.*]]
 // CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
-// CHECK-NEXT:     0x1028 R_X86_64_64 external 0x0
+// CHECK-NEXT:     0x2028 R_X86_64_64 external 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK:        Name: foo
 // CHECK-NEXT:   Value: 0x[[FOO_ADDR]]
 // CHECK:        Name: bar
 // CHECK-NEXT:   Value: 0x[[BAR_ADDR]]

lld/trunk/test/ELF/relocation-copy-flags.s

 // CHECK-NEXT: Address: 0x201000
 // CHECK-NEXT: Offset: 0x1000
 // CHECK-NEXT: Size: 8
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 00402000
+// CHECK-NEXT:   0000: 10302000
 // CHECK-NEXT: )
 
 // CHECK:      Name: bar
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x202000
-// CHECK-NEXT: Offset: 0x2000
+// CHECK-NEXT: Address: 0x203000
+// CHECK-NEXT: Offset: 0x3000
 // 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: 00000000
 // CHECK-NEXT: )
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x0
-// CHECK-NEXT: Offset: 0x30B0
+// CHECK-NEXT: Offset: 0x3008
 // 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: 00000000
 // CHECK-NEXT: )
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rela.dyn {
-// CHECK-NEXT:     0x204000 R_X86_64_COPY x 0x0
-// CHECK-NEXT:     0x202000 R_X86_64_64 z 0x0
+// CHECK-NEXT:     0x203010 R_X86_64_COPY x 0x0
+// CHECK-NEXT:     0x203000 R_X86_64_64 z 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

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

 // ADDR-NEXT: Size: 32
 
 // ADDR:      Name: .got (
 // ADDR-NEXT: Type: SHT_PROGBITS
 // ADDR-NEXT: Flags [
 // ADDR-NEXT:   SHF_ALLOC
 // ADDR-NEXT:   SHF_WRITE
 // ADDR-NEXT: ]
-// ADDR-NEXT: Address: 0x403078
+// ADDR-NEXT: Address: 0x402078
 // ADDR-NEXT: Offset:
 // ADDR-NEXT: Size: 8
 
 .section .R_386_GOTPC,"ax",@progbits
 R_386_GOTPC:
  movl $_GLOBAL_OFFSET_TABLE_, %eax
 
-// 0x402078 + 8 - 0x401014 = 4204
+// 0x402078 + 8 - 0x401014 = 8300
 
 // CHECK:      Disassembly of section .R_386_GOTPC:
 // CHECK-NEXT: R_386_GOTPC:
-// CHECK-NEXT:   401014:  {{.*}} movl  $8300, %eax
+// CHECK-NEXT:   401014:  {{.*}} movl  $4204, %eax
 
 .section .dynamic_reloc, "ax",@progbits
  call bar
 // addr(.plt) + 16 - (0x401019 + 5) = 50
 // CHECK:      Disassembly of section .dynamic_reloc:
 // CHECK-NEXT: .dynamic_reloc:
 // CHECK-NEXT:   401019:  e8 32 00 00 00 calll 50
 

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

 // RUN: llvm-readobj -s -section-data -r %t2 | FileCheck -check-prefix CHECK -check-prefix NOAPPLYDYNREL %s
 
 // APPLYDYNREL:      Name: .data
 // APPLYDYNREL-NEXT: Type: SHT_PROGBITS
 // APPLYDYNREL-NEXT: Flags [
 // APPLYDYNREL-NEXT:   SHF_ALLOC
 // APPLYDYNREL-NEXT:   SHF_WRITE
 // APPLYDYNREL-NEXT: ]
-// APPLYDYNREL-NEXT: Address: 0x1000
-// APPLYDYNREL-NEXT: Offset: 0x1000
+// APPLYDYNREL-NEXT: Address: 0x2000
+// APPLYDYNREL-NEXT: Offset: 0x2000
 // APPLYDYNREL-NEXT: Size: 16
 // APPLYDYNREL-NEXT: Link: 0
 // APPLYDYNREL-NEXT: Info: 0
 // APPLYDYNREL-NEXT: AddressAlignment: 1
 // APPLYDYNREL-NEXT: EntrySize: 0
 // APPLYDYNREL-NEXT: SectionData (
-// APPLYDYNREL-NEXT:   0000: 00100000 00000000 00000000 00000000
+// APPLYDYNREL-NEXT:   0000: 00200000 00000000 00000000 00000000
 // APPLYDYNREL-NEXT: )
 
 // NOAPPLYDYNREL:      Name: .data
 // NOAPPLYDYNREL-NEXT: Type: SHT_PROGBITS
 // NOAPPLYDYNREL-NEXT: Flags [
 // NOAPPLYDYNREL-NEXT:   SHF_ALLOC
 // NOAPPLYDYNREL-NEXT:   SHF_WRITE
 // NOAPPLYDYNREL-NEXT: ]
-// NOAPPLYDYNREL-NEXT: Address: 0x1000
-// NOAPPLYDYNREL-NEXT: Offset: 0x1000
+// NOAPPLYDYNREL-NEXT: Address: 0x2000
+// NOAPPLYDYNREL-NEXT: Offset: 0x2000
 // NOAPPLYDYNREL-NEXT: Size: 16
 // NOAPPLYDYNREL-NEXT: Link: 0
 // NOAPPLYDYNREL-NEXT: Info: 0
 // NOAPPLYDYNREL-NEXT: AddressAlignment: 1
 // NOAPPLYDYNREL-NEXT: EntrySize: 0
 // NOAPPLYDYNREL-NEXT: SectionData (
 // NOAPPLYDYNREL-NEXT:   0000: 00000000 00000000 00000000 00000000
 // NOAPPLYDYNREL-NEXT: )
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT:    Flags [
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x0
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 1
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 00100000 00000000 00100000 00000000
-// CHECK-NEXT:   0010: 00100000 00000000 00100000 00000000
+// CHECK-NEXT:   0000: 00200000 00000000 00200000 00000000
+// CHECK-NEXT:   0010: 00200000 00000000 00200000 00000000
 // CHECK-NEXT: )
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.}}) .rela.dyn {
-// CHECK-NEXT:     0x1000 R_X86_64_RELATIVE - 0x1000
-// CHECK-NEXT:     0x1008 R_X86_64_64 zed 0x0
+// CHECK-NEXT:     0x2000 R_X86_64_RELATIVE - 0x2000
+// CHECK-NEXT:     0x2008 R_X86_64_64 zed 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 .data
         .global zed
 zed:
 bar:
         .quad bar

lld/trunk/test/ELF/relocation-relative-weak.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t -pie
 # RUN: llvm-readobj -dyn-relocations %t | FileCheck %s
 
 # CHECK:      Dynamic Relocations {
-# CHECK-NEXT:   0x2018 R_X86_64_JUMP_SLOT w 0x0
+# CHECK-NEXT:   0x3018 R_X86_64_JUMP_SLOT w 0x0
 # CHECK-NEXT: }
 
 .globl _start
 _start:
 
 .globl w
 .weak w
 call w@PLT

lld/trunk/test/ELF/relocation.s

 // SEC-NEXT: Flags [
 // SEC-NEXT:   SHF_ALLOC
 // SEC-NEXT:   SHF_EXECINSTR
 // SEC-NEXT: ]
 // SEC-NEXT: Address: 0x201030
 // SEC-NEXT: Offset: 0x1030
 // SEC-NEXT: Size: 48
 
-// SEC:        Name: .got.plt
+// SEC:         Name: .got
 // SEC-NEXT:   Type: SHT_PROGBITS
 // SEC-NEXT:   Flags [
 // SEC-NEXT:     SHF_ALLOC
 // SEC-NEXT:     SHF_WRITE
 // SEC-NEXT:   ]
-// SEC-NEXT:   Address: 0x202000
-// SEC-NEXT:   Offset: 0x2000
-// SEC-NEXT:   Size: 40
+// SEC-NEXT:   Address: 0x2020F0
+// SEC-NEXT:   Offset:
+// SEC-NEXT:   Size: 8
 // SEC-NEXT:   Link: 0
 // SEC-NEXT:   Info: 0
 // SEC-NEXT:   AddressAlignment: 8
 // SEC-NEXT:   EntrySize: 0
-// SEC-NEXT:   }
+// SEC-NEXT: }
 
-// SEC:         Name: .got
+// SEC:        Name: .got.plt
 // SEC-NEXT:   Type: SHT_PROGBITS
 // SEC-NEXT:   Flags [
 // SEC-NEXT:     SHF_ALLOC
 // SEC-NEXT:     SHF_WRITE
 // SEC-NEXT:   ]
-// SEC-NEXT:   Address: 0x2030F0
-// SEC-NEXT:   Offset:
-// SEC-NEXT:   Size: 8
+// SEC-NEXT:   Address: 0x203000
+// SEC-NEXT:   Offset: 0x3000
+// SEC-NEXT:   Size: 40
 // SEC-NEXT:   Link: 0
 // SEC-NEXT:   Info: 0
 // SEC-NEXT:   AddressAlignment: 8
 // SEC-NEXT:   EntrySize: 0
-// SEC-NEXT: }
+// SEC-NEXT:   }
 
 .section       .text,"ax",@progbits,unique,1
 .global _start
 _start:
   call lulz
 
 .section       .text,"ax",@progbits,unique,2
 .zero 4

 // CHECK:      Contents of section .R_X86_64_64:
 // CHECK-NEXT:   2002c0 c0022000 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
-// 0x2030F0(.got) - 0x2002c8(.R_X86_64_GOTPCREL) = 0x2e28
+// 0x2020F0(.got) - 0x2002c8(.R_X86_64_GOTPCREL) = 0x1e28
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   2002c8 282e0000
+// CHECK-NEXT:   2002c8 281e0000
 
 .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-non-contiguous.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/copy-in-shared.s -o %t2.o
 // RUN: ld.lld -shared %t.o %t2.o -o %t.so
 
-// Place the .got.plt (non relro) immediately after .dynamic. This is the
-// reverse order of the non-linker script case. The linker created .bss.rel.ro
-// section will be placed after .got.plt causing the relro to be non-contiguous.
+// Separate RelRo sections .dynamic .bss.rel.ro with non RelRo .got.plt.
+// This causes the RelRo sections to be non-contiguous.
 // RUN: echo "SECTIONS { \
 // RUN: .dynamic : { *(.dynamic) } \
 // RUN: .got.plt : { *(.got.plt) } \
+// RUN: .bss.rel.ro : { *(.bss.rel.o) } \
 // RUN: } " > %t.script
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t3.o
 
 // Expect error for non-contiguous relro
 // RUN: not ld.lld %t3.o %t.so -z relro -o %t --script=%t.script 2>&1 | FileCheck %s
 // No error when we do not request relro.
 // RUN: ld.lld %t3.o %t.so -z norelro -o %t --script=%t.script
 

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

 .section d,"ax",@nobits
 .section c,"ax"
 .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
 // CHECK: Name: l
 
-// Writable sections appear before TLS and other relro sections.
-// CHECK: Name: i
-
 // TLS sections are only sorted on NOBITS.
 // CHECK: Name: e
 // CHECK: Name: g
 
+// Writable sections appear after TLS and other relro sections.
+// CHECK: Name: i
+
 // CHECK: Name: j
 
 // Non allocated sections are in input order.
 // CHECK: Name: t
 // CHECK: Name: s
 // CHECK: Name: r
 // CHECK: Name: q
 // CHECK: Name: p
 // CHECK: Name: o
 // CHECK: Name: n
 // CHECK: Name: m

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

 .section .gcc_except_table.foo,"aG",@progbits,foo,comdat
 .byte 0
 .section .tdata.foo,"aGwT",@progbits,foo,comdat
 .byte 0
 
 // CHECK:  1 .rodata  00000002
 // CHECK:  2 .gcc_except_table 00000001
 // CHECK:  3 .text         00000002
-// CHECK:  4 .data         00000002
-// CHECK:  5 .foo.a        00000001
-// CHECK:  6 .foo          00000001
-// CHECK:  7 .tdata        00000001
-// CHECK:  8 .tbss         00000001
-// CHECK:  9 .data.rel.ro  00000004
+// CHECK:  4 .tdata        00000001
+// CHECK:  5 .tbss         00000001
+// CHECK:  6 .data.rel.ro  00000004
+// CHECK:  7 .data         00000002
+// CHECK:  8 .foo.a        00000001
+// CHECK:  9 .foo          00000001
 // CHECK: 10 .bss          00000002
 // CHECK: 11 .comment      00000008
 // CHECK: 12 .symtab       00000030
 // CHECK: 13 .shstrtab     00000075
 // CHECK: 14 .strtab       00000008

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: .hash    {{.*}}   A
 # CHECK-NEXT: .dynstr  {{.*}}   A
 # CHECK-NEXT: .text    {{.*}}   AX
-# CHECK-NEXT: foo      {{.*}}  WA
 # CHECK-NEXT: .dynamic {{.*}}  WA
+# CHECK-NEXT: foo      {{.*}}  WA
 
 .section foo, "aw"
 .byte 0

lld/trunk/test/ELF/startstop.s

 // SYMBOL:   Name: __stop_foo
 // SYMBOL:   Value: 0x1012
 // SYMBOL:   STV_HIDDEN
 // SYMBOL:   Section: foo
 // SYMBOL: }
 
 // SYMBOL: Symbol {
 // SYMBOL:   Name: __stop_zed1
-// SYMBOL:   Value: 0x2010
+// SYMBOL:   Value: 0x3010
 // SYMBOL:   STV_PROTECTED
 // SYMBOL:   Section: zed1
 // SYMBOL: }
 // SYMBOL: Symbol {
 // SYMBOL:   Name: __stop_zed2
-// SYMBOL:   Value: 0x2020
+// SYMBOL:   Value: 0x3020
 // SYMBOL:   STV_PROTECTED
 // SYMBOL:   Section: zed2
 // SYMBOL: }
 
 .hidden __start_foo
 .hidden __stop_foo
 .hidden __start_bar
 .global _start

lld/trunk/test/ELF/synthetic-got.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t0.script
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t0.out --script %t0.script
 # RUN: llvm-objdump -section-headers %t0.out | FileCheck %s --check-prefix=GOT
 # RUN: llvm-objdump -s -section=.got -section=.got.plt %t0.out \
 # RUN:   | FileCheck %s --check-prefix=GOTDATA
 
 # GOT:     Sections:
-# GOT:      8  .got.plt     00000020 00000000000000e0 DATA
-# GOT:      10 .got         00000008 00000000000001d0 DATA
-# GOTDATA:     Contents of section .got.plt:
-# GOTDATA-NEXT:  00e0 00010000 00000000 00000000 00000000
-# GOTDATA-NEXT:  00f0 00000000 00000000 d6000000 00000000
-# GOTDATA-NEXT: Contents of section .got:
-# GOTDATA-NEXT:  01d0 00000000 00000000
+# GOT:       9 .got         00000008 00000000000001b0 DATA
+# GOT:      10 .got.plt     00000020 00000000000001b8 DATA
+# GOTDATA:      Contents of section .got:
+# GOTDATA-NEXT:  01b0 00000000 00000000
+# GOTDATA-NEXT: Contents of section .got.plt:
+# GOTDATA-NEXT:  01b8 e0000000 00000000 00000000 00000000
+# GOTDATA-NEXT:  01c8 00000000 00000000 d6000000 00000000
 
 # RUN: echo "SECTIONS { .mygot : { *(.got) *(.got.plt) } }" > %t1.script
 # RUN: ld.lld --hash-style=sysv -shared %t.o -o %t1.out --script %t1.script
 # RUN: llvm-objdump -section-headers %t1.out | FileCheck %s --check-prefix=MYGOT
 # RUN: llvm-objdump -s -section=.mygot %t1.out | FileCheck %s --check-prefix=MYGOTDATA
 
 # MYGOT:     Sections:
 # MYGOT:      8  .mygot     00000028 00000000000000e0 DATA
 # MYGOT-NOT:  .got
 # MYGOT-NOT:  .got.plt
 # MYGOTDATA:      00e0 00000000 00000000 08010000 00000000
 # MYGOTDATA-NEXT: 00f0 00000000 00000000 00000000 00000000
 # MYGOTDATA-NEXT: 0100 d6000000 00000000
 
 mov bar@gotpcrel(%rip), %rax
 call foo@plt

lld/trunk/test/ELF/tls-dynamic-i686.s

 addl tls1@gotntpoff(%ebx),%eax
 
 // CHECK:      Name: .got (
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x3070
-// CHECK-NEXT: Offset: 0x3070
+// CHECK-NEXT: Address: 0x2070
+// CHECK-NEXT: Offset: 0x2070
 // CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize: 0
 
 // CHECK: Relocations [
 // CHECK:      Section ({{.+}}) .rel.dyn {
-// CHECK-NEXT: 0x3080 R_386_TLS_DTPMOD32 - 0x0
-// CHECK-NEXT: 0x3070 R_386_TLS_DTPMOD32 tls0 0x0
-// CHECK-NEXT: 0x3074 R_386_TLS_DTPOFF32 tls0 0x0
-// CHECK-NEXT: 0x3088 R_386_TLS_TPOFF tls0 0x0
-// CHECK-NEXT: 0x3078 R_386_TLS_DTPMOD32 tls1 0x0
-// CHECK-NEXT: 0x307C R_386_TLS_DTPOFF32 tls1 0x0
-// CHECK-NEXT: 0x308C R_386_TLS_TPOFF tls1 0x0
+// CHECK-NEXT: 0x2080 R_386_TLS_DTPMOD32 - 0x0
+// CHECK-NEXT: 0x2070 R_386_TLS_DTPMOD32 tls0 0x0
+// CHECK-NEXT: 0x2074 R_386_TLS_DTPOFF32 tls0 0x0
+// CHECK-NEXT: 0x2088 R_386_TLS_TPOFF tls0 0x0
+// CHECK-NEXT: 0x2078 R_386_TLS_DTPMOD32 tls1 0x0
+// CHECK-NEXT: 0x207C R_386_TLS_DTPOFF32 tls1 0x0
+// CHECK-NEXT: 0x208C R_386_TLS_TPOFF tls1 0x0
 // CHECK-NEXT: }
 
 // DIS:      Disassembly of section .text:
 // DIS-NEXT: _start:
 // General dynamic model:
 // -32 and -24 are first and second GOT entries offsets.
 // Each one is a pair of records.
 // DIS-NEXT: 1000: {{.*}} leal -32(,%ebx), %eax

lld/trunk/test/ELF/tls-dynamic.s

 
 // CHECK:      Sections [
 // CHECK:          Name: .got (
 // CHECK-NEXT:     Type: SHT_PROGBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address: 0x30E0
+// CHECK-NEXT:     Address: 0x20E0
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 40
 
 // CHECK:      Relocations [
 // CHECK:        Section ({{.+}}) .rela.dyn {
-// CHECK-NEXT:     0x30E0 R_X86_64_DTPMOD64 - 0x0
-// CHECK-NEXT:     0x30F0 R_X86_64_DTPMOD64 c 0x0
-// CHECK-NEXT:     0x30F8 R_X86_64_DTPOFF64 c 0x0
-// CHECK-NEXT:     0x3100 R_X86_64_TPOFF64 c 0x0
+// CHECK-NEXT:     0x20E0 R_X86_64_DTPMOD64 - 0x0
+// CHECK-NEXT:     0x20F0 R_X86_64_DTPMOD64 c 0x0
+// CHECK-NEXT:     0x20F8 R_X86_64_DTPOFF64 c 0x0
+// CHECK-NEXT:     0x2100 R_X86_64_TPOFF64 c 0x0
 // CHECK-NEXT:   }
 
-// 8409 = (0x30E0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
-// 8397 = (0x30F0 + -4) - (0x100c + 3) // PC relative offset to got entry.
-// 8379 = (0x30F8 + -4) - (0x102e + 3) // PC relative offset to got entry.
-// 8375 = (0x3100 + -4) - (0x1042 + 3) // PC relative offset to got entry.
+// 4313 = (0x20E0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
+// 4301 = (0x20F0 + -4) - (0x100c + 3) // PC relative offset to got entry.
+// 4283 = (0x20F8 + -4) - (0x102e + 3) // PC relative offset to got entry.
+// 4279 = (0x2100 + -4) - (0x1042 + 3) // PC relative offset to got entry.
 
 // DIS:      Disassembly of section .text:
 // DIS-NEXT: .text:
-// DIS-NEXT:     1000: {{.+}} leaq    8409(%rip), %rdi
+// DIS-NEXT:     1000: {{.+}} leaq    4313(%rip), %rdi
 // DIS-NEXT:     1007: {{.+}} callq
-// DIS-NEXT:     100c: {{.+}} leaq    8397(%rip), %rdi
+// DIS-NEXT:     100c: {{.+}} leaq    4301(%rip), %rdi
 // DIS-NEXT:     1013: {{.+}} callq
 // DIS-NEXT:     1018: {{.+}} leaq    (%rax), %rcx
 // DIS-NEXT:     101f: {{.+}} leaq    4(%rax), %rcx
 // DIS-NEXT:     1026: 04 00
 // DIS-NEXT:     1028: 00 00
 // DIS-NEXT:     102a: 00 00
 // DIS-NEXT:     102c: 00 00
-// DIS-NEXT:     102e: {{.+}} leaq    8379(%rip), %rdi
+// DIS-NEXT:     102e: {{.+}} leaq    4283(%rip), %rdi
 // DIS-NEXT:     1035: {{.+}} callq
 // DIS-NEXT:     103b: {{.+}} leaq    (%rax), %rcx
-// DIS-NEXT:     1042: {{.+}} movq    8375(%rip), %rax
+// DIS-NEXT:     1042: {{.+}} movq    4279(%rip), %rax
 // DIS-NEXT:     1049: {{.+}} movq    %fs:(%rax), %rax
 // DIS-NEXT:     104d: {{.+}} movabsq $0, %rax
 // DIS-NEXT:     1057: {{.+}} movabsq $4, %rax
 // DIS-NEXT:     1061: {{.+}} movabsq $0, %rax

lld/trunk/test/ELF/undef-with-plt-addr.s

 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x201010
 
 // CHECK:      Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:   0x202000 R_X86_64_64 foo 0x0
+// CHECK-NEXT:   0x203000 R_X86_64_64 foo 0x0
 // CHECK-NEXT: }
 // CHECK-NEXT: Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:   0x202020 R_X86_64_JUMP_SLOT set_data 0x0
+// CHECK-NEXT:   0x203020 R_X86_64_JUMP_SLOT set_data 0x0
 // CHECK-NEXT: }
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Value: 0x0
 // CHECK-NEXT: Size: 0
 // CHECK-NEXT: Binding: Global
 // CHECK-NEXT: Type: Function
 // CHECK-NEXT: Other: 0

lld/trunk/test/ELF/undefined-versioned-symbol.s

 // RUN: echo "LIBPKG_1.3 { };" > %t.ver
 // RUN: ld.lld --shared %t.o --version-script %t.ver %t2.so -o %t.so
 // RUN: llvm-readobj --dyn-symbols -r --expand-relocs %t.so | FileCheck %s
 
 // Test that each relocation points to the correct version.
 
 // CHECK:      Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:   Relocation {
-// CHECK-NEXT:     Offset: 0x1000
+// CHECK-NEXT:     Offset: 0x2000
 // CHECK-NEXT:     Type: R_X86_64_64 (1)
 // CHECK-NEXT:     Symbol: basename@FBSD_1.1 (1)
 // CHECK-NEXT:     Addend: 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Relocation {
-// CHECK-NEXT:     Offset: 0x1008
+// CHECK-NEXT:     Offset: 0x2008
 // CHECK-NEXT:     Type: R_X86_64_64 (1)
 // CHECK-NEXT:     Symbol: basename@FBSD_1.0 (2)
 // CHECK-NEXT:     Addend: 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Relocation {
-// CHECK-NEXT:     Offset: 0x1010
+// CHECK-NEXT:     Offset: 0x2010
 // CHECK-NEXT:     Type: R_X86_64_64 (1)
 // CHECK-NEXT:     Symbol: basename@FBSD_1.1 (3)
 // CHECK-NEXT:     Addend: 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 
 
 // CHECK:      DynamicSymbols [

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

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/version-script-weak.s -o %tmp.o
 # RUN: rm -f %t.a
 # RUN: llvm-ar rcs %t.a %tmp.o
 # RUN: echo "{ local: *; };" > %t.script
 # RUN: ld.lld -shared --version-script %t.script %t.o %t.a -o %t.so
 # RUN: llvm-readobj -dyn-symbols -r %t.so | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-# CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT foo
+# CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT foo
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK:      Symbol {
 # CHECK:        Name: foo
 # CHECK-NEXT:   Value: 0x0
 # CHECK-NEXT:   Size: 0
 # CHECK-NEXT:   Binding: Weak
 # CHECK-NEXT:   Type: None
 # CHECK-NEXT:   Other: 0
 # CHECK-NEXT:   Section: Undefined
 # CHECK-NEXT: }
 
 .text
  callq foo@PLT
 .weak foo

lld/trunk/test/ELF/wrap-plt.s

 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 48
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT __wrap_foo 0x0
-// CHECK-NEXT:     0x2020 R_X86_64_JUMP_SLOT _start 0x0
+// CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT __wrap_foo 0x0
+// CHECK-NEXT:     0x3020 R_X86_64_JUMP_SLOT _start 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // DISASM:      _start:
 // DISASM-NEXT: jmp    41
 // DISASM-NEXT: jmp    36
 // DISASM-NEXT: jmp    47
 

lld/trunk/test/ELF/x86-64-plt-high-addr.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t1.o
 // RUN: ld.lld -o %t.so -shared %t1.o
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t2.o
 // RUN: ld.lld -o %t1.exe %t2.o %t.so -image-base=0xcafe00000000
 // RUN: llvm-objdump -s -j .got.plt %t1.exe | FileCheck %s
 
 // CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: cafe00002000 00300000 feca0000 00000000 00000000
-// CHECK-NEXT: cafe00002010 00000000 00000000 26100000 feca0000
+// CHECK-NEXT: cafe00003000 00200000 feca0000 00000000 00000000
+// CHECK-NEXT: cafe00003010 00000000 00000000 26100000 feca0000
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t2.o
 // RUN: ld.lld -o %t2.exe %t2.o %t.so -image-base=0xcafe00000000 -z retpolineplt
 // RUN: llvm-objdump -s -j .got.plt %t2.exe | FileCheck -check-prefix=RETPOLINE %s
 
 // RETPOLINE:      Contents of section .got.plt:
-// RETPOLINE-NEXT: cafe00002000 00300000 feca0000 00000000 00000000
-// RETPOLINE-NEXT: cafe00002010 00000000 00000000 51100000 feca0000
+// RETPOLINE-NEXT: cafe00003000 00200000 feca0000 00000000 00000000
+// RETPOLINE-NEXT: cafe00003010 00000000 00000000 51100000 feca0000
 
 .global _start
 _start:
   jmp bar@PLT

lld/trunk/test/ELF/x86-64-reloc-gotoff64.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-readelf -S %t.so | FileCheck %s -check-prefix=SECTION
 // RUN: llvm-objdump -d %t.so | FileCheck %s
 
-// SECTION: .dynamic DYNAMIC 0000000000003000
-// SECTION: .got PROGBITS 0000000000003070 003070 000000
+// SECTION: .dynamic DYNAMIC 0000000000002000
+// SECTION: .got PROGBITS 0000000000002070 002070 000000
 
 // All the _GLOBAL_OFFSET_TABLE_ occurrences below refer to the address
 // of GOT base, not the address of the symbol _GLOBAL_OFFSET_TABLE_. These
 // instructions are special and produce GOT base relative relocations. We
 // currently use .got end as the GOT base, which is not equal to
 // the address of the special symbol _GLOBAL_OFFSET_TABLE_.
 
 // The assembly is generated by
 // gcc -O2 -S -mcmodel=medium -fPIC a.c
 // This computes the pc-relative address (runtime address) of _DYNAMIC.
 //
 // extern long _DYNAMIC[] __attribute__((visibility("hidden")));
 // long* dynamic() { return _DYNAMIC; }
 
-// 0x3070 (.got end) - 0x1007 = 8297
-// 0x3000 (_DYNAMIC) - 0x3070 (.got end) = -112
-// CHECK:      1000: {{.*}} leaq 8297(%rip), %rdx
+// 0x2070 (.got end) - 0x1007 = 4201
+// 0x2000 (_DYNAMIC) - 0x2070 (.got end) = -112
+// CHECK:      1000: {{.*}} leaq 4201(%rip), %rdx
 // CHECK-NEXT: 1007: {{.*}} movabsq $-112, %rax
 .global dynamic
 dynamic:
   leaq _GLOBAL_OFFSET_TABLE_(%rip), %rdx
   movabsq $_DYNAMIC@GOTOFF, %rax
   addq %rdx, %rax
   ret

lld/trunk/test/ELF/x86-64-reloc-gotpc64.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-readelf -S %t.so | FileCheck %s -check-prefix=SECTION
 // RUN: llvm-objdump -d %t.so | FileCheck %s
 
-// SECTION: .got PROGBITS 0000000000003070 003070 000000
+// SECTION: .got PROGBITS 0000000000002070 002070 000000
 
-// 0x3070 (.got end) - 0x1000 = 8304
+// 0x2070 (.got end) - 0x1000 = 4208
 // CHECK: gotpc64:
-// CHECK-NEXT: 1000: {{.*}} movabsq $8304, %r11
+// CHECK-NEXT: 1000: {{.*}} movabsq $4208, %r11
 .global gotpc64
 gotpc64:
   movabsq $_GLOBAL_OFFSET_TABLE_-., %r11

lld/trunk/test/ELF/x86-64-retpoline-linkerscript.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.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
 
 // RUN: echo "SECTIONS { \
 // RUN:   .text : { *(.text) } \
 // RUN:   .plt : { *(.plt) } \
 // RUN:   .got.plt : { *(.got.plt) } \
 // RUN:   .dynstr : { *(.dynstr) } \
 // RUN: }" > %t.script
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt --script %t.script
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 10:       ff 35 72 00 00 00       pushq   114(%rip)
-// CHECK-NEXT: 16:       4c 8b 1d 73 00 00 00    movq    115(%rip), %r11
+// CHECK-NEXT: 10:       ff 35 32 01 00 00       pushq   306(%rip)
+// CHECK-NEXT: 16:       4c 8b 1d 33 01 00 00    movq    307(%rip), %r11
 // CHECK-NEXT: 1d:       e8 0e 00 00 00  callq   14 <.plt+0x20>
 // CHECK-NEXT: 22:       f3 90   pause
 // CHECK-NEXT: 24:       0f ae e8        lfence
 // CHECK-NEXT: 27:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 29:       cc      int3
 // CHECK-NEXT: 2a:       cc      int3
 // CHECK-NEXT: 2b:       cc      int3
 // CHECK-NEXT: 2c:       cc      int3
 // CHECK-NEXT: 2d:       cc      int3
 // CHECK-NEXT: 2e:       cc      int3
 // CHECK-NEXT: 2f:       cc      int3
 // CHECK-NEXT: 30:       4c 89 1c 24     movq    %r11, (%rsp)
 // CHECK-NEXT: 34:       c3      retq
 // CHECK-NEXT: 35:       cc      int3
 // CHECK-NEXT: 36:       cc      int3
 // CHECK-NEXT: 37:       cc      int3
 // CHECK-NEXT: 38:       cc      int3
 // CHECK-NEXT: 39:       cc      int3
 // CHECK-NEXT: 3a:       cc      int3
 // CHECK-NEXT: 3b:       cc      int3
 // CHECK-NEXT: 3c:       cc      int3
 // CHECK-NEXT: 3d:       cc      int3
 // CHECK-NEXT: 3e:       cc      int3
 // CHECK-NEXT: 3f:       cc      int3
-// CHECK-NEXT: 40:       4c 8b 1d 51 00 00 00    movq    81(%rip), %r11
+// CHECK-NEXT: 40:       4c 8b 1d 11 01 00 00    movq    273(%rip), %r11
 // CHECK-NEXT: 47:       e8 e4 ff ff ff  callq   -28 <.plt+0x20>
 // CHECK-NEXT: 4c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
 // CHECK-NEXT: 51:       68 00 00 00 00  pushq   $0
 // CHECK-NEXT: 56:       e9 b5 ff ff ff  jmp     -75 <.plt>
 // CHECK-NEXT: 5b:       cc      int3
 // CHECK-NEXT: 5c:       cc      int3
 // CHECK-NEXT: 5d:       cc      int3
 // CHECK-NEXT: 5e:       cc      int3
 // CHECK-NEXT: 5f:       cc      int3
-// CHECK-NEXT: 60:       4c 8b 1d 39 00 00 00    movq    57(%rip), %r11
+// CHECK-NEXT: 60:       4c 8b 1d f9 00 00 00    movq    249(%rip), %r11
 // CHECK-NEXT: 67:       e8 c4 ff ff ff  callq   -60 <.plt+0x20>
 // CHECK-NEXT: 6c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
 // CHECK-NEXT: 71:       68 01 00 00 00  pushq   $1
 // CHECK-NEXT: 76:       e9 95 ff ff ff  jmp     -107 <.plt>
 // CHECK-NEXT: 7b:       cc      int3
 // CHECK-NEXT: 7c:       cc      int3
 // CHECK-NEXT: 7d:       cc      int3
 // CHECK-NEXT: 7e:       cc      int3
 // CHECK-NEXT: 7f:       cc      int3
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/x86-64-retpoline.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.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
 
 // RUN: ld.lld -shared %t1.o %t2.so -o %t.exe -z retpolineplt
 // RUN: llvm-objdump -d -s %t.exe | FileCheck %s
 
 // CHECK:      Disassembly of section .plt:
 // CHECK-NEXT: .plt:
-// CHECK-NEXT: 1010:       ff 35 f2 0f 00 00       pushq   4082(%rip)
-// CHECK-NEXT: 1016:       4c 8b 1d f3 0f 00 00    movq    4083(%rip), %r11
+// CHECK-NEXT: 1010:       ff 35 f2 1f 00 00       pushq   8178(%rip)
+// CHECK-NEXT: 1016:       4c 8b 1d f3 1f 00 00    movq    8179(%rip), %r11
 // CHECK-NEXT: 101d:       e8 0e 00 00 00  callq   14 <.plt+0x20>
 // CHECK-NEXT: 1022:       f3 90   pause
 // CHECK-NEXT: 1024:       0f ae e8        lfence
 // CHECK-NEXT: 1027:       eb f9   jmp     -7 <.plt+0x12>
 // CHECK-NEXT: 1029:       cc      int3
 // CHECK-NEXT: 102a:       cc      int3
 // CHECK-NEXT: 102b:       cc      int3
 // CHECK-NEXT: 102c:       cc      int3
 // CHECK-NEXT: 102d:       cc      int3
 // CHECK-NEXT: 102e:       cc      int3
 // CHECK-NEXT: 102f:       cc      int3
 // CHECK-NEXT: 1030:       4c 89 1c 24     movq    %r11, (%rsp)
 // CHECK-NEXT: 1034:       c3      retq
 // CHECK-NEXT: 1035:       cc      int3
 // CHECK-NEXT: 1036:       cc      int3
 // CHECK-NEXT: 1037:       cc      int3
 // CHECK-NEXT: 1038:       cc      int3
 // CHECK-NEXT: 1039:       cc      int3
 // CHECK-NEXT: 103a:       cc      int3
 // CHECK-NEXT: 103b:       cc      int3
 // CHECK-NEXT: 103c:       cc      int3
 // CHECK-NEXT: 103d:       cc      int3
 // CHECK-NEXT: 103e:       cc      int3
 // CHECK-NEXT: 103f:       cc      int3
-// CHECK-NEXT: 1040:       4c 8b 1d d1 0f 00 00    movq    4049(%rip), %r11
+// CHECK-NEXT: 1040:       4c 8b 1d d1 1f 00 00    movq    8145(%rip), %r11
 // CHECK-NEXT: 1047:       e8 e4 ff ff ff  callq   -28 <.plt+0x20>
 // CHECK-NEXT: 104c:       e9 d1 ff ff ff  jmp     -47 <.plt+0x12>
 // CHECK-NEXT: 1051:       68 00 00 00 00  pushq   $0
 // CHECK-NEXT: 1056:       e9 b5 ff ff ff  jmp     -75 <.plt>
 // CHECK-NEXT: 105b:       cc      int3
 // CHECK-NEXT: 105c:       cc      int3
 // CHECK-NEXT: 105d:       cc      int3
 // CHECK-NEXT: 105e:       cc      int3
 // CHECK-NEXT: 105f:       cc      int3
-// CHECK-NEXT: 1060:       4c 8b 1d b9 0f 00 00    movq    4025(%rip), %r11
+// CHECK-NEXT: 1060:       4c 8b 1d b9 1f 00 00    movq    8121(%rip), %r11
 // CHECK-NEXT: 1067:       e8 c4 ff ff ff  callq   -60 <.plt+0x20>
 // CHECK-NEXT: 106c:       e9 b1 ff ff ff  jmp     -79 <.plt+0x12>
 // CHECK-NEXT: 1071:       68 01 00 00 00  pushq   $1
 // CHECK-NEXT: 1076:       e9 95 ff ff ff  jmp     -107 <.plt>
 // CHECK-NEXT: 107b:       cc      int3
 // CHECK-NEXT: 107c:       cc      int3
 // CHECK-NEXT: 107d:       cc      int3
 // CHECK-NEXT: 107e:       cc      int3
 // CHECK-NEXT: 107f:       cc      int3
 
 // CHECK:      Contents of section .got.plt:
-// CHECK-NEXT: 2000 00300000 00000000 00000000 00000000
-// CHECK-NEXT: 2010 00000000 00000000 51100000 00000000
-// CHECK-NEXT: 2020 71100000 00000000
+// CHECK-NEXT: 3000 00200000 00000000 00000000 00000000
+// CHECK-NEXT: 3010 00000000 00000000 51100000 00000000
+// CHECK-NEXT: 3020 71100000 00000000
 
 .global _start
 _start:
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/test/ELF/x86-64-tls-gd-local.s

 
 
 // CHECK:      Name: .got (
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC (0x2)
 // CHECK-NEXT:   SHF_WRITE (0x1)
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x30D0
-// CHECK-NEXT: Offset: 0x30D0
+// CHECK-NEXT: Address: 0x20D0
+// CHECK-NEXT: Offset: 0x20D0
 // CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 00000000 00000000 00000000 00000000  |................|
 // CHECK-NEXT:   0010: 00000000 00000000 04000000 00000000  |................|
 // CHECK-NEXT: )
 
 // CHECK:      Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:   0x30D0 R_X86_64_DTPMOD64 - 0x0
-// CHECK-NEXT:   0x30E0 R_X86_64_DTPMOD64 - 0x0
+// CHECK-NEXT:   0x20D0 R_X86_64_DTPMOD64 - 0x0
+// CHECK-NEXT:   0x20E0 R_X86_64_DTPMOD64 - 0x0
 // CHECK-NEXT: }