[PPC64] V2 abi: Emit plt call stubs to the text section rather then the plt section.

[sfertile]

Summary

In https://reviews.llvm.org/D45642 I was made aware that the .plt section is typically used for lazy symbol resolution stubs. Unfortunately we are writing the plt call stubs to that section for the PPC64 target. This patch implements plt call stubs as thunks. This enables them to be written to the proper section (.text rather then .plt) and frees up the .plt section for the lazy symbol resolvers.

Calls on PPC64 that potentially transfer control to a different linkage-unit need to be followed by a 'toc restore'. Previously we could determine a call needed a toc-restore by the R_PPC_PLT_OPD expr type. When redirecting to the thunks though we map that expr back to the non-plt expr (R_PPC_OPD). I've extended symbols with an extra field that records if a call to said symbol needs to be followed by a toc restore so we can differentiate R_PPC_OPD calls that need a toc-restore vs those that do not.

[sfertile]

Rebased to top of trunk.

[ruiu]

ELF/Arch/PPC64.cpp

293

nit: I'd combine it to return Type == R_PPC64_REL24 && S.isInPlt();

ELF/Thunks.cpp

196

Could you expand the comment to explain what PPC64 PLT call stub is and why we need it?

511–512

Coding style.

562–563

if (Type == R_PPC64_REL24) return ... is perhaps better.

572–576

While you are here, could you remove else from these lines? We normally don't write else after return.

[sfertile]

Rebased to pick up Zaaras patch that removed V1 abi support and addressed review comments.

[sfertile]

Hi Rui, thanks for the review. I think I've addressed all your comments.

[ruiu]

LGTM

ELF/Thunks.cpp

197–203

Thank you for writing this!

502

Please remove the cast if it doesn't cause your compiler to emit a warning.

[grimar]

ELF/Thunks.cpp

579

btw, you do not need to return after llvm_unreachable

[sfertile]

ELF/Thunks.cpp

197–203

Happy to :)

579

Thanks, I've updated this in the commit.

[MaskRay]

lld/trunk/ELF/InputSection.cpp

746 ↗

(On Diff #145407)

If the file was compiled with gcc -Bsymbolic -fPIC, there may not be a nop after bl.
If the symbol also requires a PLT (its NeedsTocRestore will be true), this check will fail.

[sfertile]

lld/trunk/ELF/InputSection.cpp

746 ↗

(On Diff #145407)

Hi @MaskRay are you using -Bsymbolic in the linker options as well?

[MaskRay]

lld/trunk/ELF/InputSection.cpp

746 ↗

(On Diff #145407)

I get a better example.

1. Download https://packages.debian.org/jessie/ppc64el/libstdc++-4.9-dev/download
2. Unpack with 7z then tar xf data.tar
3. ar x ./usr/lib/gcc/powerpc64le-linux-gnu/4.9/libstdc++.a locale.o

llvm-objdump -d -r locale.o

_ZNKSt6locale2id5_M_idEv:
......
      b8:       01 00 00 48     bl .+0
                00000000000000b8:  R_PPC64_REL24        _ZNKSt6locale2id5_M_idEv
      bc:       01 00 23 39     addi 9, 3, 1     //////////// there is no nop here

If the symbol _ZNKSt6locale2id5_M_idEv has NeedsTocRestore set, this will fail to link, right?

I have checked newer versions, e.g. 5.5 6.4 6.8 they don't have such weird bl instruction. I don't know if this was a bug when producing locale.o

[sfertile]

lld/trunk/ELF/InputSection.cpp

746 ↗

(On Diff #145407)

Awesome, I'll pull this down and have a closer look.

If the symbol _ZNKSt6locale2id5_M_idEv has NeedsTocRestore set, this will fail to link, right?

Yes it will, but if _ZNKSt6locale2id5_M_idEv is interposable then the missing nop is indeed a bug. For the error to be wrong I think we would need to see a situation where the target of the calll isn't in the plt but NeedsTocRestore was set.

What I observed in testing out various scenarios yesterday was that gold will emit a fatal error when there is no nop after a call to a function which doesn't have a definition in the shared object we are linking. If there is a definition there is no error even if the target of the call is interposable. In the situation where there is no nop but the target of the call is interposable the resulting shared-object is subtly broken. It will work fine as long as the dynamic loader resolves the target of the call to the definition local to the shared-object, but if it picks a definition from another shared-object or the executable then we can end up returning to this module with the wrong address in r2.

[sfertile]

lld/trunk/ELF/InputSection.cpp

746 ↗

(On Diff #145407)

a.s1 KBDownload

good_main.c:

int test(int);

int main(void) {
  return test(44);
}

bad_main.c:

int test(int);

int printf(const char*, ...);

void print(void) {
  printf("%s %d\n", __FILE__, __LINE__);
}

int main(void) {
  return test(44);
}

Here is a small test where we can assemble a.s and link it into a shared-object with gold without error, and it runs fine when used with good_main.c, but if used with bad_main.c we segfault on the lwa instruction following the call to print.

[sfertile]

A bit more info here since the fact the call to _ZNKSt6locale2id5_M_idEv is a recursive call makes the situation a bit more muddy. I tested this with an older gcc version (5.4.0) and a newer version (7.3.1 from advanced toolchain 11). The newer compiler will emit a nop after a recursive call if the function is interposable, while the older compiler skips the nop. The linkers from the older toolchain (gold and bfd from binutils 2.26) both use plt stubs for the recursive call, and will rewrite the following nop to a toc-restore if the nop is there. I think lld behavior to emit a fatal error when trying to link _ZNKSt6locale2id5_M_idEv into a shared object is the correct one.

[MaskRay]

In D46204#1223731, @sfertile wrote:

A bit more info here since the fact the call to _ZNKSt6locale2id5_M_idEv is a recursive call makes the situation a bit more muddy. I tested this with an older gcc version (5.4.0) and a newer version (7.3.1 from advanced toolchain 11). The newer compiler will emit a nop after a recursive call if the function is interposable, while the older compiler skips the nop. The linkers from the older toolchain (gold and bfd from binutils 2.26) both use plt stubs for the recursive call, and will rewrite the following nop to a toc-restore if the nop is there. I think lld behavior to emit a fatal error when trying to link _ZNKSt6locale2id5_M_idEv into a shared object is the correct one.

The related TOC rewriting code in gold:

https://sourceware.org/git/?p=binutils-gdb.git;a=blob;hb=4e57b456393946cb4f90131b78e162cdec903c8a;f=gold/powerpc.cc#l9054

9069

	      // g++ as of 20130507 emits self-calls without a
	      // following nop.  This is arguably wrong since we have
	      // conflicting information.  On the one hand a global
	      // symbol and on the other a local call sequence, but
	      // don't error for this special case.
	      // It isn't possible to cheaply verify we have exactly
	      // such a call.  Allow all calls to the same section.

I need to learn more about the stuff...

[sfertile]

Thanks for digging up that comment, its nice to know.

In D46204#1223836, @MaskRay wrote:

I need to learn more about the stuff...

Each module has its own value for the toc-pointer (I understand module is an overloaded term in compilers, here I am using it to mean the executable is a module and each shared object is a module). Anytime we potentially cross module boundaries the toc-pointer will need to be saved and later restored. From the static linkers perspective, any time the target of a call needs to be resolved by the dynamic linker the call should be followed by a toc-restore.

ELF/Arch/PPC64.cpp

public:
   PPC64();
   uint32_t calcEFlags() const override;
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   void writeGotHeader(uint8_t *Buf) const override;
+  bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
+                  uint64_t BranchAddr, const Symbol &S) const override;
 };
 } // namespace
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 // document.
 static uint16_t applyPPCLo(uint64_t V) { return V; }
PPC64::PPC64() {
   PltHeaderSize = 0;
   GotBaseSymInGotPlt = false;
   GotBaseSymOff = 0x8000;
 
   if (Config->EKind == ELF64LEKind) {
     GotHeaderEntriesNum = 1;
     GotPltHeaderEntriesNum = 2;
     PltRel = R_PPC64_JMP_SLOT;
+    NeedsThunks = true;
   } else {
     PltRel = R_PPC64_GLOB_DAT;
   }
 
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
   DefaultMaxPageSize = 65536;
 

 void PPC64::writeGotHeader(uint8_t *Buf) const {
   if (isPPC64ElfV2())
     write64(Buf, getPPC64TocBase());
 }
 
 void PPC64::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const {
-  uint64_t Off = GotPltEntryAddr - getPPC64TocBase();
 
-  if (isPPC64ElfV2()) {
-    // The most-common form of the plt stub. This assumes that the toc-pointer
-    // register is properly initalized, and that the stub must save the toc
-    // pointer value to the stack-save slot reserved for it (sp + 24).
-    // There are 2 other variants but we don't have to emit those until we add
-    // support for R_PPC64_REL24_NOTOC and R_PPC64_TOCSAVE relocations.
-    // We are missing a super simple optimization, where if the upper 16 bits of
-    // the offset are zero, then we can omit the addis instruction, and load
-    // r2 + lo-offset directly into r12. I decided to leave this out in the
-    // spirit of keeping it simple until we can link actual non-trivial
-    // programs.
-    write32(Buf +  0, 0xf8410018);                    // std     r2,24(r1)
-    write32(Buf +  4, 0x3d820000 | applyPPCHa(Off));  // addis   r12,r2, X@plt@to@ha
-    write32(Buf +  8, 0xe98c0000 | applyPPCLo(Off));  // ld      r12,X@plt@toc@l(r12)
-    write32(Buf + 12, 0x7d8903a6);                    // mtctr    r12
-    write32(Buf + 16, 0x4e800420);                    // bctr
-  } else {
-    // FIXME: What we should do, in theory, is get the offset of the function
-    // descriptor in the .opd section, and use that as the offset from %r2 (the
-    // TOC-base pointer). Instead, we have the GOT-entry offset, and that will
-    // be a pointer to the function descriptor in the .opd section. Using
-    // this scheme is simpler, but requires an extra indirection per PLT dispatch.
-    write32(Buf, 0xf8410028);                       // std %r2, 40(%r1)
-    write32(Buf + 4, 0x3d620000 | applyPPCHa(Off)); // addis %r11, %r2, X@ha
-    write32(Buf + 8, 0xe98b0000 | applyPPCLo(Off)); // ld %r12, X@l(%r11)
-    write32(Buf + 12, 0xe96c0000);                  // ld %r11,0(%r12)
-    write32(Buf + 16, 0x7d6903a6);                  // mtctr %r11
-    write32(Buf + 20, 0xe84c0008);                  // ld %r2,8(%r12)
-    write32(Buf + 24, 0xe96c0010);                  // ld %r11,16(%r12)
-    write32(Buf + 28, 0x4e800420);                  // bctr
-  }
+ if (!isPPC64ElfV2()) {
+   uint64_t Off = GotPltEntryAddr - getPPC64TocBase();
 }
 
 static std::pair<RelType, uint64_t> toAddr16Rel(RelType Type, uint64_t Val) {
   uint64_t V = Val - PPC64TocOffset;
   switch (Type) {
   case R_PPC64_TOC16:
     return {R_PPC64_ADDR16, V};
   case R_PPC64_TOC16_DS:
case R_PPC64_REL24: {
     write32(Loc, (read32(Loc) & ~Mask) | (Val & Mask));
     break;
   }
   default:
     error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
   }
 }
 
+bool PPC64::needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
+                       uint64_t BranchAddr, const Symbol &S) const {
+  if (Type != R_PPC64_REL24)
+    return false;
+
+  // If a function is in the plt it needs to be called through
+  // a call stub.
+  return S.isInPlt();
+}
+
 TargetInfo *elf::getPPC64TargetInfo() {
   static PPC64 Target;
   return &Target;
 }

ELF/InputSection.cpp

case R_RELAX_TLS_GD_TO_LE_NEG:
       Target->relaxTlsGdToLe(BufLoc, Type, TargetVA);
       break;
     case R_RELAX_TLS_GD_TO_IE:
     case R_RELAX_TLS_GD_TO_IE_ABS:
     case R_RELAX_TLS_GD_TO_IE_PAGE_PC:
     case R_RELAX_TLS_GD_TO_IE_END:
       Target->relaxTlsGdToIe(BufLoc, Type, TargetVA);
       break;
-    case R_PPC_PLT_OPD:
+    case R_PPC_OPD:
       // Patch a nop (0x60000000) to a ld.
+      if (Rel.Sym->NeedsTocRestore) {
         if (BufLoc + 8 > BufEnd || read32(BufLoc + 4) != 0x60000000) {
           error(getErrorLocation(BufLoc) + "call lacks nop, can't restore toc");
           break;
         }
         write32(BufLoc + 4, 0xe8410018); // ld %r2, 24(%r1)
+      }
       Target->relocateOne(BufLoc, Type, TargetVA);
       break;
     default:
       Target->relocateOne(BufLoc, Type, TargetVA);
       break;
     }
   }
 }

ELF/Symbols.h

public:
   OutputSection *getOutputSection() const;
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
       : File(File), NameData(Name.Data), NameSize(Name.Size), Binding(Binding),
         Type(Type), StOther(StOther), SymbolKind(K), NeedsPltAddr(false),
         IsInGlobalMipsGot(false), Is32BitMipsGot(false), IsInIplt(false),
-        IsInIgot(false), IsPreemptible(false), Used(!Config->GcSections) {}
+        IsInIgot(false), IsPreemptible(false), Used(!Config->GcSections),
+        NeedsTocRestore(0) {}
 
 public:
   // True the symbol should point to its PLT entry.
   // For SharedSymbol only.
   unsigned NeedsPltAddr : 1;
   // True if this symbol has an entry in the global part of MIPS GOT.
   unsigned IsInGlobalMipsGot : 1;
 
   // True if this symbol is referenced by 32-bit GOT relocations.
   unsigned Is32BitMipsGot : 1;
 
   // True if this symbol is in the Iplt sub-section of the Plt.
   unsigned IsInIplt : 1;
 
   // True if this symbol is in the Igot sub-section of the .got.plt or .got.
   unsigned IsInIgot : 1;
 
   // True if this symbol is preemptible at load time.
   unsigned IsPreemptible : 1;
 
   // True if an undefined or shared symbol is used from a live section.
   unsigned Used : 1;
 
+  // True if a call to this symbol needs to be followed by a restore of the
+  // PPC64 toc pointer.
+  unsigned NeedsTocRestore : 1;
+
   // The Type field may also have this value. It means that we have not yet seen
   // a non-Lazy symbol with this name, so we don't know what its type is. The
   // Type field is normally set to this value for Lazy symbols unless we saw a
   // weak undefined symbol first, in which case we need to remember the original
   // symbol's type in order to check for TLS mismatches.
   enum { UnknownType = 255 };
 
   bool isSection() const { return Type == llvm::ELF::STT_SECTION; }

ELF/Thunks.cpp

public:
   MicroMipsR6Thunk(Symbol &Dest) : Thunk(Dest) {}
 
   uint32_t size() override { return 12; }
   void writeTo(uint8_t *Buf) override;
   void addSymbols(ThunkSection &IS) override;
   InputSection *getTargetInputSection() const override;
 };
 
+
+// PPC64 Plt call stubs.
+class PPC64PltCallStub final : public Thunk {
+public:
+  PPC64PltCallStub(Symbol &Dest) : Thunk(Dest) {}
+  uint32_t size() { return 20; }
+  void writeTo(uint8_t *Buf) override;
+  void addSymbols(ThunkSection &IS) override;
+};
+
 } // end anonymous namespace
 
 Defined *Thunk::addSymbol(StringRef Name, uint8_t Type, uint64_t Value,
                           InputSectionBase &Section) {
   Defined *D = addSyntheticLocal(Name, Type, Value, /*Size=*/0, Section);
   Syms.push_back(D);
   return D;
 }
void MicroMipsR6Thunk::addSymbols(ThunkSection &IS) {
   D->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsR6Thunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
   return dyn_cast<InputSection>(DR.Section);
 }
 
+void PPC64PltCallStub::writeTo(uint8_t *Buf) {
+  int64_t Off = Destination.getGotPltVA() - getPPC64TocBase();
+  // Need to add 0x8000 to offset to account for the low bits being signed.
+  uint16_t OffHa = (Off + 0x8000) >> 16;
+  uint16_t OffLo = (uint16_t)Off;
+
+  write32(Buf +  0, 0xf8410018);          // std     r2,24(r1)
+  write32(Buf +  4, 0x3d820000 | OffHa);  // addis   r12,r2, X@plt@to@ha
+  write32(Buf +  8, 0xe98c0000 | OffLo);  // ld      r12,X@plt@toc@l(r12)
+  write32(Buf + 12, 0x7d8903a6);          // mtctr    r12
+  write32(Buf + 16, 0x4e800420);          // bctr
+}
+
+void PPC64PltCallStub::addSymbols(ThunkSection &IS)
+{
+  Defined *S = addSymbol(Saver.save("__plt_" + Destination.getName()), STT_FUNC,
+             0, IS);
+  S->NeedsTocRestore = true;
+}
+
 Thunk::Thunk(Symbol &D) : Destination(D), Offset(0) {}
 
 Thunk::~Thunk() = default;
 
 static Thunk *addThunkAArch64(RelType Type, Symbol &S) {
   if (Type != R_AARCH64_CALL26 && Type != R_AARCH64_JUMP26)
     fatal("unrecognized relocation type");
   if (Config->Pic)

 static Thunk *addThunkMips(RelType Type, Symbol &S) {
   if ((S.StOther & STO_MIPS_MICROMIPS) && isMipsR6())
     return make<MicroMipsR6Thunk>(S);
   if (S.StOther & STO_MIPS_MICROMIPS)
     return make<MicroMipsThunk>(S);
   return make<MipsThunk>(S);
 }
 
+static Thunk *addThunkPPC64(RelType Type, Symbol &S) {
+  switch(Type) {
+  case R_PPC64_REL24:
+    return make<PPC64PltCallStub>(S);
+  }
+  fatal("unexpected relocation type");
+}
+
 Thunk *addThunk(RelType Type, Symbol &S) {
   if (Config->EMachine == EM_AARCH64)
     return addThunkAArch64(Type, S);
   else if (Config->EMachine == EM_ARM)
     return addThunkArm(Type, S);
   else if (Config->EMachine == EM_MIPS)
     return addThunkMips(Type, S);
+  else if (Config->EMachine == EM_PPC64)
+    return addThunkPPC64(Type, S);
   llvm_unreachable("add Thunk only supported for ARM and Mips");
   return nullptr;
 }
 
 } // end namespace elf
 } // end namespace lld

test/ELF/ppc64-ifunc.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/shared-ppc64le.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t2.so
 # RUN: ld.lld %t.o %t2.so -o %t
-# RUN: llvm-objdump -d %t | FileCheck %s
+# RUN: llvm-objdump -D %t | FileCheck %s
+
+# CHECK: Disassembly of section .text:
+
+# Tocbase    + (-2 << 16) + 32576
+# 0x100380d0 + (-131072)  + 32576 = 0x10020010 (.got.plt[2])
+# CHECK: __plt_foo:
+# CHECK-NEXT:     std 2, 24(1)
+# CHECK-NEXT:     addis 12, 2, -2
+# CHECK-NEXT:     ld 12, 32576(12)
+# CHECK-NEXT:     mtctr 12
+# CHECK-NEXT:     bctr
+
+# Tocbase    + (-2 << 16) + 32584
+# 0x100380d0 + (-131072)  + 32584 = 0x10020018  (.got.plt[3])
+# CHECK: __plt_ifunc:
+# CHECK-NEXT:     std 2, 24(1)
+# CHECK-NEXT:     addis 12, 2, -2
+# CHECK-NEXT:     ld 12, 32584(12)
+# CHECK-NEXT:     mtctr 12
+# CHECK-NEXT:     bctr
+
+# CHECK: ifunc:
+# CHECK-NEXT: 10010028:       00 00 00 60     nop
 
-# CHECK:      _start:
-# CHECK-NEXT: 10010004:       1d 00 00 48     bl .+28
-# CHECK-NEXT: 10010008:       18 00 41 e8     ld 2, 24(1)
-# CHECK-NEXT: 1001000c:       35 00 00 48     bl .+52
-# CHECK-NEXT: 10010010:       18 00 41 e8     ld 2, 24(1)
-
-# 0x10010004 + 28 = 0x10010020 (PLT entry 0)
-# 0x1001000c + 52 = 0x10010040 (PLT entry 1)
-
-# CHECK:     Disassembly of section .plt:
-# CHECK-NEXT: .plt:
-# CHECK-NEXT: 10010020:       18 00 41 f8     std 2, 24(1)
-# CHECK-NEXT: 10010024:       02 10 82 3d     addis 12, 2, 4098
-# CHECK-NEXT: 10010028:       10 80 8c e9     ld 12, -32752(12)
-# CHECK-NEXT: 1001002c:       a6 03 89 7d     mtctr 12
-# CHECK-NEXT: 10010030:       20 04 80 4e     bctr
-# CHECK-NEXT: 10010034:       08 00 e0 7f     trap
-# CHECK-NEXT: 10010038:       08 00 e0 7f     trap
-# CHECK-NEXT: 1001003c:       08 00 e0 7f     trap
-# CHECK-NEXT: 10010040:       18 00 41 f8     std 2, 24(1)
-# CHECK-NEXT: 10010044:       02 10 82 3d     addis 12, 2, 4098
-# CHECK-NEXT: 10010048:       18 80 8c e9     ld 12, -32744(12)
-# CHECK-NEXT: 1001004c:       a6 03 89 7d     mtctr 12
+# CHECK: _start:
+# CHECK-NEXT:     addis 2, 12, 3
+# CHECK-NEXT:     addi 2, 2, -32604
+# CHECK-NEXT:     bl .+67108812
+# CHECK-NEXT:     ld 2, 24(1)
+# CHECK-NEXT:     bl .+67108824
+# CHECK-NEXT:     ld 2, 24(1)
+
+# Address of .got.plt
+# CHECK:      Disassembly of section .got.plt:
+# CHECK-NEXT:   .got.plt:
+# CHECK-NEXT:   10020000:
+
+
+# Check tocbase
+# CHECK:       Disassembly of section .got:
+# CHECK-NEXT:    .got:
+# CHECK-NEXT:    100300d0:       d0 80 03 10
+# CHECK-NEXT:    100300d4:       00 00 00 00
+
+
     .text
     .abiversion 2
 
 .type ifunc STT_GNU_IFUNC
 .globl ifunc
 ifunc:
  nop
 
     .global _start
+    .type   _start,@function
+
 _start:
+.Lfunc_gep0:
+  addis 2, 12, .TOC.-.Lfunc_gep0@ha
+  addi 2, 2, .TOC.-.Lfunc_gep0@l
+.Lfunc_lep0:
+  .localentry     _start, .Lfunc_lep0-.Lfunc_gep0
   bl foo
   nop
   bl ifunc
   nop

test/ELF/ppc64-toc-restore.s

 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/shared-ppc64le.s -o %t2.o
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/ppc64-func.s -o %t3.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld %t.o %t2.so %t3.o -o %t
 // RUN: llvm-objdump -d %t | FileCheck %s
 // REQUIRES: ppc
     .text
     .abiversion 2
 .global bar_local
 bar_local:
   li 3, 2
   blr
 
 # Calling external function foo in a shared object needs a nop.
 # Calling local function bar_local doe snot need a nop.
-// CHECK: Disassembly of section .text:
 .global _start
 _start:
   bl foo
   nop
   bl bar_local
 
+
+// CHECK: Disassembly of section .text:
 // CHECK: _start:
-// CHECK: 10010008:       49 00 00 48     bl .+72
-// CHECK-NOT: 1001000c:       00 00 00 60     nop
-// CHECK: 1001000c:       18 00 41 e8     ld 2, 24(1)
-// CHECK: 10010010:       f1 ff ff 4b     bl .+67108848
-// CHECK-NOT: 10010014:       00 00 00 60     nop
-// CHECK-NOT: 10010014:       18 00 41 e8     ld 2, 24(1)
+// CHECK:     1001001c:       e5 ff ff 4b bl .+67108836
+// CHECK-NOT: 10010020:       00 00 00 60     nop
+// CHECK:     10010020:       18 00 41 e8     ld 2, 24(1)
+// CHECK:     10010024:       f1 ff ff 4b     bl .+67108848
+// CHECK-NOT: 10010028:       00 00 00 60     nop
+// CHECK-NOT: 10010028:       18 00 41 e8     ld 2, 24(1)
 
 # Calling a function in another object file which will have same
 # TOC base does not need a nop. If nop present, do not rewrite to
 # a toc restore
 .global diff_object
 _diff_object:
   bl foo_not_shared
   bl foo_not_shared
   nop
 
 // CHECK: _diff_object:
-// CHECK-NEXT: 10010014:       1d 00 00 48     bl .+28
-// CHECK-NEXT: 10010018:       19 00 00 48     bl .+24
-// CHECK-NEXT: 1001001c:       00 00 00 60     nop
+// CHECK-NEXT: 10010028:       19 00 00 48     bl .+24
+// CHECK-NEXT: 1001002c:       15 00 00 48     bl .+20
+// CHECK-NEXT: 10010030:       00 00 00 60     nop
 
 # Branching to a local function does not need a nop
 .global noretbranch
 noretbranch:
   b bar_local
 // CHECK: noretbranch:
-// CHECK: 10010020:       e0 ff ff 4b     b .+67108832
-// CHECK-NOT: 10010024:       00 00 00 60     nop
-// CHECK-NOT: 10010024:       18 00 41 e8     ld 2, 24(1)
+// CHECK:     10010034:       e0 ff ff 4b     b .+67108832
+// CHECK-NOT: 10010038:       00 00 00 60     nop
+// CHECK-NOT: 1001003c:       18 00 41 e8     ld 2, 24(1)
 
 // This should come last to check the end-of-buffer condition.
 .global last
 last:
   bl foo
   nop
 // CHECK: last:
-// CHECK: 10010024:       2d 00 00 48     bl .+44
-// CHECK-NEXT: 10010028:       18 00 41 e8     ld 2, 24(1)
-
-// CHECK: Disassembly of section .plt:
-// CHECK: .plt:
-// CHECK-NEXT: 10010050:       18 00 41 f8     std 2, 24(1)
-// CHECK-NEXT: 10010054:       02 10 82 3d     addis 12, 2, 4098
-// CHECK-NEXT: 10010058:       10 80 8c e9     ld 12, -32752(12)
-// CHECK-NEXT: 1001005c:       a6 03 89 7d     mtctr 12
+// CHECK:      10010038:       c9 ff ff 4b     bl .+67108808
+// CHECK-NEXT: 1001003c:       18 00 41 e8     ld 2, 24(1)

test/ELF/ppc64le-plt-stub.s

 // REQUIRES: ppc
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %p/Inputs/shared-ppc64le.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld %t.o %t2.so -o %t
 // RUN: llvm-objdump -d %t | FileCheck %s
 
-// CHECK:          Disassembly of section .text:
+// CHECK:      Disassembly of section .text:
+// CHECK-NEXT: __plt_foo:
+// CHECK-NEXT:      std 2, 24(1)
+// CHECK-NEXT:      addis 12, 2, -2
+// CHECK-NEXT:      ld 12, 32576(12)
+// CHECK-NEXT:      mtctr 12
+// CHECK-NEXT:      bctr
+
+
 // CHECK:            _start:
-// CHECK:            bl .+24
+// CHECK:            bl .+67108824
         .text
         .abiversion 2
         .globl  _start
         .p2align        4
         .type   _start,@function
 _start:
 .Lfunc_begin0:
 .Lfunc_gep0:
   addis 2, 12, .TOC.-.Lfunc_gep0@ha
   addi 2, 2, .TOC.-.Lfunc_gep0@l
 .Lfunc_lep0:
   .localentry     _start, .Lfunc_lep0-.Lfunc_gep0
   bl foo
   nop
   li 0, 1
   sc
   .size _start, .-.Lfunc_begin0
-
-
-
-// CHECK:          Disassembly of section .plt:
-// CHECK:          .plt:
-// CHECK-NEXT:            18 00 41 f8     std 2, 24(1)
-// CHECK-NEXT:            fe ff 82 3d     addis 12, 2, -2
-// CHECK-NEXT:            40 7f 8c e9     ld 12, 32576(12)
-// CHECK-NEXT:            a6 03 89 7d     mtctr 12
-// CHECK:                 20 04 80 4e     bctr