[PowerPC] Support PCRelative Callees for R_PPC64_REL24 Relocation

[stefanp]

Summary

The R_PPC64_REL24 is used in function calls when the caller requires a
valid TOC pointer. If the callee shares the same TOC or does not clobber
the TOC pointer then a direct call can be made. If the callee does not
share the TOC a thunk must be added to save the TOC pointer for the caller.

Up until PC Relative was introduced all local calls on medium and large code
models were assumed to share a TOC. This is no longer the case because
if the caller requires a TOC and the callee is PC Relative then the callee
can clobber the TOC even if it is in the same DSO.

This patch is to add support for a TOC caller calling a PC Relative callee that
clobbers the TOC.

[stefanp]

Updated initial test case to clean up some of the instruction.
Added a second test to check that an error is reported when the nop after the
call is missing.

[anil9]

lld/ELF/Thunks.cpp

284

guaranteee - > guarantee

285

need the save -> need to save

286

This stub does: -> This stub:

287

Branch -> Branches/Jumps

[sfertile]

lld/ELF/Thunks.cpp

287

Alternatively: 2) Tails calls the callee

842

What happens if offset doesn't fit within 26 bits?

846

This is being named the same as a branch extending thunk (ie a trampoline for when the call is too far to represent with a single call instruction). The name we create shoud represent the thunk type, it makes reading disassembly much easier. How about "__toc_save_` instead?

lld/test/ELF/ppc64-error-toc-local-call.s

37

nit: remove the compiler generated comments.

lld/test/ELF/ppc64-toc-call-to-pcrel.s

62

nit: remove extra blank line.

[stefanp]

Fixed some nits in comments.
Added a fatal error and a test case case to cover the situation where the offset
for the branch is more than 26 bits.

lld/ELF/Thunks.cpp

842

Good point.
Right now we just drop the extra bits from the offset and jump to an incorrect offset.

I'll add an error to fail at this point if the offset does not fit in the 26 bits.

846

The reason I had used this name was because GCC used long_branch.callee as the name as well so I figured I would do the same thing. However, I do like the idea of calling it __toc_save better so I'm going to use that instead.

[MaskRay]

lld/ELF/Thunks.cpp

843

Drop trailing period. http://llvm.org/docs/CodingStandards.html#error-and-warning-messages

"R2 save stub branch offset is too large: " + Twine(offset)

lld/test/ELF/ppc64-error-toc-local-call.s

16

Delete addi 3, 3, 5 and extsw. They are irrelevant.

26

Delete irrelevant mr and add

[stefanp]

Updated text for error message.
Test cleanup be deleting lines that are not needed.

[stefanp]

Cleaned up third test as well.

[MaskRay]

lld/ELF/Thunks.cpp

979

This needs a comment.

lld/test/ELF/ppc64-error-toc-local-call.s

8

Use ## for comments. Newer tests conform to this rule.

lld/test/ELF/ppc64-toc-call-to-pcrel-long-jump.s

29 ↗

(On Diff #276284)

add 3, 4, 3 is irrelevant and can be deleted.

35 ↗

(On Diff #276284)

.size can be deleted

[stefanp]

Fixed a couple of conditions and added comments for them.
Added a test for the new condition.
Cleaned up existing tests.

lld/ELF/Thunks.cpp

979

I've added a comment.
Adding the comment forced me to re-assess the condition statement so I've also changed the condition to be just:

if ((s.stOther >> 5) == 1)

There was no reason to exclude R_PPC64_REL14 from this condition.
I have also added a test for R_PPC64_REL14.

[sfertile]

LGTM.

lld/ELF/Thunks.cpp

979

👍

lld/ELF/Arch/PPC64.cpp

bool PPC64::needsThunk(RelExpr expr, RelType type, const InputFile *file,
                        uint64_t branchAddr, const Symbol &s, int64_t a) const {
   if (type != R_PPC64_REL14 && type != R_PPC64_REL24)
     return false;
 
   // If a function is in the Plt it needs to be called with a call-stub.
   if (s.isInPlt())
     return true;
 
+  // If the callee clobbers the TOC but the caller requires a TOC.
+  if ((s.stOther >> 5) == 1 && type == R_PPC64_REL24)
+    return true;
+
   // If a symbol is a weak undefined and we are compiling an executable
   // it doesn't need a range-extending thunk since it can't be called.
   if (s.isUndefWeak() && !config->shared)
     return false;
 
   // If the offset exceeds the range of the branch type then it will need
   // a range-extending thunk.
   // See the comment in getRelocTargetVA() about R_PPC64_CALL.

lld/ELF/Thunks.cpp

 class PPC64PltCallStub final : public Thunk {
 public:
   PPC64PltCallStub(Symbol &dest) : Thunk(dest, 0) {}
   uint32_t size() override { return 20; }
   void writeTo(uint8_t *buf) override;
   void addSymbols(ThunkSection &isec) override;
 };
 
+// PPC64 R2 Save Stub
+// When the caller requires a valid R2 TOC pointer but the callee does not
+// require a TOC pointer and the callee cannot guaranteee that it doesn't
+// clobber R2 then we need the save R2. This stub does:
+// 1) Saves the TOC pointer to the stack.
+// 2) Branch directly to the callee.
+class PPC64R2SaveStub final : public Thunk {
+public:
+  PPC64R2SaveStub(Symbol &dest) : Thunk(dest, 0) {}
+  uint32_t size() override { return 8; }
+  void writeTo(uint8_t *buf) override;
+  void addSymbols(ThunkSection &isec) override;
+};
+
 // A bl instruction uses a signed 24 bit offset, with an implicit 4 byte
 // alignment. This gives a possible 26 bits of 'reach'. If the call offset is
 // larger then that we need to emit a long-branch thunk. The target address
 // of the callee is stored in a table to be accessed TOC-relative. Since the
 // call must be local (a non-local call will have a PltCallStub instead) the
 // table stores the address of the callee's local entry point. For
 // position-independent code a corresponding relative dynamic relocation is
 // used.

 
 void PPC64PltCallStub::addSymbols(ThunkSection &isec) {
   Defined *s = addSymbol(saver.save("__plt_" + destination.getName()), STT_FUNC,
                          0, isec);
   s->needsTocRestore = true;
   s->file = destination.file;
 }
 
+void PPC64R2SaveStub::writeTo(uint8_t *buf) {
+  int64_t offset = destination.getVA() - (getThunkTargetSym()->getVA() + 4);
+  write32(buf + 0, 0xf8410018);                         // std  r2,24(r1)
+  write32(buf + 4, 0x48000000 | (offset & 0x03fffffc)); // b    <offset>
+}
+
+void PPC64R2SaveStub::addSymbols(ThunkSection &isec) {
+  Defined *s = addSymbol(saver.save("__long_branch_" + destination.getName()),
+                         STT_FUNC, 0, isec);
+  s->needsTocRestore = true;
+}
+
 void PPC64LongBranchThunk::writeTo(uint8_t *buf) {
   int64_t offset = in.ppc64LongBranchTarget->getEntryVA(&destination, addend) -
                    getPPC64TocBase();
   writePPC64LoadAndBranch(buf, offset);
 }
 
 void PPC64LongBranchThunk::addSymbols(ThunkSection &isec) {
   addSymbol(saver.save("__long_branch_" + destination.getName()), STT_FUNC, 0,

 }
 
 static Thunk *addThunkPPC64(RelType type, Symbol &s, int64_t a) {
   assert((type == R_PPC64_REL14 || type == R_PPC64_REL24) &&
          "unexpected relocation type for thunk");
   if (s.isInPlt())
     return make<PPC64PltCallStub>(s);
 
+  if ((s.stOther >> 5) == 1 && type == R_PPC64_REL24)
+    return make<PPC64R2SaveStub>(s);
+
   if (config->picThunk)
     return make<PPC64PILongBranchThunk>(s, a);
 
   return make<PPC64PDLongBranchThunk>(s, a);
 }
 
 Thunk *elf::addThunk(const InputSection &isec, Relocation &rel) {
   Symbol &s = *rel.sym;

lld/test/ELF/ppc64-error-toc-local-call.s

+# RUN: llvm-mc -filetype=obj -triple=powerpc64le %s -o %t.o
+# RUN: not ld.lld %t.o -o /dev/null 2>&1 | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64 %s -o %t.o
+# RUN: not ld.lld %t.o -o /dev/null 2>&1 | FileCheck %s
+
+# This test checks that the linker produces errors when it is missing the nop
+# after a local call to a callee with st_other=1.
+
+# CHECK: (.text+0x18): call to _branch_callee lacks nop, can't restore toc
+# CHECK: (.text+0x2C): call to _branch_callee lacks nop, can't restore toc
+
+callee:
+  .localentry callee, 1
+  addi 3, 3, 5                                       # 0x0
+  extsw 3, 3
+  blr
+
+caller:
+.Lfunc_gep1:
+  addis 2, 12, .TOC.-.Lfunc_gep1@ha
+  addi 2, 2, .TOC.-.Lfunc_gep1@l
+.Lfunc_lep1:
+  .localentry caller, .Lfunc_lep1-.Lfunc_gep1
+  mr  30, 3
+  bl callee                                          # 0x18
+  add 3, 3, 30
+  blr
+
+caller_tail:
+.Lfunc_gep2:
+  addis 2, 12, .TOC.-.Lfunc_gep2@ha
+  addi 2, 2, .TOC.-.Lfunc_gep2@l
+.Lfunc_lep2:
+  .localentry caller_tail, .Lfunc_lep2-.Lfunc_gep2
+  b callee                                           # 0x2C
+  #TC_RETURNd8 callee 0

lld/test/ELF/ppc64-toc-call-to-pcrel.s

+# REQUIRES: ppc
+# RUN: echo 'SECTIONS { \
+# RUN:       .text_callee 0x10010000 : { *(.text_callee) } \
+# RUN:       .text_caller 0x10020000 : { *(.text_caller) } \
+# RUN:       }' > %t.script
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le %s -o %t.o
+# RUN: ld.lld -T %t.script %t.o -o %t
+# RUN: llvm-readelf -s %t | FileCheck %s --check-prefix=SYMBOL
+# RUN: llvm-objdump -d --no-show-raw-insn --mcpu=future %t | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64 %s -o %t.o
+# RUN: ld.lld -T %t.script %t.o -o %t
+# RUN: llvm-readelf -s %t | FileCheck %s --check-prefix=SYMBOL
+# RUN: llvm-objdump -d --no-show-raw-insn --mcpu=future %t | FileCheck %s
+
+# The point of this test is to make sure that when a function with TOC access
+# a local function with st_other=1, a TOC save stub is inserted.
+
+# SYMBOL: Symbol table '.symtab' contains 6 entries
+# SYMBOL: 10010000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   1 callee
+# SYMBOL: 10020000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x60>]   2 caller
+# SYMBOL: 10020028     8 FUNC    LOCAL  DEFAULT                   2 __long_branch_callee
+
+# CHECK-LABEL: callee
+# CHECK:       blr
+
+# CHECK-LABEL: caller
+# CHECK:       bl 0x10020028
+# CHECK-NEXT:  ld 2, 24(1)
+# CHECK-NEXT:  blr
+
+# CHECK-LABEL: __long_branch_callee
+# CHECK-NEXT:  std 2, 24(1)
+# CHECK-NEXT:  b 0x10010000
+
+
+.section .text_callee, "ax", %progbits
+callee:
+  .localentry callee, 1
+  addi 2, 3, 5
+  extsw 3, 2
+  blr
+
+.section .text_caller, "ax", %progbits
+caller:
+.Lfunc_gep1:
+  addis 2, 12, .TOC.-.Lfunc_gep1@ha
+  addi 2, 2, .TOC.-.Lfunc_gep1@l
+.Lfunc_lep1:
+  .localentry caller, .Lfunc_lep1-.Lfunc_gep1
+  addis 30, 2, global@toc@ha
+  lwz 4, global@toc@l(30)
+  add 3, 4, 3
+  extsw 3, 3
+  bl callee
+  nop
+  blr
+global:
+  .long 0
+  .size global, 4
+