[ELF] - Protect first entries of got.plt with RelRo.

[grimar]

Summary

First entries of got.plt can be protected using RelRo technique,
this patch implements this by shifting got.plt to the memory page,
where relro is active.

Both gold and bfd do that and it should be good for security.

[ruiu]

Interesting, but it is tricky. What exactly is the threat for putting the first entry of .got.plt in a writable segment, how realistic is the attack is, and how much does this mitigate the risk?

[• rafael]

Remind me again how the first entry works. From the ABI it looks like
.got has to have the first entry be the value of _DYNAMIC and the
dynamic linker can use that.

But, it looks like it is actually .got.plt that has that. Also, if the
dynamic linker can find the .got, it can find the .dynamic section,
no?

[• rafael]

I see that musl just does

lea _DYNAMIC(%rip),%rsi

to find its own _DYNAMIC.

I wonder if we can just drop the magical first entries.

Cheers,
Rafael

[emaste]

If going for safety you should really disable lazy loading or even just compile with -fno-plt.

This patch is not terribly complex, but I also suspect that in practice folks will use -zrelro & -znow if this is a concern.

ELF/OutputSections.h

92

This comment is now confusing to me -- "page aligned" isn't how I'd describe the effect of PageAlignKind::GotPlt. What about just describing these three types where the enum is defined?

[grimar]

Well, I assumed it is useful, at least because even linkerscript has special command
DATA_SEGMENT_RELRO_END to do that:

.got            : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (24, .);
.got.plt        : { *(.got.plt)  *(.igot.plt) }

I don't know how realistic is attack using unprotected first 3 entries.
Second and third are reserved for dynamic linker use and it is probably would be very specific attack.
So may be use of -zrelro & -znow is enough to protect (since whole .got.plt is covered by relro which is even more safe)
and also avoids additional code complexity.

ELF/OutputSections.h

 
 template <class ELFT>
 static inline typename ELFT::uint getAddend(const typename ELFT::Rela &Rel) {
   return Rel.r_addend;
 }
 
 bool isValidCIdentifier(StringRef S);
 
+enum class PageAlignKind { None, GotPlt, Common };
+
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <class ELFT> class OutputSectionBase {
 public:
   typedef typename ELFT::uint uintX_t;
uintX_t getAlign() const {
     return std::max<uintX_t>(Header.sh_addralign, 1);
   }
   uint32_t getType() const { return Header.sh_type; }
   void updateAlign(uintX_t Align) {
     if (Align > Header.sh_addralign)
       Header.sh_addralign = Align;
   }
 
-  // If true, this section will be page aligned on disk.
+  // If not PageAlignKind::None this section will be page aligned on disk.
   // Typically the first section of each PT_LOAD segment has this flag.
-  bool PageAlign = false;
+  // PageAlignKind::GotPlt can be used to protect first entries of got.plt,
+  // using RelRo technique.
+  PageAlignKind PageAlign = PageAlignKind::None;
 
   virtual void finalize() {}
   virtual void
   forEachInputSection(std::function<void(InputSectionBase<ELFT> *)> F) {}
   virtual void writeTo(uint8_t *Buf) {}
   virtual ~OutputSectionBase() = default;
 
 protected:

ELF/Writer.cpp

template <class ELFT> static bool isRelroSection(OutputSectionBase<ELFT> *Sec) {
   if (!(Flags & SHF_ALLOC) || !(Flags & SHF_WRITE))
     return false;
   if (Flags & SHF_TLS)
     return true;
   uint32_t Type = Sec->getType();
   if (Type == SHT_INIT_ARRAY || Type == SHT_FINI_ARRAY ||
       Type == SHT_PREINIT_ARRAY)
     return true;
-  if (Sec == Out<ELFT>::GotPlt)
-    return Config->ZNow;
-  if (Sec == Out<ELFT>::Dynamic || Sec == Out<ELFT>::Got)
+  if (Sec == Out<ELFT>::GotPlt || Sec == Out<ELFT>::Dynamic ||
+      Sec == Out<ELFT>::Got)
     return true;
   StringRef S = Sec->getName();
   return S == ".data.rel.ro" || S == ".ctors" || S == ".dtors" || S == ".jcr" ||
          S == ".eh_frame";
 }
 
 // Output section ordering is determined by this function.
 template <class ELFT>
if (AIsNoBits != BIsNoBits)
     return BIsNoBits;
 
   // We place RelRo section before plain r/w ones.
   bool AIsRelRo = isRelroSection(A);
   bool BIsRelRo = isRelroSection(B);
   if (AIsRelRo != BIsRelRo)
     return AIsRelRo;
 
+  if (AIsRelRo && BIsRelRo) {
+    // GotPlt should go right after all other RelRo sections.
+    // That way we will able to shift its VA, so RelRo memory page
+    // will protect first entries.
+    if (Config->ZRelro && !Config->ZNow) {
+      bool AIsGotPlt = A == Out<ELFT>::GotPlt;
+      bool BIsGotPlt = B == Out<ELFT>::GotPlt;
+      if (AIsGotPlt != BIsGotPlt)
+        return BIsGotPlt;
+    }
+  }
+
   // Some architectures have additional ordering restrictions for sections
   // within the same PT_LOAD.
   if (Config->EMachine == EM_PPC64)
     return getPPC64SectionRank(A->getName()) <
            getPPC64SectionRank(B->getName());
 
   return false;
 }
template <class ELFT> void Writer<ELFT>::createPhdrs() {
   Out<ELFT>::ProgramHeaders->setSize(sizeof(Elf_Phdr) * Phdrs.size());
 }
 
 // The first section of each PT_LOAD and the first section after PT_GNU_RELRO
 // have to be page aligned so that the dynamic linker can set the permissions.
 template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
   for (const Phdr &P : Phdrs)
     if (P.H.p_type == PT_LOAD)
-      P.First->PageAlign = true;
+      P.First->PageAlign = PageAlignKind::Common;
 
   for (const Phdr &P : Phdrs) {
     if (P.H.p_type != PT_GNU_RELRO)
       continue;
+
+    if (Config->ZRelro && !Config->ZNow && P.Last == Out<ELFT>::GotPlt) {
+      Out<ELFT>::GotPlt->PageAlign = PageAlignKind::GotPlt;
+      continue;
+    }
+
     // Find the first section after PT_GNU_RELRO. If it is in a PT_LOAD we
     // have to align it to a page.
     auto End = OutputSections.end();
     auto I = std::find(OutputSections.begin(), End, P.Last);
     if (I == End || (I + 1) == End)
       continue;
     OutputSectionBase<ELFT> *Sec = *(I + 1);
     if (needsPtLoad(Sec))
-      Sec->PageAlign = true;
+      Sec->PageAlign = PageAlignKind::Common;
   }
 }
 
 // We should set file offsets and VAs for elf header and program headers
 // sections. These are special, we do not include them into output sections
 // list, but have them to simplify the code.
 template <class ELFT> void Writer<ELFT>::fixHeaders() {
   uintX_t BaseVA = ScriptConfig->DoLayout ? 0 : Target->getVAStart();
   Out<ELFT>::ElfHeader->setVA(BaseVA);
   Out<ELFT>::ElfHeader->setFileOffset(0);
   uintX_t Off = Out<ELFT>::ElfHeader->getSize();
   Out<ELFT>::ProgramHeaders->setVA(Off + BaseVA);
   Out<ELFT>::ProgramHeaders->setFileOffset(Off);
 }
 
+template <class ELFT, class uintX_t, class PageAlignKind>
+static uintX_t maybeShiftAlign(uintX_t Val, uintX_t Align, PageAlignKind Kind) {
+  uintX_t GotPltShift = Target->GotPltHeaderEntriesNum * sizeof(uintX_t);
+  uintX_t OldVal = Val;
+
+  Val = alignTo(Val, Align);
+  if (Kind == PageAlignKind::GotPlt) {
+    if (Val - GotPltShift < OldVal)
+      Val += Target->PageSize;
+    Val -= GotPltShift;
+  }
+  return Val;
+}
+
 // Assign VAs (addresses at run-time) to output sections.
 template <class ELFT> void Writer<ELFT>::assignAddresses() {
   uintX_t VA = Target->getVAStart() + Out<ELFT>::ElfHeader->getSize() +
                Out<ELFT>::ProgramHeaders->getSize();
 
   uintX_t ThreadBssOffset = 0;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     uintX_t Align = Sec->getAlign();
-    if (Sec->PageAlign)
+    if (Sec->PageAlign != PageAlignKind::None)
       Align = std::max<uintX_t>(Align, Target->PageSize);
 
     // We only assign VAs to allocated sections.
     if (needsPtLoad<ELFT>(Sec)) {
-      VA = alignTo(VA, Align);
+      VA = maybeShiftAlign<ELFT>(VA, Align, Sec->PageAlign);
       Sec->setVA(VA);
       VA += Sec->getSize();
     } else if (Sec->getFlags() & SHF_TLS && Sec->getType() == SHT_NOBITS) {
       uintX_t TVA = VA + ThreadBssOffset;
       TVA = alignTo(TVA, Align);
       Sec->setVA(TVA);
       ThreadBssOffset = TVA - VA + Sec->getSize();
     }
   }
 }
 
 // Adjusts the file alignment for a given output section and returns
 // its new file offset. The file offset must be the same with its
 // virtual address (modulo the page size) so that the loader can load
 // executables without any address adjustment.
 template <class ELFT, class uintX_t>
 static uintX_t getFileAlignment(uintX_t Off, OutputSectionBase<ELFT> *Sec) {
   uintX_t Align = Sec->getAlign();
-  if (Sec->PageAlign)
+  if (Sec->PageAlign != PageAlignKind::None)
     Align = std::max<uintX_t>(Align, Target->PageSize);
-  Off = alignTo(Off, Align);
+  Off = maybeShiftAlign<ELFT>(Off, Align, Sec->PageAlign);
 
   // Relocatable output does not have program headers
   // and does not need any other offset adjusting.
   if (Config->Relocatable || !(Sec->getFlags() & SHF_ALLOC))
     return Off;
   return alignTo(Off, Target->PageSize, Sec->getVA());
 }
 
if (First) {
       if (Last->getType() != SHT_NOBITS)
         H.p_filesz += Last->getSize();
       H.p_memsz = Last->getVA() + Last->getSize() - First->getVA();
       H.p_offset = First->getFileOff();
       H.p_vaddr = First->getVA();
     }
     if (H.p_type == PT_LOAD)
       H.p_align = Target->PageSize;
-    else if (H.p_type == PT_GNU_RELRO)
+    else if (H.p_type == PT_GNU_RELRO) {
       H.p_align = 1;
+      if (Last->PageAlign == PageAlignKind::GotPlt) {
+        uintX_t Oversize = Out<ELFT>::GotPlt->getSize() -
+                           Target->GotPltHeaderEntriesNum * sizeof(uintX_t);
+        H.p_filesz -= Oversize;
+        H.p_memsz -= Oversize;
+      }
+    }
     H.p_paddr = H.p_vaddr;
 
     // The TLS pointer goes after PT_TLS. At least glibc will align it,
     // so round up the size to make sure the offsets are correct.
     if (H.p_type == PT_TLS) {
       Out<ELFT>::TlsPhdr = &H;
       H.p_memsz = alignTo(H.p_memsz, H.p_align);
     }

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: 0x3000
-#DSOREL-NEXT:   Offset: 0x3000
+#DSOREL-NEXT:   Address: 0x2FE8
+#DSOREL-NEXT:   Offset: 0x2FE8
 #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:    0x3018 R_AARCH64_JUMP_SLOT _foo
-#DSOREL-NEXT:    0x3020 R_AARCH64_JUMP_SLOT _bar
-#DSOREL-NEXT:    0x3028 R_AARCH64_JUMP_SLOT _dah
+#DSOREL-NEXT:    0x3000 R_AARCH64_JUMP_SLOT _foo
+#DSOREL-NEXT:    0x3008 R_AARCH64_JUMP_SLOT _bar
+#DSOREL-NEXT:    0x3010 R_AARCH64_JUMP_SLOT _dah
 #DSOREL-NEXT:  }
 #DSOREL-NEXT:]
 
 #DSO:      Disassembly of section .text:
 #DSO-NEXT: _foo:
 #DSO-NEXT:     1000: {{.*}} nop
 #DSO-NEXT:     1004: {{.*}} nop
 #DSO-NEXT:     1008: {{.*}} nop
 #DSO-NEXT:     100c: {{.*}} nop
 #DSO:      _bar:
 #DSO-NEXT:     1010: {{.*}} nop
 #DSO-NEXT:     1014: {{.*}} nop
 #DSO-NEXT:     1018: {{.*}} nop
 #DSO:      _dah:
 #DSO-NEXT:     101c: {{.*}} nop
 #DSO-NEXT:     1020: {{.*}} nop
 #DSO:      _start:
 #DSO-NEXT:     1024: {{.*}} b.eq #44
 #DSO-NEXT:     1028: {{.*}} b.eq #56
 #DSO-NEXT:     102c: {{.*}} b.eq #68
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-NEXT: .plt:
 #DSO-NEXT:     1030: {{.*}} stp x16, x30, [sp, #-16]!
-#DSO-NEXT:     1034: {{.*}} adrp x16, #8192
-#DSO-NEXT:     1038: {{.*}} ldr x17, [x16, #16]
-#DSO-NEXT:     103c: {{.*}} add x16, x16, #16
+#DSO-NEXT:     1034: {{.*}} adrp x16, #4096
+#DSO-NEXT:     1038: {{.*}} ldr x17, [x16, #4088]
+#DSO-NEXT:     103c: {{.*}} add x16, x16, #4088
 #DSO-NEXT:     1040: {{.*}} br x17
 #DSO-NEXT:     1044: {{.*}} nop
 #DSO-NEXT:     1048: {{.*}} nop
 #DSO-NEXT:     104c: {{.*}} nop
 #DSO-NEXT:     1050: {{.*}} adrp x16, #8192
-#DSO-NEXT:     1054: {{.*}} ldr x17, [x16, #24]
-#DSO-NEXT:     1058: {{.*}} add x16, x16, #24
+#DSO-NEXT:     1054: {{.*}} ldr x17, [x16]
+#DSO-NEXT:     1058: {{.*}} add x16, x16, #0
 #DSO-NEXT:     105c: {{.*}} br x17
 #DSO-NEXT:     1060: {{.*}} adrp x16, #8192
-#DSO-NEXT:     1064: {{.*}} ldr x17, [x16, #32]
-#DSO-NEXT:     1068: {{.*}} add x16, x16, #32
+#DSO-NEXT:     1064: {{.*}} ldr x17, [x16, #8]
+#DSO-NEXT:     1068: {{.*}} add x16, x16, #8
 #DSO-NEXT:     106c: {{.*}} br x17
 #DSO-NEXT:     1070: {{.*}} adrp x16, #8192
-#DSO-NEXT:     1074: {{.*}} ldr x17, [x16, #40]
-#DSO-NEXT:     1078: {{.*}} add x16, x16, #40
+#DSO-NEXT:     1074: {{.*}} ldr x17, [x16, #16]
+#DSO-NEXT:     1078: {{.*}} add x16, x16, #16
 #DSO-NEXT:     107c: {{.*}} br x17
 
 .globl _start
 _start:
  b.eq _foo
  b.eq _bar
  b.eq _dah

test/ELF/aarch64-gnu-ifunc.s

 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux-gnu %s -o %t.o
 // RUN: ld.lld -static %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r -symbols -sections %tout | FileCheck %s
 // REQUIRES: aarch64
 
 // CHECK:      Sections [
 // CHECK:       Section {
 // CHECK:       Index: 1
 // CHECK-NEXT:  Name: .rela.plt
 // CHECK-NEXT:  Type: SHT_RELA
 // CHECK-NEXT:  Flags [
 // CHECK-NEXT:    SHF_ALLOC
 // CHECK-NEXT:  ]
 // CHECK-NEXT:  Address: [[RELA:.*]]
-// CHECK-NEXT:  Offset: 0x158
+// CHECK-NEXT:  Offset: 0x190
 // CHECK-NEXT:  Size: 48
 // CHECK-NEXT:  Link: 5
 // CHECK-NEXT:  Info: 0
 // CHECK-NEXT:  AddressAlignment: 8
 // CHECK-NEXT:  EntrySize: 24
 // CHECK-NEXT: }
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:     0x12018 R_AARCH64_IRELATIVE
-// CHECK-NEXT:     0x12020 R_AARCH64_IRELATIVE
+// CHECK-NEXT:     0x12000 R_AARCH64_IRELATIVE
+// CHECK-NEXT:     0x12008 R_AARCH64_IRELATIVE
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 // CHECK:      Symbols [
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name:
 // CHECK-NEXT:    Value: 0x0
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: Undefined
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: $x.0
 // CHECK-NEXT:    Value: 0x11000
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: .text
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: __rela_iplt_end
-// CHECK-NEXT:    Value: 0x10188
+// CHECK-NEXT:    Value: 0x101C0
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Section: .rela.plt
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: __rela_iplt_start
-// CHECK-NEXT:    Value: 0x10158
+// CHECK-NEXT:    Value: 0x10190
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Section: .rela.plt
 // CHECK-NEXT:  }

 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: GNU_IFunc
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: .text
 // CHECK-NEXT:  }
 // CHECK-NEXT: ]
 
-// 344 = 0x158
-// 392 = 0x188
+// 400 = 0x190
+// 448 = 0x1C0
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:  11000: c0 03 5f d6 ret
 // DISASM:      bar:
 // DISASM-NEXT:  11004: c0 03 5f d6 ret
 // DISASM:      _start:
 // DISASM-NEXT:  11008: 0e 00 00 94 bl #56
 // DISASM-NEXT:  1100c: 11 00 00 94 bl #68
-// DISASM-NEXT:  11010: 42 60 05 91 add x2, x2, #344
-// DISASM-NEXT:  11014: 42 20 06 91 add x2, x2, #392
+// DISASM-NEXT:  11010: 42 40 06 91 add x2, x2, #400
+// DISASM-NEXT:  11014: 42 00 07 91 add x2, x2, #448
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
 // DISASM-NEXT:  11020: f0 7b bf a9 stp x16, x30, [sp, #-16]!
-// DISASM-NEXT:  11024: 10 00 00 b0 adrp x16, #4096
-// DISASM-NEXT:  11028: 11 0a 40 f9 ldr x17, [x16, #16]
-// DISASM-NEXT:  1102c: 10 42 00 91 add x16, x16, #16
+// DISASM-NEXT:  11024: 10 00 00 90 adrp x16, #0
+// DISASM-NEXT:  11028: 11 fe 47 f9 ldr x17, [x16, #4088]
+// DISASM-NEXT:  1102c: 10 e2 3f 91 add x16, x16, #4088
 // DISASM-NEXT:  11030: 20 02 1f d6 br x17
 // DISASM-NEXT:  11034: 1f 20 03 d5 nop
 // DISASM-NEXT:  11038: 1f 20 03 d5 nop
 // DISASM-NEXT:  1103c: 1f 20 03 d5 nop
 // DISASM-NEXT:  11040: 10 00 00 b0 adrp x16, #4096
-// DISASM-NEXT:  11044: 11 0e 40 f9 ldr x17, [x16, #24]
-// DISASM-NEXT:  11048: 10 62 00 91 add x16, x16, #24
+// DISASM-NEXT:  11044: 11 02 40 f9 ldr x17, [x16]
+// DISASM-NEXT:  11048: 10 02 00 91 add x16, x16, #0
 // DISASM-NEXT:  1104c: 20 02 1f d6 br x17
 // DISASM-NEXT:  11050: 10 00 00 b0 adrp x16, #4096
-// DISASM-NEXT:  11054: 11 12 40 f9 ldr x17, [x16, #32]
-// DISASM-NEXT:  11058: 10 82 00 91 add x16, x16, #32
+// DISASM-NEXT:  11054: 11 06 40 f9 ldr x17, [x16, #8]
+// DISASM-NEXT:  11058: 10 22 00 91 add x16, x16, #8
 // DISASM-NEXT:  1105c: 20 02 1f d6 br x17
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret
 

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: 0x3000
-#DSOREL-NEXT:   Offset: 0x3000
+#DSOREL-NEXT:   Address: 0x2FE8
+#DSOREL-NEXT:   Offset: 0x2FE8
 #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:    0x3018 R_AARCH64_JUMP_SLOT _foo
-#DSOREL-NEXT:    0x3020 R_AARCH64_JUMP_SLOT _bar
+#DSOREL-NEXT:    0x3000 R_AARCH64_JUMP_SLOT _foo
+#DSOREL-NEXT:    0x3008 R_AARCH64_JUMP_SLOT _bar
 #DSOREL-NEXT:  }
 #DSOREL-NEXT:]
 
 #DSO:      Disassembly of section .text:
 #DSO-NEXT: _foo:
 #DSO-NEXT:  1000: {{.*}} nop
 #DSO-NEXT:  1004: {{.*}} nop
 #DSO-NEXT:  1008: {{.*}} nop

 # 0x1028 + 56 = 0x1060 = PLT[2]
 #DSO-NEXT:  101c: {{.*}} tbnz w3, #15, #52
 #DSO-NEXT:  1020: {{.*}} tbnz w3, #15, #64
 #DSO-NEXT:  1024: {{.*}} tbz x6, #45, #44
 #DSO-NEXT:  1028: {{.*}} tbz x6, #45, #56
 #DSO-NEXT: Disassembly of section .plt:
 #DSO-NEXT: .plt:
 #DSO-NEXT:  1030: {{.*}} stp x16, x30, [sp, #-16]!
-#DSO-NEXT:  1034: {{.*}} adrp x16, #8192
-#DSO-NEXT:  1038: {{.*}} ldr x17, [x16, #16]
-#DSO-NEXT:  103c: {{.*}} add x16, x16, #16
+#DSO-NEXT:  1034: {{.*}} adrp x16, #4096
+#DSO-NEXT:  1038: {{.*}} ldr x17, [x16, #4088]
+#DSO-NEXT:  103c: {{.*}} add x16, x16, #4088
 #DSO-NEXT:  1040: {{.*}} br x17
 #DSO-NEXT:  1044: {{.*}} nop
 #DSO-NEXT:  1048: {{.*}} nop
 #DSO-NEXT:  104c: {{.*}} nop
 #DSO-NEXT:  1050: {{.*}} adrp x16, #8192
-#DSO-NEXT:  1054: {{.*}} ldr x17, [x16, #24]
-#DSO-NEXT:  1058: {{.*}} add x16, x16, #24
+#DSO-NEXT:  1054: {{.*}} ldr x17, [x16]
+#DSO-NEXT:  1058: {{.*}} add x16, x16, #0
 #DSO-NEXT:  105c: {{.*}} br x17
 #DSO-NEXT:  1060: {{.*}} adrp x16, #8192
-#DSO-NEXT:  1064: {{.*}} ldr x17, [x16, #32]
-#DSO-NEXT:  1068: {{.*}} add x16, x16, #32
+#DSO-NEXT:  1064: {{.*}} ldr x17, [x16, #8]
+#DSO-NEXT:  1068: {{.*}} add x16, x16, #8
 #DSO-NEXT:  106c: {{.*}} br x17
 
 .globl _start
 _start:
  tbnz w3, #15, _foo
  tbnz w3, #15, _bar
  tbz x6, #45, _foo
  tbz x6, #45, _bar

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: 0x3020
+// CHECK-NEXT: Address: 0x3008
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rela.dyn {
-// CHECK-NEXT:     0x3020 R_X86_64_COPY foo 0x0
+// CHECK-NEXT:     0x3008 R_X86_64_COPY foo 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section (5) .rela.plt {
-// CHECK-NEXT:     0x3018 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x3000 R_X86_64_JUMP_SLOT bar 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // (0x1010 + 0x10) - 0x1005 = 27
-// 0x3020          - 0x100a = 8214
+// 0x3008          - 0x100a = 8190
 
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: _start:
 // DISASM-NEXT:     1000:       e8 1b 00 00 00  callq   27
-// DISASM-NEXT:     1005:       e8 16 20 00 00  callq   8214 <foo>
+// DISASM-NEXT:     1005:       e8 fe 1f 00 00  callq  8190 <foo>

test/ELF/dynamic-reloc-index.s

 // 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:     0x13018 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x13000 R_X86_64_JUMP_SLOT bar 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
         .global foobar
 foobar:
         .global zedx
 zedx:
         .global _start
 _start:
 .quad bar

test/ELF/dynamic-reloc.s

 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x11000
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
 // CHECK-NEXT:     Relocation {
-// CHECK-NEXT:       Offset: 0x13018
+// CHECK-NEXT:       Offset: 0x13000
 // CHECK-NEXT:       Type: R_X86_64_JUMP_SLOT
 // CHECK-NEXT:       Symbol: bar
 // CHECK-NEXT:       Addend: 0x0
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK: DynamicSection [

test/ELF/gnu-ifunc-i386.s

 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: ld.lld -static %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r -symbols -sections %tout | FileCheck %s
 // REQUIRES: x86
 
 // CHECK:      Sections [
 // CHECK:       Section {
 // CHECK:       Index: 1
 // CHECK-NEXT:  Name: .rel.plt
 // CHECK-NEXT:  Type: SHT_REL
 // CHECK-NEXT:  Flags [
 // CHECK-NEXT:    SHF_ALLOC
 // CHECK-NEXT:  ]
 // CHECK-NEXT:  Address: [[RELA:.*]]
-// CHECK-NEXT:  Offset: 0xD4
+// CHECK-NEXT:  Offset: 0xF4
 // CHECK-NEXT:  Size: 16
 // CHECK-NEXT:  Link: 5
 // CHECK-NEXT:  Info: 0
 // CHECK-NEXT:  AddressAlignment: 4
 // CHECK-NEXT:  EntrySize: 8
 // CHECK-NEXT: }
 // CHECK:     Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rel.plt {
-// CHECK-NEXT:     0x1200C R_386_IRELATIVE
-// CHECK-NEXT:     0x12010 R_386_IRELATIVE
+// CHECK-NEXT:     0x12000 R_386_IRELATIVE
+// CHECK-NEXT:     0x12004 R_386_IRELATIVE
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name:
 // CHECK-NEXT:   Value: 0x0
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other: 0
 // CHECK-NEXT:   Section: Undefined
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:   Name: __rel_iplt_end
-// CHECK-NEXT:   Value: 0x100E4
+// CHECK-NEXT:   Value: 0x10104
 // CHECK-NEXT:   Size: 0
 // CHECK-NEXT:   Binding: Local
 // CHECK-NEXT:   Type: None
 // CHECK-NEXT:   Other [
 // CHECK-NEXT:     STV_HIDDEN
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Section: .rel.plt
 // CHECK-NEXT: }

 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT: 11000: c3 retl
 // DISASM:      bar:
 // DISASM-NEXT: 11001: c3 retl
 // DISASM:      _start:
 // DISASM-NEXT:    11002: e8 29 00 00 00 calll 41
 // DISASM-NEXT:    11007: e8 34 00 00 00 calll 52
-// DISASM-NEXT:    1100c: ba d4 00 01 00 movl $65748, %edx
-// DISASM-NEXT:    11011: ba e4 00 01 00 movl $65764, %edx
+// DISASM-NEXT:    1100c: ba f4 00 01 00 movl $65780, %edx
+// DISASM-NEXT:    11011: ba 04 01 01 00 movl $65796, %edx
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:    11020: ff 35 04 20 01 00 pushl 73732
-// DISASM-NEXT:    11026: ff 25 08 20 01 00 jmpl *73736
+// DISASM-NEXT:    11020: ff 35 f8 1f 01 00 pushl 73720
+// DISASM-NEXT:    11026: ff 25 fc 1f 01 00 jmpl *73724
 // DISASM-NEXT:    1102c: 90 nop
 // DISASM-NEXT:    1102d: 90 nop
 // DISASM-NEXT:    1102e: 90 nop
 // DISASM-NEXT:    1102f: 90 nop
-// DISASM-NEXT:    11030: ff 25 0c 20 01 00 jmpl *73740
+// DISASM-NEXT:    11030: ff 25 00 20 01 00 jmpl *73728
 // DISASM-NEXT:    11036: 68 00 00 00 00    pushl $0
 // DISASM-NEXT:    1103b: e9 e0 ff ff ff    jmp -32 <.plt>
-// DISASM-NEXT:    11040: ff 25 10 20 01 00 jmpl *73744
+// DISASM-NEXT:    11040: ff 25 04 20 01 00 jmpl *73732
 // DISASM-NEXT:    11046: 68 08 00 00 00    pushl $8
 // DISASM-NEXT:    1104b: e9 d0 ff ff ff    jmp -48 <.plt>
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret

test/ELF/gnu-ifunc.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld -static %t.o -o %tout
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
 // RUN: llvm-readobj -r -symbols -sections %tout | FileCheck %s
 // REQUIRES: x86
 
 // CHECK:      Sections [
 // CHECK:       Section {
 // CHECK:       Index: 1
 // CHECK-NEXT:  Name: .rela.plt
 // CHECK-NEXT:  Type: SHT_RELA
 // CHECK-NEXT:  Flags [
 // CHECK-NEXT:    SHF_ALLOC
 // CHECK-NEXT:  ]
 // CHECK-NEXT:  Address: [[RELA:.*]]
-// CHECK-NEXT:  Offset: 0x158
+// CHECK-NEXT:  Offset: 0x190
 // CHECK-NEXT:  Size: 48
 // CHECK-NEXT:  Link: 5
 // CHECK-NEXT:  Info: 0
 // CHECK-NEXT:  AddressAlignment: 8
 // CHECK-NEXT:  EntrySize: 24
 // CHECK-NEXT: }
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:     0x12018 R_X86_64_IRELATIVE
-// CHECK-NEXT:     0x12020 R_X86_64_IRELATIVE
+// CHECK-NEXT:     0x12000 R_X86_64_IRELATIVE
+// CHECK-NEXT:     0x12008 R_X86_64_IRELATIVE
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 // CHECK:      Symbols [
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name:
 // CHECK-NEXT:    Value: 0x0
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other: 0
 // CHECK-NEXT:    Section: Undefined
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
 // CHECK-NEXT:    Name: __rela_iplt_end
-// CHECK-NEXT:    Value: 0x10188
+// CHECK-NEXT:    Value: 0x101C0
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Section: .rela.plt
 // CHECK-NEXT:  }

 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: foo:
 // DISASM-NEXT:    11000: c3 retq
 // DISASM:      bar:
 // DISASM-NEXT:    11001: c3 retq
 // DISASM:      _start:
 // DISASM-NEXT:    11002: e8 29 00 00 00 callq 41
 // DISASM-NEXT:    11007: e8 34 00 00 00 callq 52
-// DISASM-NEXT:    1100c: ba 58 01 01 00 movl $65880, %edx
-// DISASM-NEXT:    11011: ba 88 01 01 00 movl $65928, %edx
-// DISASM-NEXT:    11016: ba 89 01 01 00 movl $65929, %edx
+// DISASM-NEXT:    1100c: ba 90 01 01 00 movl $65936, %edx
+// DISASM-NEXT:    11011: ba c0 01 01 00 movl $65984, %edx
+// DISASM-NEXT:    11016: ba c1 01 01 00 movl $65985, %edx
 // DISASM-NEXT: Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:    11020: ff 35 e2 0f 00 00 pushq 4066(%rip)
-// DISASM-NEXT:    11026: ff 25 e4 0f 00 00 jmpq *4068(%rip)
+// DISASM-NEXT:    11020: ff 35 ca 0f 00 00 pushq 4042(%rip)
+// DISASM-NEXT:    11026: ff 25 cc 0f 00 00 jmpq *4044(%rip)
 // DISASM-NEXT:    1102c: 0f 1f 40 00       nopl (%rax)
-// DISASM-NEXT:    11030: ff 25 e2 0f 00 00 jmpq *4066(%rip)
+// DISASM-NEXT:    11030: ff 25 ca 0f 00 00 jmpq *4042(%rip)
 // DISASM-NEXT:    11036: 68 00 00 00 00    pushq $0
 // DISASM-NEXT:    1103b: e9 e0 ff ff ff    jmp -32
-// DISASM-NEXT:    11040: ff 25 da 0f 00 00 jmpq *4058(%rip)
+// DISASM-NEXT:    11040: ff 25 c2 0f 00 00 jmpq *4034(%rip)
 // DISASM-NEXT:    11046: 68 01 00 00 00    pushq $1
 // DISASM-NEXT:    1104b: e9 d0 ff ff ff    jmp -48
 
 .text
 .type foo STT_GNU_IFUNC
 .globl foo
 foo:
  ret

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:  0x13018 R_X86_64_JUMP_SLOT puts 0x0
+; CHECK-NEXT:  0x13000 R_X86_64_JUMP_SLOT puts 0x0
 ; CHECK-NEXT: }
 
 ; CHECK: DynamicSymbols [
 ; CHECK: Symbol {
 ; CHECK:    Name: puts@

test/ELF/mips-26.s

 #                                                    ^-- 0x20040 gotplt[foo0]
 # CHECK-NEXT:   20014:       00 00 00 00     nop
 #
 # CHECK:      loc:
 # CHECK-NEXT:   20018:       00 00 00 00     nop
 # CHECK-NEXT: Disassembly of section .plt:
 # CHECK-NEXT: .plt:
 # CHECK-NEXT:   20020:       3c 1c 00 04     lui     $gp, 4
-# CHECK-NEXT:   20024:       8f 99 00 04     lw      $25, 4($gp)
-# CHECK-NEXT:   20028:       27 9c 00 04     addiu   $gp, $gp, 4
+# CHECK-NEXT:   20024:       8f 99 ff f8     lw $25, -8($gp)
+# CHECK-NEXT:   20028:       27 9c ff f8     addiu   $gp, $gp, -8
 # CHECK-NEXT:   2002c:       03 1c c0 23     subu    $24, $24, $gp
 # CHECK-NEXT:   20030:       03 e0 78 25     move    $15, $ra
 # CHECK-NEXT:   20034:       00 18 c0 82     srl     $24, $24, 2
 # CHECK-NEXT:   20038:       03 20 f8 09     jalr    $25
 # CHECK-NEXT:   2003c:       27 18 ff fe     addiu   $24, $24, -2
 # CHECK-NEXT:   20040:       3c 0f 00 04     lui     $15, 4
-# CHECK-NEXT:   20044:       8d f9 00 0c     lw      $25, 12($15)
+# CHECK-NEXT:   20044:       8d f9 00 00     lw      $25, 0($15)
 # CHECK-NEXT:   20048:       03 20 00 08     jr      $25
-# CHECK-NEXT:   2004c:       25 f8 00 0c     addiu   $24, $15, 12
+# CHECK-NEXT:   2004c:       25 f8 00 00     addiu   $24, $15, 0
 
 # REL:      Name: .plt
 # REL-NEXT: Type: SHT_PROGBITS
 # REL-NEXT: Flags [ (0x6)
 # REL-NEXT:   SHF_ALLOC
 # REL-NEXT:   SHF_EXECINSTR
 # REL-NEXT: ]
 # REL-NEXT: Address: 0x[[PLTADDR:[0-9A-F]+]]

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: 0x3000
+// CHECKDSO-NEXT:     Address: 0x2FE8
 // 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]) = 0x3000 + 3 * 8 = 0x3018
-// CHECKDSO-NEXT:     0x3018 R_AARCH64_JUMP_SLOT foo
+// &(.got.plt[3]) = 0x2FE8 + 3 * 8 = 0x3000
+// CHECKDSO-NEXT:     0x3000 R_AARCH64_JUMP_SLOT foo
 
-// &(.got.plt[4]) = 0x3000 + 4 * 8 = 0x3020
-// CHECKDSO-NEXT:     0x3020 R_AARCH64_JUMP_SLOT bar
+// &(.got.plt[4]) = 0x2FE8 + 4 * 8 = 0x3008
+// CHECKDSO-NEXT:     0x3008 R_AARCH64_JUMP_SLOT bar
 
-// &(.got.plt[5]) = 0x3000 + 5 * 8 = 0x3028
-// CHECKDSO-NEXT:     0x3028 R_AARCH64_JUMP_SLOT weak
+// &(.got.plt[5]) = 0x2FE8 + 5 * 8 = 0x3010
+// CHECKDSO-NEXT:     0x3010 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 = 0x1010
-// DUMPDSO-NEXT:  3000 00000000 00000000 00000000 00000000  ................
-// DUMPDSO-NEXT:  3010 00000000 00000000 10100000 00000000  ................
-// DUMPDSO-NEXT:  3020 10100000 00000000 10100000 00000000  ................
+// DUMPDSO-NEXT:  2fe8 00000000 00000000 00000000 00000000  ................
+// DUMPDSO-NEXT:  2ff8 00000000 00000000 10100000 00000000  ................
+// DUMPDSO-NEXT:  3008 10100000 00000000 10100000 00000000  ................
 
 // DISASMDSO: _start:
 // 0x1030 - 0x1000 = 0x30 = 48
 // DISASMDSO-NEXT:     1000:  0c 00 00 14   b #48
 // 0x1040 - 0x1004 = 0x3c = 60
 // DISASMDSO-NEXT:     1004:  0f 00 00 14   b #60
 // 0x1050 - 0x1008 = 0x48 = 72
 // DISASMDSO-NEXT:     1008:  12 00 00 14   b #72
 
 // DISASMDSO: foo:
 // DISASMDSO-NEXT:     100c:  1f 20 03 d5   nop
 
 // DISASMDSO: Disassembly of section .plt:
 // DISASMDSO-NEXT: .plt:
 // DISASMDSO-NEXT:     1010:  f0 7b bf a9   stp x16, x30, [sp, #-16]!
-// &(.got.plt[2]) = 0x3000 + 2 * 8 = 0x3010
-// Page(0x3010) - Page(0x1014) = 0x3000 - 0x1000 = 0x2000 = 8192
-// DISASMDSO-NEXT:     1014:  10 00 00 d0   adrp  x16, #8192
-// 0x3010 & 0xFFF = 0x10 = 16
-// DISASMDSO-NEXT:     1018:  11 0a 40 f9 ldr x17, [x16, #16]
-// DISASMDSO-NEXT:     101c:  10 42 00 91   add x16, x16, #16
+// &(.got.plt[2]) = 0x2FE8 + 2 * 8 = 0x2FF8
+// Page(0x2FF8) - Page(0x1014) = 0x2000 - 0x1000 = 0x1000 = 4096
+// DISASMDSO-NEXT:     1014:  10 00 00 b0 adrp x16, #4096
+// 0x2FF8 & 0xFFF = 0xFF8 = 4088
+// DISASMDSO-NEXT:     1018:  11 fe 47 f9 ldr x17, [x16, #4088]
+// DISASMDSO-NEXT:     101c:  10 e2 3f 91 add x16, x16, #4088
 // DISASMDSO-NEXT:     1020:  20 02 1f d6   br  x17
 // DISASMDSO-NEXT:     1024:  1f 20 03 d5   nop
 // DISASMDSO-NEXT:     1028:  1f 20 03 d5   nop
 // DISASMDSO-NEXT:     102c:  1f 20 03 d5   nop
 
 // foo@plt
-// Page(0x3018) - Page(0x1030) = 0x3000 - 0x1000 = 0x2000 = 8192
+// Page(0x3000) - Page(0x1030) = 0x3000 - 0x1000 = 0x2000 = 8192
 // DISASMDSO-NEXT:     1030:  10 00 00 d0   adrp  x16, #8192
-// 0x3018 & 0xFFF = 0x18 = 24
-// DISASMDSO-NEXT:     1034:  11 0e 40 f9   ldr x17, [x16, #24]
-// DISASMDSO-NEXT:     1038:  10 62 00 91   add x16, x16, #24
+// 0x3000 & 0xFFF = 0
+// DISASMDSO-NEXT:     1034:  11 02 40 f9   ldr x17, [x16]
+// DISASMDSO-NEXT:     1038:  10 02 00 91 add x16, x16, #0
 // DISASMDSO-NEXT:     103c:  20 02 1f d6   br  x17
 
 // bar@plt
 // Page(0x3020) - Page(0x1040) = 0x3000 - 0x1000 = 0x2000 = 8192
 // DISASMDSO-NEXT:     1040:  10 00 00 d0   adrp  x16, #8192
-// 0x3020 & 0xFFF = 0x20 = 32
-// DISASMDSO-NEXT:     1044:  11 12 40 f9   ldr x17, [x16, #32]
-// DISASMDSO-NEXT:     1048:  10 82 00 91   add x16, x16, #32
+// 0x3008 & 0xFFF = 0x8 = 8
+// DISASMDSO-NEXT:     1044:  11 06 40 f9 ldr x17, [x16, #8]
+// DISASMDSO-NEXT:     1048:  10 22 00 91 add x16, x16, #8
 // DISASMDSO-NEXT:     104c:  20 02 1f d6   br  x17
 
 // weak@plt
-// Page(0x3028) - Page(0x1050) = 0x3000 - 0x1000 = 0x2000 = 8192
+// Page(0x3010) - Page(0x1050) = 0x3000 - 0x1000 = 0x2000 = 8192
 // DISASMDSO-NEXT:     1050:  10 00 00 d0   adrp  x16, #8192
-// 0x3028 & 0xFFF = 0x28 = 40
-// DISASMDSO-NEXT:     1054:  11 16 40 f9   ldr x17, [x16, #40]
-// DISASMDSO-NEXT:     1058:  10 a2 00 91   add x16, x16, #40
+// 0x3010 & 0xFFF = 0x10 = 16
+// DISASMDSO-NEXT:     1054:  11 0a 40 f9   ldr x17, [x16, #16]
+// DISASMDSO-NEXT:     1058:  10 42 00 91   add x16, x16, #16
 // DISASMDSO-NEXT:     105c:  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: 0x11010
 // 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: 0x13000
+// CHECKEXE-NEXT:     Address: 0x12FE8
 // 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]) = 0x13000 + 3 * 8 = 0x13018
-// CHECKEXE-NEXT:     0x13018 R_AARCH64_JUMP_SLOT bar 0x0
+// &(.got.plt[3]) = 0x12FE8 + 3 * 8 = 0x13000
+// CHECKEXE-NEXT:     0x13000 R_AARCH64_JUMP_SLOT bar 0x0
 
-// &(.got.plt[4]) = 0x13000 + 4 * 8 = 0x13020
-// CHECKEXE-NEXT:     0x13020 R_AARCH64_JUMP_SLOT weak 0x0
+// &(.got.plt[4]) = 0x12FE8 + 4 * 8 = 0x13008
+// CHECKEXE-NEXT:     0x13008 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 = 0x11010
-// DUMPEXE-NEXT:  13000 00000000 00000000 00000000 00000000  ................
-// DUMPEXE-NEXT:  13010 00000000 00000000 10100100 00000000  ................
-// DUMPEXE-NEXT:  13020 10100100 00000000                    ........
+// DUMPEXE-NEXT:  12fe8 00000000 00000000 00000000 00000000  ................
+// DUMPEXE-NEXT:  12ff8 00000000 00000000 10100100 00000000  ................
+// DUMPEXE-NEXT:  13008 10100100 00000000                    ........
 
 // DISASMEXE: _start:
 // 0x1100c - 0x11000 = 0xc = 12
 // DISASMEXE-NEXT:    11000:  03 00 00 14   b #12
 // 0x11030 - 0x11004 = 0x2c = 44
 // DISASMEXE-NEXT:    11004:  0b 00 00 14   b #44
 // 0x11040 - 0x11008 = 0x38 = 56
 // DISASMEXE-NEXT:    11008:  0e 00 00 14   b #56
 
 // DISASMEXE: foo:
 // DISASMEXE-NEXT:    1100c:  1f 20 03 d5   nop
 
 // DISASMEXE: Disassembly of section .plt:
 // DISASMEXE-NEXT: .plt:
 // DISASMEXE-NEXT:    11010:  f0 7b bf a9   stp x16, x30, [sp, #-16]!
 // &(.got.plt[2]) = 0x120B0 + 2 * 8 = 0x120C0
-// Page(0x13010) - Page(0x11014) = 0x13000 - 0x11000 = 0x1000 = 8192
-// DISASMEXE-NEXT:    11014:  10 00 00 d0   adrp  x16, #8192
-// 0x120c0 & 0xFFF = 0xC0 = 192
-// DISASMEXE-NEXT:    11018:  11 0a 40 f9   ldr x17, [x16, #16]
-// DISASMEXE-NEXT:    1101c:  10 42 00 91   add x16, x16, #16
+// Page(0x12ff8) - Page(0x11014) = 0x12000 - 0x11000 = 0x1000 = 4096
+// DISASMEXE-NEXT:    11014:  10 00 00 b0 adrp x16, #4096
+// 0x12ff8 & 0xFFF = 0xff8 = 4088
+// DISASMEXE-NEXT:    11018:  11 fe 47 f9   ldr x17, [x16, #4088]
+// DISASMEXE-NEXT:    1101c:  10 e2 3f 91   add x16, x16, #4088
 // DISASMEXE-NEXT:    11020:  20 02 1f d6   br  x17
 // DISASMEXE-NEXT:    11024:  1f 20 03 d5   nop
 // DISASMEXE-NEXT:    11028:  1f 20 03 d5   nop
 // DISASMEXE-NEXT:    1102c:  1f 20 03 d5   nop
 
 // bar@plt
-// Page(0x13018) - Page(0x11030) = 0x12000 - 0x11000 = 0x1000 = 8192
+// Page(0x13000) - Page(0x11030) = 0x12000 - 0x11000 = 0x1000 = 8192
 // DISASMEXE-NEXT:    11030:  10 00 00 d0   adrp  x16, #8192
-// 0x120C8 & 0xFFF = 0xC8 = 200
-// DISASMEXE-NEXT:    11034:  11 0e 40 f9   ldr x17, [x16, #24]
-// DISASMEXE-NEXT:    11038:  10 62 00 91   add x16, x16, #24
+// 0x13000 & 0xFFF = 0x0 = 0
+// DISASMEXE-NEXT:    11034:  11 02 40 f9   ldr x17, [x16]
+// DISASMEXE-NEXT:    11038:  10 02 00 91   add x16, x16, #0
 // DISASMEXE-NEXT:    1103c:  20 02 1f d6   br  x17
 
 // weak@plt
-// Page(0x13020) - Page(0x11040) = 0x12000 - 0x11000 = 0x1000 = 8192
+// Page(0x13008) - Page(0x11040) = 0x12000 - 0x11000 = 0x1000 = 8192
 // DISASMEXE-NEXT:    11040:  10 00 00 d0   adrp  x16, #8192
-// 0x120D0 & 0xFFF = 0xD0 = 208
-// DISASMEXE-NEXT:    11044:  11 12 40 f9   ldr x17, [x16, #32]
-// DISASMEXE-NEXT:    11048:  10 82 00 91   add x16, x16, #32
+// 0x13008 & 0xFFF = 0x8 = 8
+// DISASMEXE-NEXT:    11044:  11 06 40 f9   ldr x17, [x16, #8]
+// DISASMEXE-NEXT:    11048:  10 22 00 91   add x16, x16, #8
 // DISASMEXE-NEXT:    1104c:  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

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: 0x13000
-// CHECK-NEXT: Offset: 0x3000
+// CHECK-NEXT: Address: 0x12FF4
+// CHECK-NEXT: Offset: 0x2FF4
 // CHECK-NEXT: Size: 20
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize: 0
 
-// 0x13000 + got.plt.reserved(12) = 0x1300C
-// 0x13000 + got.plt.reserved(12) + 4 = 0x13010
+// 0x12FF4 + got.plt.reserved(12) = 0x13000
+// 0x12FF4 + got.plt.reserved(12) + 4 = 0x13004
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rel.plt {
-// CHECK-NEXT:     0x1300C R_386_JUMP_SLOT bar 0x0
-// CHECK-NEXT:     0x13010 R_386_JUMP_SLOT zed 0x0
+// CHECK-NEXT:     0x13000 R_386_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x13004 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]
 // (0x11010 + 16) - (0x11000 + 1) - 4 = 27
 // (0x11010 + 16) - (0x11005 + 1) - 4 = 22
 // (0x11020 + 16) - (0x1100a + 1) - 4 = 33
 
 // DISASM:       local:
 // DISASM-NEXT:  11000: {{.*}}
 // DISASM-NEXT:  11002: {{.*}}
 // DISASM:       _start:
 // 0x11013 + 5 - 24 = 0x11000
 // DISASM-NEXT: 11004: e9 27 00 00 00 jmp 39
 // DISASM-NEXT: 11009: e9 22 00 00 00 jmp 34
 // DISASM-NEXT: 1100e: e9 2d 00 00 00 jmp 45
 // DISASM-NEXT: 11013: e9 e8 ff ff ff jmp -24
 
 // 0x11010 - 0x1102b - 5 = -32
 // 0x11010 - 0x1103b - 5 = -48
-// 77828 = 0x13004 = .got.plt (0x13000) + 4
-// 77832 = 0x13008 = .got.plt (0x13000) + 8
-// 77836 = 0x1300C = .got.plt (0x13000) + got.plt.reserved(12)
-// 77840 = 0x13010 = .got.plt (0x13000) + got.plt.reserved(12) + 4
+// 77816 = 0x12FF8 = .got.plt (0x12FF4) + 4
+// 77820 = 0x12FFC = .got.plt (0x12FF4) + 8
+// 77824 = 0x13000 = .got.plt (0x12FF4) + got.plt.reserved(12)
+// 77828 = 0x13004 = .got.plt (0x12FF4) + got.plt.reserved(12) + 4
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:    11020: ff 35 04 30 01 00 pushl 77828
-// DISASM-NEXT:    11026: ff 25 08 30 01 00 jmpl *77832
+// DISASM-NEXT:    11020: ff 35 f8 2f 01 00 pushl 77816
+// DISASM-NEXT:    11026: ff 25 fc 2f 01 00 jmpl *77820
 // DISASM-NEXT:    1102c: 90 nop
 // DISASM-NEXT:    1102d: 90 nop
 // DISASM-NEXT:    1102e: 90 nop
 // DISASM-NEXT:    1102f: 90 nop
-// DISASM-NEXT:    11030: ff 25 0c 30 01 00 jmpl *77836
+// DISASM-NEXT:    11030: ff 25 00 30 01 00 jmpl *77824
 // DISASM-NEXT:    11036: 68 00 00 00 00 pushl $0
 // DISASM-NEXT:    1103b: e9 e0 ff ff ff jmp -32 <.plt>
-// DISASM-NEXT:    11040: ff 25 10 30 01 00 jmpl *77840
+// DISASM-NEXT:    11040: ff 25 04 30 01 00 jmpl *77828
 // DISASM-NEXT:    11046: 68 08 00 00 00 pushl $8
 // DISASM-NEXT:    1104b: 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: 0x3000
-// CHECKSHARED-NEXT:   Offset: 0x3000
+// CHECKSHARED-NEXT:   Address: 0x2FF4
+// CHECKSHARED-NEXT:   Offset: 0x2FF4
 // CHECKSHARED-NEXT:   Size: 20
 // CHECKSHARED-NEXT:   Link: 0
 // CHECKSHARED-NEXT:   Info: 0
 // CHECKSHARED-NEXT:   AddressAlignment: 4
 // CHECKSHARED-NEXT:   EntrySize: 0
 // CHECKSHARED-NEXT:   }
 
-// 0x3000 + got.plt.reserved(12) = 0x300C
-// 0x3000 + got.plt.reserved(12) + 4 = 0x3010
+// 0x2FF4 + got.plt.reserved(12) = 0x3000
+// 0x2FF4 + got.plt.reserved(12) + 4 = 0x3004
 // CHECKSHARED:        Relocations [
 // CHECKSHARED-NEXT:     Section ({{.*}}) .rel.plt {
-// CHECKSHARED-NEXT:       0x300C R_386_JUMP_SLOT bar 0x0
-// CHECKSHARED-NEXT:       0x3010 R_386_JUMP_SLOT zed 0x0
+// CHECKSHARED-NEXT:       0x3000 R_386_JUMP_SLOT bar 0x0
+// CHECKSHARED-NEXT:       0x3004 R_386_JUMP_SLOT zed 0x0
 // CHECKSHARED-NEXT:     }
 // CHECKSHARED-NEXT:   ]
 
 // DISASMSHARED:       local:
 // DISASMSHARED-NEXT:  1000: {{.*}}
 // DISASMSHARED-NEXT:  1002: {{.*}}
 // DISASMSHARED:       _start:
 // 0x1013 + 5 - 24 = 0x1000

 // DISASMPIE:      Disassembly of section .plt:
 // DISASMPIE-NEXT: .plt:
 // DISASMPIE-NEXT:   1020:  ff b3 04 00 00 00 pushl 4(%ebx)
 // DISASMPIE-NEXT:   1026:  ff a3 08 00 00 00 jmpl *8(%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 30 00 00 jmpl *12300(%ebx)
+// DISASMPIE-NEXT:   1030:  ff a3 00 30 00 00 jmpl *12288(%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 30 00 00 jmpl *12304(%ebx)
+// DISASMPIE-NEXT:   1040:  ff a3 04 30 00 00 jmpl *12292(%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

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:     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:     0x3000 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x3008 R_X86_64_JUMP_SLOT zed 0x0
+// CHECK-NEXT:     0x3010 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: 0x11020
 // 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:     0x13018 R_X86_64_JUMP_SLOT bar 0x0
-// CHECK2-NEXT:     0x13020 R_X86_64_JUMP_SLOT zed 0x0
+// CHECK2-NEXT:     0x13000 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK2-NEXT:     0x13008 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
 
-// 0x3018 - 0x1036  = 8162
-// 0x3020 - 0x1046  = 4234
-// 0x3028 - 0x1056  = 4226
+// 0x3000 - 0x1036  = 8138
+// 0x3008 - 0x1046  = 8130
+// 0x3010 - 0x1056  = 8122
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// 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:   1020:  ff 35 ca 1f 00 00  pushq 8138(%rip)
+// DISASM-NEXT:   1026:  ff 25 cc 1f 00 00  jmpq *8140(%rip)
 // DISASM-NEXT:   102c:  0f 1f 40 00        nopl (%rax)
-// DISASM-NEXT:   1030:  ff 25 e2 1f 00 00  jmpq *8162(%rip)
+// DISASM-NEXT:   1030:  ff 25 ca 1f 00 00  jmpq *8138(%rip)
 // DISASM-NEXT:   1036:  68 00 00 00 00     pushq $0
 // DISASM-NEXT:   103b:  e9 e0 ff ff ff     jmp -32 <.plt>
-// DISASM-NEXT:   1040:  ff 25 da 1f 00 00  jmpq *8154(%rip)
+// DISASM-NEXT:   1040:  ff 25 c2 1f 00 00  jmpq *8130(%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 1f 00 00  jmpq *8146(%rip)
+// DISASM-NEXT:   1050:  ff 25 ba 1f 00 00  jmpq *8122(%rip)
 // DISASM-NEXT:   1056:  68 02 00 00 00     pushq $2
 // DISASM-NEXT:   105b:  e9 c0 ff ff ff     jmp -64 <.plt>
 
 // 0x11030 - (0x11000 + 1) - 4 = 43
 // 0x11030 - (0x11005 + 1) - 4 = 38
 // 0x11040 - (0x1100a + 1) - 4 = 49
 // 0x11000 - (0x1100f + 1) - 4 = -20
 
 // DISASM2:      _start:
 // DISASM2-NEXT:   11000:  e9 {{.*}}     jmp  43
 // DISASM2-NEXT:   11005:  e9 {{.*}}     jmp  38
 // DISASM2-NEXT:   1100a:  e9 {{.*}}     jmp  49
 // DISASM2-NEXT:   1100f:  e9 {{.*}}     jmp  -20
 
-// 0x13018 - 0x11036  = 4242
-// 0x13020 - 0x11046  = 4234
+// 0x13000 - 0x11036  = 8138
+// 0x13008 - 0x11046  = 4234
 
 // DISASM2:      Disassembly of section .plt:
 // DISASM2-NEXT: .plt:
-// DISASM2-NEXT:  11020:  ff 35 e2 1f 00 00   pushq 8162(%rip)
-// DISASM2-NEXT:  11026:  ff 25 e4 1f 00 00   jmpq *8164(%rip)
+// DISASM2-NEXT:  11020:  ff 35 ca 1f 00 00   pushq 8138(%rip)
+// DISASM2-NEXT:  11026:  ff 25 cc 1f 00 00   jmpq *8140(%rip)
 // DISASM2-NEXT:  1102c:  0f 1f 40 00         nopl  (%rax)
-// DISASM2-NEXT:  11030:  ff 25 e2 1f 00 00   jmpq *8162(%rip)
+// DISASM2-NEXT:  11030:  ff 25 ca 1f 00 00   jmpq *8138(%rip)
 // DISASM2-NEXT:  11036:  68 00 00 00 00      pushq $0
 // DISASM2-NEXT:  1103b:  e9 e0 ff ff ff      jmp -32 <.plt>
-// DISASM2-NEXT:  11040:  ff 25 da 1f 00 00   jmpq *8154(%rip)
+// DISASM2-NEXT:  11040:  ff 25 c2 1f 00 00   jmpq *8130(%rip)
 // DISASM2-NEXT:  11046:  68 01 00 00 00      pushq $1
 // DISASM2-NEXT:  1104b:  e9 d0 ff ff ff      jmp -48 <.plt>
 // DISASM2-NOT:   110C0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

test/ELF/relocation.s

 // SEC-NEXT: }
 
 // 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: 0x13000
-// SEC-NEXT:   Offset: 0x3000
+// SEC-NEXT:   Address: 0x12FE8
+// SEC-NEXT:   Offset: 0x2FE8
 // SEC-NEXT:   Size: 40
 // SEC-NEXT:   Link: 0
 // SEC-NEXT:   Info: 0
 // SEC-NEXT:   AddressAlignment: 8
 // SEC-NEXT:   EntrySize: 0
 // SEC-NEXT:   }
 
 .section       .text,"ax",@progbits,unique,1

test/ELF/relro.s

 // PARTRELRO-NEXT:  Info: 0
 // PARTRELRO-NEXT:  AddressAlignment: 8
 // PARTRELRO-NEXT:  EntrySize: 0
 // PARTRELRO-NEXT:  SectionData (
 // PARTRELRO-NEXT:    0000:
 // PARTRELRO-NEXT:  )
 // PARTRELRO-NEXT:  }
 // PARTRELRO-NEXT:  Section {
-// PARTRELRO-NEXT:  Index: 10
-// PARTRELRO-NEXT:  Name: .data
-// PARTRELRO-NEXT:  Type: SHT_PROGBITS
-// PARTRELRO-NEXT:  Flags [
-// PARTRELRO-NEXT:    SHF_ALLOC
-// PARTRELRO-NEXT:    SHF_WRITE
-// PARTRELRO-NEXT:  ]
-// PARTRELRO-NEXT:  Address: 0x13000
-// PARTRELRO-NEXT:  Offset: 0x3000
-// PARTRELRO-NEXT:  Size: 12
-// PARTRELRO-NEXT:  Link: 0
-// PARTRELRO-NEXT:  Info: 0
-// PARTRELRO-NEXT:  AddressAlignment: 1
-// PARTRELRO-NEXT:  EntrySize: 0
-// PARTRELRO-NEXT:  SectionData (
-// PARTRELRO-NEXT:    0000:
-// PARTRELRO-NEXT:  )
+// PARTRELRO-NEXT:    Index: 10
+// PARTRELRO-NEXT:    Name: .got.plt
+// PARTRELRO-NEXT:    Type: SHT_PROGBITS
+// PARTRELRO-NEXT:    Flags [
+// PARTRELRO-NEXT:      SHF_ALLOC
+// PARTRELRO-NEXT:      SHF_WRITE
+// PARTRELRO-NEXT:    ]
+// PARTRELRO-NEXT:    Address: 0x12FE8
+// PARTRELRO-NEXT:    Offset: 0x2FE8
+// PARTRELRO-NEXT:    Size: 32
+// PARTRELRO-NEXT:    Link: 0
+// PARTRELRO-NEXT:    Info: 0
+// PARTRELRO-NEXT:    AddressAlignment: 8
+// PARTRELRO-NEXT:    EntrySize: 0
+// PARTRELRO-NEXT:    SectionData (
+// PARTRELRO-NEXT:      0000:
+// PARTRELRO-NEXT:      0010:
+// PARTRELRO-NEXT:    )
 // PARTRELRO-NEXT:  }
 // PARTRELRO-NEXT:  Section {
-// PARTRELRO-NEXT:    Index: 11
-// PARTRELRO-NEXT:    Name: .foo
-// PARTRELRO-NEXT:    Type: SHT_PROGBITS
-// PARTRELRO-NEXT:    Flags [
-// PARTRELRO-NEXT:      SHF_ALLOC
-// PARTRELRO-NEXT:      SHF_WRITE
-// PARTRELRO-NEXT:    ]
-// PARTRELRO-NEXT:    Address: 0x1300C
-// PARTRELRO-NEXT:    Offset: 0x300C
-// PARTRELRO-NEXT:    Size: 0
-// PARTRELRO-NEXT:    Link: 0
-// PARTRELRO-NEXT:    Info: 0
-// PARTRELRO-NEXT:    AddressAlignment: 1
-// PARTRELRO-NEXT:    EntrySize: 0
-// PARTRELRO-NEXT:    SectionData (
-// PARTRELRO-NEXT:    )
+// PARTRELRO-NEXT:  Index: 11
+// PARTRELRO-NEXT:  Name: .data
+// PARTRELRO-NEXT:  Type: SHT_PROGBITS
+// PARTRELRO-NEXT:  Flags [
+// PARTRELRO-NEXT:    SHF_ALLOC
+// PARTRELRO-NEXT:    SHF_WRITE
+// PARTRELRO-NEXT:  ]
+// PARTRELRO-NEXT:  Address: 0x13008
+// PARTRELRO-NEXT:  Offset: 0x3008
+// PARTRELRO-NEXT:  Size: 12
+// PARTRELRO-NEXT:  Link: 0
+// PARTRELRO-NEXT:  Info: 0
+// PARTRELRO-NEXT:  AddressAlignment: 1
+// PARTRELRO-NEXT:  EntrySize: 0
+// PARTRELRO-NEXT:  SectionData (
+// PARTRELRO-NEXT:    0000:
+// PARTRELRO-NEXT:  )
 // PARTRELRO-NEXT:  }
 // PARTRELRO-NEXT:  Section {
 // PARTRELRO-NEXT:    Index: 12
-// PARTRELRO-NEXT:    Name: .got.plt
+// PARTRELRO-NEXT:    Name: .foo
 // PARTRELRO-NEXT:    Type: SHT_PROGBITS
 // PARTRELRO-NEXT:    Flags [
 // PARTRELRO-NEXT:      SHF_ALLOC
 // PARTRELRO-NEXT:      SHF_WRITE
 // PARTRELRO-NEXT:    ]
-// PARTRELRO-NEXT:    Address: 0x13010
-// PARTRELRO-NEXT:    Offset: 0x3010
-// PARTRELRO-NEXT:    Size: 32
+// PARTRELRO-NEXT:    Address: 0x13014
+// PARTRELRO-NEXT:    Offset: 0x3014
+// PARTRELRO-NEXT:    Size: 0
 // PARTRELRO-NEXT:    Link: 0
 // PARTRELRO-NEXT:    Info: 0
-// PARTRELRO-NEXT:    AddressAlignment: 8
+// PARTRELRO-NEXT:    AddressAlignment: 1
 // PARTRELRO-NEXT:    EntrySize: 0
 // PARTRELRO-NEXT:    SectionData (
-// PARTRELRO-NEXT:      0000:
-// PARTRELRO-NEXT:      0010:
 // PARTRELRO-NEXT:    )
 // PARTRELRO-NEXT:  }
 // PARTRELRO-NEXT:  Section {
 // PARTRELRO-NEXT:    Index: 13
 // PARTRELRO-NEXT:    Name: .bss
 // PARTRELRO-NEXT:    Type: SHT_NOBITS
 // PARTRELRO-NEXT:    Flags [
 // PARTRELRO-NEXT:      SHF_ALLOC
 // PARTRELRO-NEXT:      SHF_WRITE
 // PARTRELRO-NEXT:    ]
-// PARTRELRO-NEXT:    Address: 0x13030
-// PARTRELRO-NEXT:    Offset: 0x3030
+// PARTRELRO-NEXT:    Address: 0x13014
+// PARTRELRO-NEXT:    Offset: 0x3014
 // PARTRELRO-NEXT:    Size: 0
 // PARTRELRO-NEXT:    Link: 0
 // PARTRELRO-NEXT:    Info: 0
 // PARTRELRO-NEXT:    AddressAlignment: 1
 // PARTRELRO-NEXT:    EntrySize: 0
 // PARTRELRO-NEXT:  }
 // PARTRELRO:       ProgramHeader {
 // PARTRELRO:       Type: PT_LOAD
 // PARTRELRO:       Offset: 0x2000
 // PARTRELRO-NEXT:  VirtualAddress: [[RWADDR:.*]]
 // PARTRELRO-NEXT:  PhysicalAddress:
-// PARTRELRO-NEXT:  FileSize: 4144
-// PARTRELRO-NEXT:  MemSize: 4144
+// PARTRELRO-NEXT:  FileSize: 4116
+// PARTRELRO-NEXT:  MemSize: 4116
 // PARTRELRO-NEXT:  Flags [
 // PARTRELRO-NEXT:    PF_R (0x4)
 // PARTRELRO-NEXT:    PF_W (0x2)
 // PARTRELRO-NEXT:  ]
 // PARTRELRO-NEXT:  Alignment: 4096
 // PARTRELRO:       Type: PT_GNU_RELRO
 // PARTRELRO-NEXT:  Offset: 0x2000
 // PARTRELRO-NEXT:  VirtualAddress: [[RWADDR]]
 // PARTRELRO-NEXT:  PhysicalAddress:
-// PARTRELRO-NEXT:  FileSize: 248
-// PARTRELRO-NEXT:  MemSize: 248
+// PARTRELRO-NEXT:  FileSize: 4096
+// PARTRELRO-NEXT:  MemSize: 4096
 // PARTRELRO-NEXT:  Flags [
 // PARTRELRO-NEXT:    PF_R
 // PARTRELRO-NEXT:  ]
 // PARTRELRO-NEXT:  Alignment: 1
 
 // NORELRO:     ProgramHeaders [
 // NORELRO-NOT: PT_GNU_RELRO
 

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: 0x11010
 
 // CHECK:      Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:   0x13000 R_X86_64_64 foo 0x0
+// CHECK-NEXT:   0x13008 R_X86_64_64 foo 0x0
 // CHECK-NEXT: }
 // CHECK-NEXT: Section ({{.*}}) .rela.plt {
-// CHECK-NEXT:   0x13020 R_X86_64_JUMP_SLOT set_data 0x0
+// CHECK-NEXT:   0x13000 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