[ELF] Change GOT*_FROM_END (relative to end(.got)) to GOTPLT* (start(.got.plt))

[MaskRay]

Summary

This should address remaining issues discussed in PR36555.

Currently R_GOT*_FROM_END are exclusively used by x86 and x86_64 to
express relocations types relative to the GOT base. We have
_GLOBAL_OFFSET_TABLE_ (GOT base) = start(.got.plt) but end(.got) !=
start(.got.plt)

This can have problems when _GLOBAL_OFFSET_TABLE_ is used as a symbol, e.g.
glibc dl_machine_dynamic assumes _GLOBAL_OFFSET_TABLE_ is start(.got.plt),
which is not true.

extern const ElfW(Addr) _GLOBAL_OFFSET_TABLE_[] attribute_hidden;
return _GLOBAL_OFFSET_TABLE_[0]; // R_X86_64_GOTPC32

In this patch, we

• Change all GOT*_FROM_END to GOTPLT* to fix the problem.
• Add HasGotPltOffRel to denote whether .got.plt should be kept even if the section is empty.
• Simply GotSection::empty and GotPltSection::empty a bit by setting HasGotOffRel and HasGotPltOffRel early.

The change of R_386_GOTPC makes X86::writePltHeader simpler as we don't
have to compute the offset start(.got.plt) - Ebx (it is constant 0).

We still diverge from ld.bfd (at least in most cases) and gold in that
.got.plt and .got are not adjacent, but the advantage doing that is
unclear.

[MaskRay]

Improve 3 tests

[ruiu]

ELF/Arch/X86.cpp

195–197

Is this comment still correct? You are no longer modifying these instructions' operands, so I'm guessing they now have different operands.

[MaskRay]

ELF/Arch/X86.cpp

195–197

Ebx = GotPlt now so the 4 lines below can be deleted.

test/ELF/plt-i686.s

148–149

llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp cannot recognize our unusual GOT base (end(.got)). It is good now :)

// The jmp instruction at the beginning of each PLT entry jumps to the
// address of the base of the .got.plt section plus the immediate.
uint32_t Imm = support::endian::read32le(PltContents.data() + Byte + 2);
Result.push_back(
    std::make_pair(PltSectionVA + Byte, GotPltSectionVA + Imm));
Byte += 6;

[ruiu]

ELF/Arch/X86.cpp

195–197

Then I guess you need to update that comment to

pushl 4(%ebx)
jmp *8(%ebx)

no?

[MaskRay]

Update the comment to

pushl 4(%ebx)
jmp *8(%ebx)

[MaskRay]

.

[ruiu]

I don't remember why we defined _FROM_END relocation types in the first place. That was done by Rafael. It looks to me that this change is looking generally good. I hope there's no hidden reason we did that at that time...

ELF/Relocations.cpp

1073–1075

Is this logically x86-64 only? I think it is fine to create a .got when you create .got.plt, but the comment should explain that.

ELF/Relocations.h

34–35

Sort.

[sivachandra]

ELF/Relocations.cpp

1073–1075

One need not emit .got even if emitting .got.plt. For example, for non-PIE but statically linked excutables, ld.bfd does not emit .got but still emits .got.plt.

That said, I am not sure if not emitting a .got (when emitting .got.plt) for other kinds of executables is a good/bad thing. IMO, emitting a .got even when not required will only add a few bytes at most.

[MaskRay]

ELF/Relocations.cpp

1073–1075

R_GOTPLT, R_GOTPLTONLY_PC, and R_GOTPLTREL are x86-32 x86-64 only. It currently emits .got because we need to compute the distance between .got and .got.plt. The empty .got will serve as an anchor.

I read some history in the past and I remember that *_FROM_END was chosen to make the GOT base in the middle of .got

AMD64 psABI p.75

The symbol _GLOBAL_OFFSET_TABLE_ may reside in the middle of the .got section,

allowing both negative and non-negative offsets into the array of addresses.

But in reality that rule doesn't have to be followed strictly.. @sivachandra mentioned https://fedoraproject.org/wiki/Changes/.got.plt_Isolation Now I'm thinking ld.bfd may in some configuration allow .got and .got.plt to be separated. If that is true, The start of .got.plt would still be the GOT base as end(.got) would break things...

[MaskRay]

Update

[sivachandra]

ELF/Relocations.cpp

1073–1075

Note that the ABI doc does not prescribe .got.plt. In fact, AFAICT, there is no mention of such a section in the doc.

The way I view/interpret it is this:

1. .got.plt is a section which linkers have been emitting as a convenient logical separation: everything .got pertains to global variables, and every thing after that supports .plt.
2. As a convention, they have been making the address of GOT = start(.got.plt)
3. So, by placing .got.plt right after .got, they still adhere to the ABI which says GOT may reside in the middle of .got. That is, .got.plt is merely an extension of .got.

Just curious, for what purposes does one need to compute the distance between .got and .got.plt?

[MaskRay]

Update code/tests related to R_GOTPLT R_TLSGD_GOTPLT

[MaskRay]

Simplify In.GotPlt->HasGotPltOffRel = true; after reading the interaction again...

[MaskRay]

This gives me more confidence..

ninja -C Release clang lld  # build lld with this change

cmake -GNinja -H. -BGOT -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=$HOME/llvm/Release/bin/clang++ -DCMAKE_C_COMPILER=$HOME/llvm/Release/bin/clang -DLLVM_ENABLE_LLD=On -DLLVM_INCLUDE_GO_TESTS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DBUILD_SHARED_LIBS=On
ninja -C GOT check-all  # all (llvm+clang+extra+lld+compiler-rt) passed

[MaskRay]

In D59594#1439028, @MaskRay wrote:

This gives me more confidence..

ninja -C Release clang lld  # build lld with this change

cmake -GNinja -H. -BGOT -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=$HOME/llvm/Release/bin/clang++ -DCMAKE_C_COMPILER=$HOME/llvm/Release/bin/clang -DLLVM_ENABLE_LLD=On -DLLVM_INCLUDE_GO_TESTS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DBUILD_SHARED_LIBS=On
ninja -C GOT check-all  # all (llvm+clang+extra+lld+compiler-rt) passed

I've tested this patch on our internal code base and I don't find any issues.

[ruiu]

LGTM

Let's give it a shot. Thank you for doing this.

ELF/Arch/X86.cpp

RelExpr X86::getRelExpr(RelType Type, const Symbol &S,
 
   switch (Type) {
   case R_386_8:
   case R_386_16:
   case R_386_32:
   case R_386_TLS_LDO_32:
     return R_ABS;
   case R_386_TLS_GD:
-    return R_TLSGD_GOT_FROM_END;
+    return R_TLSGD_GOTPLT;
   case R_386_TLS_LDM:
-    return R_TLSLD_GOT_FROM_END;
+    return R_TLSLD_GOTPLT;
   case R_386_PLT32:
     return R_PLT_PC;
   case R_386_PC8:
   case R_386_PC16:
   case R_386_PC32:
     return R_PC;
   case R_386_GOTPC:
-    return R_GOTONLY_PC_FROM_END;
+    return R_GOTPLTONLY_PC;
   case R_386_TLS_IE:
     return R_GOT;
   case R_386_GOT32:
   case R_386_GOT32X:
     // These relocations are arguably mis-designed because their calculations
     // depend on the instructions they are applied to. This is bad because we
     // usually don't care about whether the target section contains valid
     // machine instructions or not. But this is part of the documented ABI, so
case R_386_GOT32X:
     // It's unfortunate that compilers emit the same relocation for these
     // different use cases. In order to distinguish them, we have to read a
     // machine instruction.
     //
     // The following code implements it. We assume that Loc[0] is the first byte
     // of a displacement or an immediate field of a valid machine
     // instruction. That means a ModRM byte is at Loc[-1]. By taking a look at
     // the byte, we can determine whether the instruction uses the operand as an
-    // absolute address (R_GOT) or a register-relative address (R_GOT_FROM_END).
-    return (Loc[-1] & 0xc7) == 0x5 ? R_GOT : R_GOT_FROM_END;
+    // absolute address (R_GOT) or a register-relative address (R_GOTPLT).
+    return (Loc[-1] & 0xc7) == 0x5 ? R_GOT : R_GOTPLT;
   case R_386_TLS_GOTIE:
-    return R_GOT_FROM_END;
+    return R_GOTPLT;
   case R_386_GOTOFF:
-    return R_GOTREL_FROM_END;
+    return R_GOTPLTREL;
   case R_386_TLS_LE:
     return R_TLS;
   case R_386_TLS_LE_32:
     return R_NEG_TLS;
   case R_386_NONE:
     return R_NONE;
   default:
     error(getErrorLocation(Loc) + "unknown relocation (" + Twine(Type) +
if (Type == R_386_TLS_LE)
     return R_386_TLS_TPOFF;
   if (Type == R_386_TLS_LE_32)
     return R_386_TLS_TPOFF32;
   return Type;
 }
 
 void X86::writePltHeader(uint8_t *Buf) const {
   if (Config->Pic) {
     const uint8_t V[] = {
-        0xff, 0xb3, 0x04, 0x00, 0x00, 0x00, // pushl GOTPLT+4(%ebx)
-        0xff, 0xa3, 0x08, 0x00, 0x00, 0x00, // jmp *GOTPLT+8(%ebx)
+        0xff, 0xb3, 0x04, 0x00, 0x00, 0x00, // pushl 4(%ebx)
+        0xff, 0xa3, 0x08, 0x00, 0x00, 0x00, // jmp *8(%ebx)
         0x90, 0x90, 0x90, 0x90              // nop
     };
     memcpy(Buf, V, sizeof(V));
-
-    uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
-    uint32_t GotPlt = In.GotPlt->getVA() - Ebx;
-    write32le(Buf + 2, GotPlt + 4);
-    write32le(Buf + 8, GotPlt + 8);
     return;
   }
 
   const uint8_t PltData[] = {
       0xff, 0x35, 0, 0, 0, 0, // pushl (GOTPLT+4)
       0xff, 0x25, 0, 0, 0, 0, // jmp *(GOTPLT+8)
       0x90, 0x90, 0x90, 0x90, // nop
   };
const uint8_t Inst[] = {
       0xff, 0x00, 0, 0, 0, 0, // jmp *foo_in_GOT or jmp *foo@GOT(%ebx)
       0x68, 0, 0, 0, 0,       // pushl $reloc_offset
       0xe9, 0, 0, 0, 0,       // jmp .PLT0@PC
   };
   memcpy(Buf, Inst, sizeof(Inst));
 
   if (Config->Pic) {
     // jmp *foo@GOT(%ebx)
-    uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
+    uint32_t Ebx = In.GotPlt->getVA();
     Buf[1] = 0xa3;
     write32le(Buf + 2, GotPltEntryAddr - Ebx);
   } else {
     // jmp *foo_in_GOT
     Buf[1] = 0x25;
     write32le(Buf + 2, GotPltEntryAddr);
   }
 

 }
 
 void RetpolinePic::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
   write32le(Buf, S.getPltVA() + 17);
 }
 
 void RetpolinePic::writePltHeader(uint8_t *Buf) const {
   const uint8_t Insn[] = {
-      0xff, 0xb3, 0,    0,    0,    0,          // 0:    pushl GOTPLT+4(%ebx)
+      0xff, 0xb3, 4,    0,    0,    0,          // 0:    pushl 4(%ebx)
       0x50,                                     // 6:    pushl %eax
-      0x8b, 0x83, 0,    0,    0,    0,          // 7:    mov GOTPLT+8(%ebx), %eax
+      0x8b, 0x83, 8,    0,    0,    0,          // 7:    mov 8(%ebx), %eax
       0xe8, 0x0e, 0x00, 0x00, 0x00,             // d:    call next
       0xf3, 0x90,                               // 12: loop: pause
       0x0f, 0xae, 0xe8,                         // 14:   lfence
       0xeb, 0xf9,                               // 17:   jmp loop
       0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // 19:   int3; .align 16
       0x89, 0x0c, 0x24,                         // 20: next: mov %ecx, (%esp)
       0x8b, 0x4c, 0x24, 0x04,                   // 23:   mov 0x4(%esp), %ecx
       0x89, 0x44, 0x24, 0x04,                   // 27:   mov %eax ,0x4(%esp)
       0x89, 0xc8,                               // 2b:   mov %ecx, %eax
       0x59,                                     // 2d:   pop %ecx
       0xc3,                                     // 2e:   ret
       0xcc,                                     // 2f:   int3; padding
   };
   memcpy(Buf, Insn, sizeof(Insn));
-
-  uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
-  uint32_t GotPlt = In.GotPlt->getVA() - Ebx;
-  write32le(Buf + 2, GotPlt + 4);
-  write32le(Buf + 9, GotPlt + 8);
 }
 
 void RetpolinePic::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
                             uint64_t PltEntryAddr, int32_t Index,
                             unsigned RelOff) const {
   const uint8_t Insn[] = {
       0x50,                            // pushl %eax
       0x8b, 0x83, 0,    0,    0,    0, // mov foo@GOT(%ebx), %eax
       0xe8, 0,    0,    0,    0,       // call plt+0x20
       0xe9, 0,    0,    0,    0,       // jmp plt+0x12
       0x68, 0,    0,    0,    0,       // pushl $reloc_offset
       0xe9, 0,    0,    0,    0,       // jmp plt+0
       0xcc, 0xcc, 0xcc, 0xcc, 0xcc,    // int3; padding
   };
   memcpy(Buf, Insn, sizeof(Insn));
 
-  uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
+  uint32_t Ebx = In.GotPlt->getVA();
   unsigned Off = getPltEntryOffset(Index);
   write32le(Buf + 3, GotPltEntryAddr - Ebx);
   write32le(Buf + 8, -Off - 12 + 32);
   write32le(Buf + 13, -Off - 17 + 18);
   write32le(Buf + 18, RelOff);
   write32le(Buf + 23, -Off - 27);
 }
 

ELF/Arch/X86_64.cpp

case R_X86_64_PLT32:
     return R_PLT_PC;
   case R_X86_64_PC8:
   case R_X86_64_PC16:
   case R_X86_64_PC32:
   case R_X86_64_PC64:
     return R_PC;
   case R_X86_64_GOT32:
   case R_X86_64_GOT64:
-    return R_GOT_FROM_END;
+    return R_GOTPLT;
   case R_X86_64_GOTPCREL:
   case R_X86_64_GOTPCRELX:
   case R_X86_64_REX_GOTPCRELX:
   case R_X86_64_GOTTPOFF:
     return R_GOT_PC;
   case R_X86_64_GOTOFF64:
-    return R_GOTREL_FROM_END;
+    return R_GOTPLTREL;
   case R_X86_64_GOTPC32:
   case R_X86_64_GOTPC64:
-    return R_GOTONLY_PC_FROM_END;
+    return R_GOTPLTONLY_PC;
   case R_X86_64_NONE:
     return R_NONE;
   default:
     error(getErrorLocation(Loc) + "unknown relocation (" + Twine(Type) +
           ") against symbol " + toString(S));
     return R_NONE;
   }
 }

ELF/InputSection.cpp

case R_ADDEND:
     return A;
   case R_ARM_SBREL:
     return Sym.getVA(A) - getARMStaticBase(Sym);
   case R_GOT:
   case R_RELAX_TLS_GD_TO_IE_ABS:
     return Sym.getGotVA() + A;
   case R_GOTONLY_PC:
     return In.Got->getVA() + A - P;
-  case R_GOTONLY_PC_FROM_END:
-    return In.Got->getVA() + A - P + In.Got->getSize();
+  case R_GOTPLTONLY_PC:
+    return In.GotPlt->getVA() + A - P;
   case R_GOTREL:
     return Sym.getVA(A) - In.Got->getVA();
-  case R_GOTREL_FROM_END:
-    return Sym.getVA(A) - In.Got->getVA() - In.Got->getSize();
-  case R_GOT_FROM_END:
+  case R_GOTPLTREL:
+    return Sym.getVA(A) - In.GotPlt->getVA();
+  case R_GOTPLT:
   case R_RELAX_TLS_GD_TO_IE_END:
-    return Sym.getGotOffset() + A - In.Got->getSize();
+    return Sym.getGotVA() + A - In.GotPlt->getVA();
   case R_TLSLD_GOT_OFF:
   case R_GOT_OFF:
   case R_RELAX_TLS_GD_TO_IE_GOT_OFF:
     return Sym.getGotOffset() + A;
   case R_AARCH64_GOT_PAGE_PC:
   case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC:
     return getAArch64Page(Sym.getGotVA() + A) - getAArch64Page(P);
   case R_GOT_PC:
case R_SIZE:
     return Sym.getSize() + A;
   case R_TLSDESC:
     return In.Got->getGlobalDynAddr(Sym) + A;
   case R_AARCH64_TLSDESC_PAGE:
     return getAArch64Page(In.Got->getGlobalDynAddr(Sym) + A) -
            getAArch64Page(P);
   case R_TLSGD_GOT:
     return In.Got->getGlobalDynOffset(Sym) + A;
-  case R_TLSGD_GOT_FROM_END:
-    return In.Got->getGlobalDynOffset(Sym) + A - In.Got->getSize();
+  case R_TLSGD_GOTPLT:
+    return In.Got->getVA() + In.Got->getGlobalDynOffset(Sym) + A - In.GotPlt->getVA();
   case R_TLSGD_PC:
     return In.Got->getGlobalDynAddr(Sym) + A - P;
-  case R_TLSLD_GOT_FROM_END:
-    return In.Got->getTlsIndexOff() + A - In.Got->getSize();
+  case R_TLSLD_GOTPLT:
+    return In.Got->getVA() + In.Got->getTlsIndexOff() + A - In.GotPlt->getVA();
   case R_TLSLD_GOT:
     return In.Got->getTlsIndexOff() + A;
   case R_TLSLD_PC:
     return In.Got->getTlsIndexVA() + A - P;
   default:
     llvm_unreachable("invalid expression");
   }
 }

ELF/Relocations.h

 typedef uint32_t RelType;
 
 // List of target-independent relocation types. Relocations read
 // from files are converted to these types so that the main code
 // doesn't have to know about architecture-specific details.
 enum RelExpr {
   R_ABS,
   R_ADDEND,
   R_GOT,
-  R_GOTONLY_PC,
-  R_GOTONLY_PC_FROM_END,
-  R_GOTREL,
-  R_GOTREL_FROM_END,
-  R_GOT_FROM_END,
   R_GOT_OFF,
   R_GOT_PC,
+  R_GOTONLY_PC,
+  R_GOTPLTONLY_PC,
+  R_GOTPLT,
+  R_GOTPLTREL,
+  R_GOTREL,
   R_HINT,
   R_NEG_TLS,
   R_NONE,
   R_PC,
   R_PLT,
   R_PLT_PC,
   R_RELAX_GOT_PC,
   R_RELAX_GOT_PC_NOPIC,
   R_RELAX_TLS_GD_TO_IE,
   R_RELAX_TLS_GD_TO_IE_ABS,
   R_RELAX_TLS_GD_TO_IE_END,
   R_RELAX_TLS_GD_TO_IE_GOT_OFF,
   R_RELAX_TLS_GD_TO_LE,
   R_RELAX_TLS_GD_TO_LE_NEG,
   R_RELAX_TLS_IE_TO_LE,
   R_RELAX_TLS_LD_TO_LE,
   R_RELAX_TLS_LD_TO_LE_ABS,
   R_SIZE,
   R_TLS,
   R_TLSDESC,
   R_TLSDESC_CALL,
   R_TLSGD_GOT,
-  R_TLSGD_GOT_FROM_END,
+  R_TLSGD_GOTPLT,
   R_TLSGD_PC,
   R_TLSIE_HINT,
   R_TLSLD_GOT,
-  R_TLSLD_GOT_FROM_END,
+  R_TLSLD_GOTPLT,
   R_TLSLD_GOT_OFF,
   R_TLSLD_HINT,
   R_TLSLD_PC,
 
   // The following is abstract relocation types used for only one target.
   //
   // Even though RelExpr is intended to be a target-neutral representation
   // of a relocation type, there are some relocations whose semantics are

ELF/Relocations.cpp

if (In.Got->addDynTlsEntry(Sym)) {
       In.RelaDyn->addReloc(
           {Target->TlsDescRel, In.Got, Off, !Sym.IsPreemptible, &Sym, 0});
     }
     if (Expr != R_TLSDESC_CALL)
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return 1;
   }
 
-  if (oneof<R_TLSLD_GOT, R_TLSLD_GOT_FROM_END, R_TLSLD_PC, R_TLSLD_HINT>(
+  if (oneof<R_TLSLD_GOT, R_TLSLD_GOTPLT, R_TLSLD_PC, R_TLSLD_HINT>(
           Expr)) {
     // Local-Dynamic relocs can be relaxed to Local-Exec.
     if (!Config->Shared) {
       C.Relocations.push_back(
           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_LD_TO_LE), Type,
            Offset, Addend, &Sym});
       return Target->getTlsGdRelaxSkip(Type);
     }
if (!Sym.isInGot()) {
       In.Got->Relocations.push_back(
           {R_ABS, Target->TlsOffsetRel, Off, 0, &Sym});
     }
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return 1;
   }
 
   if (oneof<R_TLSDESC, R_AARCH64_TLSDESC_PAGE, R_TLSDESC_CALL, R_TLSGD_GOT,
-            R_TLSGD_GOT_FROM_END, R_TLSGD_PC>(Expr)) {
+            R_TLSGD_GOTPLT, R_TLSGD_PC>(Expr)) {
     if (Config->Shared) {
       if (In.Got->addDynTlsEntry(Sym)) {
         uint64_t Off = In.Got->getGlobalDynOffset(Sym);
         In.RelaDyn->addReloc(Target->TlsModuleIndexRel, In.Got, Off, &Sym);
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
         uint64_t OffsetOff = Off + Config->Wordsize;
if (Sym.IsPreemptible) {
           {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_LE), Type,
            Offset, Addend, &Sym});
     }
     return Target->getTlsGdRelaxSkip(Type);
   }
 
   // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
   // defined.
-  if (oneof<R_GOT, R_GOT_FROM_END, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF,
+  if (oneof<R_GOT, R_GOTPLT, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF,
             R_TLSIE_HINT>(Expr) &&
       !Config->Shared && !Sym.IsPreemptible) {
     C.Relocations.push_back({R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Sym});
     return 1;
   }
 
   if (Expr == R_TLSIE_HINT)
     return 1;

 }
 
 // Returns true if Expr refers a GOT entry. Note that this function
 // returns false for TLS variables even though they need GOT, because
 // TLS variables uses GOT differently than the regular variables.
 static bool needsGot(RelExpr Expr) {
   return oneof<R_GOT, R_GOT_OFF, R_HEXAGON_GOT, R_MIPS_GOT_LOCAL_PAGE,
                R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_AARCH64_GOT_PAGE_PC,
-               R_GOT_PC, R_GOT_FROM_END>(Expr);
+               R_GOT_PC, R_GOTPLT>(Expr);
 }
 
 // True if this expression is of the form Sym - X, where X is a position in the
 // file (PC, or GOT for example).
 static bool isRelExpr(RelExpr Expr) {
-  return oneof<R_PC, R_GOTREL, R_GOTREL_FROM_END, R_MIPS_GOTREL, R_PPC_CALL,
+  return oneof<R_PC, R_GOTREL, R_GOTPLTREL, R_MIPS_GOTREL, R_PPC_CALL,
                R_PPC_CALL_PLT, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC>(Expr);
 }
 
 // Returns true if a given relocation can be computed at link-time.
 //
 // For instance, we know the offset from a relocation to its target at
 // link-time if the relocation is PC-relative and refers a
 // non-interposable function in the same executable. This function
 // will return true for such relocation.
 //
 // If this function returns false, that means we need to emit a
 // dynamic relocation so that the relocation will be fixed at load-time.
 static bool isStaticLinkTimeConstant(RelExpr E, RelType Type, const Symbol &Sym,
                                      InputSectionBase &S, uint64_t RelOff) {
   // These expressions always compute a constant
-  if (oneof<R_GOT_FROM_END, R_GOT_OFF, R_HEXAGON_GOT, R_TLSLD_GOT_OFF,
+  if (oneof<R_GOTPLT, R_GOT_OFF, R_HEXAGON_GOT, R_TLSLD_GOT_OFF,
             R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOTREL, R_MIPS_GOT_OFF,
             R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC, R_MIPS_TLSGD,
             R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC,
-            R_GOTONLY_PC_FROM_END, R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOT_FROM_END,
+            R_GOTPLTONLY_PC, R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOTPLT,
             R_TLSGD_PC, R_PPC_CALL_PLT, R_TLSDESC_CALL, R_AARCH64_TLSDESC_PAGE,
             R_HINT, R_TLSLD_HINT, R_TLSIE_HINT>(E))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
static void scanReloc(InputSectionBase &Sec, OffsetGetter &GetOffset, RelTy *&I,
   // list. We can leverage that fact.
   if (!Sym.IsPreemptible && !Sym.isGnuIFunc()) {
     if (Expr == R_GOT_PC && !isAbsoluteValue(Sym))
       Expr = Target->adjustRelaxExpr(Type, RelocatedAddr, Expr);
     else
       Expr = fromPlt(Expr);
   }
 
-  // This relocation does not require got entry, but it is relative to got and
-  // needs it to be created. Here we request for that.
-  if (oneof<R_GOTONLY_PC, R_GOTONLY_PC_FROM_END, R_GOTREL, R_GOTREL_FROM_END,
-            R_PPC_TOC>(Expr))
+  // If the relocation is relative to GOT or GOTPLT, we need GOT or GOTPLT to be
+  // created.
+  if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL>(Expr)) {
+    In.GotPlt->HasGotPltOffRel = true;
+  } else if (oneof<R_GOTONLY_PC, R_GOTREL, R_PPC_TOC>(Expr)) {
     In.Got->HasGotOffRel = true;
+  } else if (Expr == R_GOTPLT) {
+    // This x86 and x86_64 specific relocation type is relative to GOTPLT but
+    // its computation requires .got to exist.
+    In.GotPlt->HasGotPltOffRel = true;
+    In.Got->HasGotOffRel = true;
+  }
 
   // Read an addend.
   int64_t Addend = computeAddend<ELFT>(Rel, End, Sec, Expr, Sym.isLocal());
 
   // Process some TLS relocations, including relaxing TLS relocations.
   // Note that this function does not handle all TLS relocations.
   if (unsigned Processed =
           handleTlsRelocation<ELFT>(Type, Sym, Sec, Offset, Addend, Expr)) {

ELF/SyntheticSections.h

 class GotPltSection final : public SyntheticSection {
 public:
   GotPltSection();
   void addEntry(Symbol &Sym);
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
   bool empty() const override;
 
+  // Flag to force GotPlt to be in output if we have relocations
+  // that relies on its address.
+  bool HasGotPltOffRel = false;
+
 private:
   std::vector<const Symbol *> Entries;
 };
 
 // The IgotPltSection is a Got associated with the PltSection for GNU Ifunc
 // Symbols that will be relocated by Target->IRelativeRel.
 // On most Targets the IgotPltSection will immediately follow the GotPltSection
 // on ARM the IgotPltSection will immediately follow the GotSection.

ELF/SyntheticSections.cpp

 }
 
 void GotSection::finalizeContents() {
   Size = NumEntries * Config->Wordsize;
 }
 
 bool GotSection::empty() const {
   // We need to emit a GOT even if it's empty if there's a relocation that is
-  // relative to GOT(such as GOTOFFREL) or there's a symbol that points to a GOT
-  // (i.e. _GLOBAL_OFFSET_TABLE_) that the target defines relative to the .got.
-  return NumEntries == 0 && !HasGotOffRel &&
-         !(ElfSym::GlobalOffsetTable && !Target->GotBaseSymInGotPlt);
+  // relative to GOT(such as GOTOFFREL).
+  return NumEntries == 0 && !HasGotOffRel;
 }
 
 void GotSection::writeTo(uint8_t *Buf) {
   // Buf points to the start of this section's buffer,
   // whereas InputSectionBase::relocateAlloc() expects its argument
   // to point to the start of the output section.
   Target->writeGotHeader(Buf);
   relocateAlloc(Buf - OutSecOff, Buf - OutSecOff + Size);
void GotPltSection::writeTo(uint8_t *Buf) {
   Buf += Target->GotPltHeaderEntriesNum * Target->GotPltEntrySize;
   for (const Symbol *B : Entries) {
     Target->writeGotPlt(Buf, *B);
     Buf += Config->Wordsize;
   }
 }
 
 bool GotPltSection::empty() const {
-  // We need to emit a GOT.PLT even if it's empty if there's a symbol that
-  // references the _GLOBAL_OFFSET_TABLE_ and the Target defines the symbol
-  // relative to the .got.plt section.
-  return Entries.empty() &&
-         !(ElfSym::GlobalOffsetTable && Target->GotBaseSymInGotPlt);
+  // We need to emit GOTPLT even if it's empty if there's a relocation relative
+  // to it.
+  return Entries.empty() && !HasGotPltOffRel;
 }
 
 static StringRef getIgotPltName() {
   // On ARM the IgotPltSection is part of the GotSection.
   if (Config->EMachine == EM_ARM)
     return ".got";
 
   // On PowerPC64 the GotPltSection is renamed to '.plt' so the IgotPltSection

ELF/Writer.cpp

if (Config->EMachine == EM_PPC64) {
     Add(In.PPC64LongBranchTarget);
   }
 
   In.GotPlt = make<GotPltSection>();
   Add(In.GotPlt);
   In.IgotPlt = make<IgotPltSection>();
   Add(In.IgotPlt);
 
+  // _GLOBAL_OFFSET_TABLE_ is defined relative to either .got.plt or .got. Treat
+  // it as a relocation and ensure the referenced section is created.
+  if (ElfSym::GlobalOffsetTable && Config->EMachine != EM_MIPS) {
+    if (Target->GotBaseSymInGotPlt)
+      In.GotPlt->HasGotPltOffRel = true;
+    else
+      In.Got->HasGotOffRel = true;
+  }
+
   if (Config->GdbIndex)
     Add(GdbIndexSection::create<ELFT>());
 
   // We always need to add rel[a].plt to output if it has entries.
   // Even for static linking it can contain R_[*]_IRELATIVE relocations.
   In.RelaPlt = make<RelocationSection<ELFT>>(
       Config->IsRela ? ".rela.plt" : ".rel.plt", false /*Sort*/);
   Add(In.RelaPlt);

test/ELF/got-i386.s

 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 0
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 
 // CHECK:      Symbol {
 // CHECK:       Name: bar
-// CHECK-NEXT:  Value: 0x402000
+// CHECK-NEXT:  Value: 0x40200C
 // CHECK-NEXT:  Size: 10
 // CHECK-NEXT:  Binding: Global
 // CHECK-NEXT:  Type: Object
 // CHECK-NEXT:  Other: 0
 // CHECK-NEXT:  Section: .bss
 // CHECK-NEXT: }
 // CHECK-NEXT: Symbol {
 // CHECK-NEXT:  Name: obj
-// CHECK-NEXT:  Value: 0x40200A
+// CHECK-NEXT:  Value: 0x402016
 // CHECK-NEXT:  Size: 10
 // CHECK-NEXT:  Binding: Global
 // CHECK-NEXT:  Type: Object
 // CHECK-NEXT:  Other: 0
 // CHECK-NEXT:  Section: .bss
 // CHECK-NEXT: }
 
 // 0x402000 - 0 = addr(.got) = 0x402000
 // 0x40200A - 10 = addr(.got) = 0x402000
 // 0x40200A + 5 - 15 = addr(.got) = 0x402000
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: _start:
-// DISASM-NEXT: 401000: c7 81 00 00 00 00 01 00 00 00 movl $1, (%ecx)
-// DISASM-NEXT: 40100a: c7 81 0a 00 00 00 02 00 00 00 movl $2, 10(%ecx)
-// DISASM-NEXT: 401014: c7 81 0f 00 00 00 03 00 00 00 movl $3, 15(%ecx)
+// DISASM-NEXT: 401000: c7 81 0c 00 00 00 01 00 00 00 movl $1, 12(%ecx)
+// DISASM-NEXT: 40100a: c7 81 16 00 00 00 02 00 00 00 movl $2, 22(%ecx)
+// DISASM-NEXT: 401014: c7 81 1b 00 00 00 03 00 00 00 movl $3, 27(%ecx)
 
 .global _start
 _start:
   movl $1, bar@GOTOFF(%ecx)
   movl $2, obj@GOTOFF(%ecx)
   movl $3, obj+5@GOTOFF(%ecx)
   .type bar, @object
   .comm bar, 10
   .type obj, @object
   .comm obj, 10

test/ELF/i386-gotoff-shared.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-readelf -S %t.so | FileCheck %s
 // RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 
 bar:
         movl    bar@GOTOFF(%ebx), %eax
         mov     bar@GOT, %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: 0x2050
-// CHECK-NEXT: Offset: 0x2050
-// CHECK-NEXT: Size: 4
+// CHECK: .got.plt          PROGBITS        00003000
 
-// 0x1000 - (0x2050 + 4) = -4180
+// 0x1000 - 0x3000 (.got.plt) = -8192
 
-// DISASM:  1000: {{.*}} movl    -4180(%ebx), %eax
+// DISASM:  1000: {{.*}} movl    -8192(%ebx), %eax

test/ELF/i386-gotpc-dynamic.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-readelf -S %t.so | FileCheck %s
 # RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 
-# CHECK:       Section {
-# CHECK:        Index: 7
-# CHECK-NEXT:   Name: .got
-# CHECK-NEXT:   Type: SHT_PROGBITS
-# CHECK-NEXT:   Flags [
-# CHECK-NEXT:     SHF_ALLOC
-# CHECK-NEXT:     SHF_WRITE
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Address: 0x2030
-# CHECK-NEXT:   Offset:
-# CHECK-NEXT:   Size:
-# CHECK-NEXT:   Link:
-# CHECK-NEXT:   Info:
-# CHECK-NEXT:   AddressAlignment:
-# CHECK-NEXT:   EntrySize:
-# CHECK-NEXT: }
+# CHECK: .got.plt          PROGBITS        00003000
 
-## 0x1000 + 4144 = 0x2030
-# DISASM: 1000: {{.*}} movl $4144, %eax
+## 0x3000 - 0x1000 = 8192
+# DISASM: 1000: {{.*}} movl $8192, %eax
 
 .section .foo,"ax",@progbits
 foo:
  movl $bar@got-., %eax # R_386_GOTPC
 
 .local bar
 bar:

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-readelf -S %t.so | FileCheck %s
 // RUN: llvm-objdump -d %t.so | FileCheck --check-prefix=DISASM %s
 
 movl $_GLOBAL_OFFSET_TABLE_, %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: 0x2030
-
-// 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: 0x3000
+// CHECK: .got.plt          PROGBITS        00003000
 
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: .text:
-// DISASM-NEXT:    1000: {{.*}}         movl    $4144, %eax
-//                                              0x2030 - 0x1000 = 0x1030
+// DISASM-NEXT:    1000: {{.*}}         movl    $8192, %eax
+//                                              0x3000 (.got.plt) - 0x1000 = 8192

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 ec 00 00 00       pushl   236(%ebx)
+// CHECK-NEXT: 10:       ff b3 04 00 00 00       pushl   4(%ebx)
 // CHECK-NEXT: 16:       50      pushl   %eax
-// CHECK-NEXT: 17:       8b 83 f0 00 00 00 movl    240(%ebx), %eax
+// CHECK-NEXT: 17:       8b 83 08 00 00 00 movl    8(%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 f4 00 00 00       movl    244(%ebx), %eax
+// CHECK-NEXT: 41:       8b 83 0c 00 00 00       movl    12(%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 f8 00 00 00       movl    248(%ebx), %eax
+// CHECK-NEXT: 61:       8b 83 10 00 00 00       movl    16(%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

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 30 00 00       pushl   12292(%ebx)
+// CHECK-NEXT: 1010:       ff b3 04 00 00 00       pushl   4(%ebx)
 // CHECK-NEXT: 1016:       50      pushl   %eax
-// CHECK-NEXT: 1017:       8b 83 08 30 00 00       movl    12296(%ebx), %eax
+// CHECK-NEXT: 1017:       8b 83 08 00 00 00       movl    8(%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 30 00 00       movl    12300(%ebx), %eax
+// CHECK-NEXT: 1041:       8b 83 0c 00 00 00       movl    12(%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 30 00 00       movl    12304(%ebx), %eax
+// CHECK-NEXT: 1061:       8b 83 10 00 00 00       movl    16(%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

test/ELF/plt-i686.s

 // 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 30 00 00 pushl 12292(%ebx)
-// DISASMSHARED-NEXT:  1026: ff a3 08 30 00 00 jmpl *12296(%ebx)
+// DISASMSHARED-NEXT:  1020: ff b3 04 00 00 00 pushl 4(%ebx)
+// DISASMSHARED-NEXT:  1026: ff a3 08 00 00 00 jmpl *8(%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 30 00 00 jmpl *12300(%ebx)
+// DISASMSHARED:       bar@plt:
+// DISASMSHARED-NEXT:  1030: ff a3 0c 00 00 00 jmpl *12(%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 30 00 00 jmpl *12304(%ebx)
+// DISASMSHARED:       zed@plt:
+// DISASMSHARED-NEXT:  1040: ff a3 10 00 00 00 jmpl *16(%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 30 00 00 pushl 12292(%ebx)
-// DISASMPIE-NEXT:   1026:  ff a3 08 30 00 00 jmpl *12296(%ebx)
+// 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:        bar@plt:
+// DISASMPIE-NEXT:   1030:  ff a3 0c 00 00 00 jmpl *12(%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:        zed@plt:
+// DISASMPIE-NEXT:   1040:  ff a3 10 00 00 00 jmpl *16(%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/relocation-i686.s

 // ADDR-NEXT: Flags [
 // ADDR-NEXT:   SHF_ALLOC
 // ADDR-NEXT:   SHF_EXECINSTR
 // ADDR-NEXT: ]
 // ADDR-NEXT: Address: 0x401040
 // ADDR-NEXT: Offset: 0x1040
 // ADDR-NEXT: Size: 32
 
-// ADDR:      Name: .got (
+// ADDR:      Name: .got.plt (
 // ADDR-NEXT: Type: SHT_PROGBITS
 // ADDR-NEXT: Flags [
 // ADDR-NEXT:   SHF_ALLOC
 // ADDR-NEXT:   SHF_WRITE
 // ADDR-NEXT: ]
-// ADDR-NEXT: Address: 0x402078
+// ADDR-NEXT: Address: 0x403000
 // ADDR-NEXT: Offset:
-// ADDR-NEXT: Size: 8
+// ADDR-NEXT: Size:
 
 .section .R_386_GOTPC,"ax",@progbits
 R_386_GOTPC:
  movl $_GLOBAL_OFFSET_TABLE_, %eax
 
-// 0x402078 + 8 - 0x401014 = 8300
+// 0x403000 (.got.plt) - 0x401014 = 8300
 
 // CHECK:      Disassembly of section .R_386_GOTPC:
 // CHECK-NEXT: R_386_GOTPC:
-// CHECK-NEXT:   401014:  {{.*}} movl  $4204, %eax
+// CHECK-NEXT:   401014:  {{.*}} movl  $8172, %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
 

test/ELF/shared.s

 // test that .hash is linked to .dynsym
 // CHECK:        Index: 2
 // CHECK-NEXT:   Name: .dynsym
 // CHECK-NEXT:   Type: SHT_DYNSYM
 // CHECK-NEXT:   Flags [
 // CHECK-NEXT:     SHF_ALLOC
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   Address: [[DYNSYMADDR:.*]]
-// CHECK-NEXT:   Offset: 0x150
+// CHECK-NEXT:   Offset: 0x170
 // CHECK-NEXT:   Size:
 // CHECK-NEXT:   Link: [[DYNSTR:.*]]
 // CHECK-NEXT:   Info: 1
 // CHECK-NEXT:   AddressAlignment: 4
 // CHECK-NEXT:   EntrySize: 16
 // CHECK-NEXT:   SectionData (
 // CHECK-NEXT:     0000:
 // CHECK-NEXT:     0010:

test/ELF/tls-dynamic-i686.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t
-// RUN: ld.lld --hash-style=sysv -shared %t -o %tout
+// RUN: ld.lld --hash-style=sysv -shared -z norelro %t -o %tout
 // RUN: llvm-readobj -sections -relocations %tout | FileCheck %s
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DIS
 
 .type tls0,@object
 .section .tbss,"awT",@nobits
 .globl tls0
 .align 4
 tls0:

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 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_.
+// SECTION: .got.plt PROGBITS 0000000000003000 003000 000018
 
 // 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; }
 
-// 0x2070 (.got end) - 0x1007 = 4201
-// 0x2000 (_DYNAMIC) - 0x2070 (.got end) = -112
-// CHECK:      1000: {{.*}} leaq 4201(%rip), %rdx
-// CHECK-NEXT: 1007: {{.*}} movabsq $-112, %rax
+// 0x3000 (.got.plt) - 0x1007 = 8185
+// 0x2000 (_DYNAMIC) - 0x3000 (.got.plt) = -4096
+// CHECK:      1000: {{.*}} leaq 8185(%rip), %rdx
+// CHECK-NEXT: 1007: {{.*}} movabsq $-4096, %rax
 .global dynamic
 dynamic:
   leaq _GLOBAL_OFFSET_TABLE_(%rip), %rdx
   movabsq $_DYNAMIC@GOTOFF, %rax
   addq %rdx, %rax
   ret

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 0000000000002070 002070 000000
+// SECTION: .got.plt PROGBITS 0000000000003000 003000 000018
 
-// 0x2070 (.got end) - 0x1000 = 4208
+// 0x3000 (.got.plt) - 0x1000 = 8192
 // CHECK: gotpc64:
-// CHECK-NEXT: 1000: {{.*}} movabsq $4208, %r11
+// CHECK-NEXT: 1000: {{.*}} movabsq $8192, %r11
 .global gotpc64
 gotpc64:
   movabsq $_GLOBAL_OFFSET_TABLE_-., %r11