[PowerPC] Support for R_PPC64_REL24_NOTOC calls where the caller has no TOC and the callee is not DSO local

[NeHuang]

Summary

This patch supports the situation where caller does not have a valid TOC and
calls using the R_PPC64_REL24_NOTOC relocation and the callee is not DSO local.
In this case the call cannot be made directly since the callee may or may not
require a valid TOC pointer. As a result this situation requires an R12 setup
plt stub.

[NeHuang]

lld/ELF/Arch/PPC64.cpp

-5–1

nit: remove this comment

lld/ELF/Thunks.cpp

34

Shall we merge it with the if check below if it does not hurt the readability?

if (s.isInPlt())
  return (type == R_PPC64_REL24_NOTOC) ?  make<PPC64R12SetupStub>(s) : make<PPC64PltCallStub>(s);

[sfertile]

lld/ELF/Thunks.cpp

35

I'll need to check what instruction we are using in the R12SetupStub, I see the comment says pld right now, but where is it loading from?
destination.getVA() - getThunkTargetSym()->getVA() is the offset from the program counter to the (non-premptable) definition so I'm guessing its meant to be a paddi instead. Either way, that offset calculation is wrong for a symbol in the plt. Instead we want to load the address of the function from the plt.

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

48

Whats the offset that gets encoded into the instruction? What offset are you expecting?

[NeHuang]

• Added a new plt gep setup stub.
• Updated the test case and checks if the offset func@plt@pcrel properly computed.
• Re-based the patch with ToT master and merged in latest changes in https://reviews.llvm.org/D83504

[NeHuang]

lld/ELF/Thunks.cpp

35

Thanks Sean.

• Updated the patch to load the address of function from the plt.
• The offset is computed by destination.getGotPltVA() - getThunkTargetSym()->getVA(); instead.

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

48

• The offset computed is from the program counter to the plt entry address storing the address of the callee function.
• Updated the test case to check if the offset properly computed.

[NeHuang]

Updated instruction encode computation for pld

[sfertile]

lld/ELF/Arch/PPC64.cpp

-5–1

No need for a extra case to handle the NOTOC plt calls, the following case handles it perfectly.

lld/ELF/Thunks.cpp

34

If you look at the existing plt stub it also sets up R12, this is expected of any plt stub variety on PPC64. The important details about this stub type is that it is a plt stub that uses pc-relative instructions, that it sets up R12 is just an implementation detail.

// PPC64 PLT R12 Setup Stub

-->

// PPC64 PC-relative PLT Stub

41

Change the name to PPC64PCRelPLTStub.

47

Both plt stub types perform the setup for the gep so the name doesn't really disambiguate which stub type we have. I suggest trying to use pc-rel in the name instead of gep.

[NeHuang]

Thanks Sean.

• Removed the redundant check in needsThunk
• Renamed the new stub as suggested, updated comments and the test case accordingly.

[stefanp]

I only had one nit.
LGTM.

lld/ELF/Thunks.cpp

47

nit:
Try to use __plt_pcrel_ instead of __plt_pc-rel_.
The - is probably fine as part of a function name but since I'm not 100% sure I would not risk it.

[MaskRay]

lld/ELF/Thunks.cpp

33–1

Remove unneeded parens.

lld/test/ELF/Inputs/ppc64-callee-global.s

1 ↗

(On Diff #279321)

Use extract?

or llvm-mc --defsym AUX=1 and

.ifdef AUX
...
.else
...
.endif

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

27

-NEXT:

[sfertile]

lld/ELF/Thunks.cpp

34

Are the casts needed?

47

+1. Stefan's suggestions in more consistent with the other stub names.

[NeHuang]

Thank you all for the review!

• Addressed the nits and update the test case.
• Combined ppc64-callee-global.s with ppc64-pcrel-call-to-extern.s using extract.

[NeHuang]

lld/ELF/Thunks.cpp

34

Yeah, the ternary conditional operator would complain since make<PPC64PCRelPLTStub>(s) and make<PPC64PltCallStub>(s) has different value type.

[NeHuang]

As the patch https://reviews.llvm.org/D83834 is reverted, updated the test case accordingly to combine ppc64-callee-global.s and ppc64-pcrel-call-to-extern.s with .ifdef AUX

[sfertile]

lld/ELF/Thunks.cpp

33–1

nit: clang-format

34

Thanks.

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

31

minor nit: add whitepace so it lines up with the following lines

36

Can you add spaces to the lines that are missing '-NEXT' to keep the columns aligned.

51

I believe plt[1] is the dynamic object identifier. Maybe its best to say the first 2 entries in the plt are reserved for the dynamic linkers usage and skip mentioning what they are used for.

[NeHuang]

Thanks Sean for the review. Addressed the nits for clang-format and alignment issues.

[sfertile]

LGTM.

lld/ELF/Arch/PPC64.cpp

 //===- PPC64.cpp ----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 }
 
 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 &&
       type != R_PPC64_REL24_NOTOC)
     return false;
 
-  // FIXME: Remove the fatal error once the call protocol is implemented.
-  if (type == R_PPC64_REL24_NOTOC && s.isInPlt())
-    fatal("unimplemented feature: external function call with the reltype"
-          " R_PPC64_REL24_NOTOC");
-
   // If a function is in the Plt it needs to be called with a call-stub.
   if (s.isInPlt())
     return true;
 
   // This check looks at the st_other bits of the callee with relocation
   // R_PPC64_REL14 or R_PPC64_REL24. If the value is 1, then the callee
   // clobbers the TOC and we need an R2 save stub.
   if (type != R_PPC64_REL24_NOTOC && (s.stOther >> 5) == 1)

lld/ELF/Thunks.cpp

 #include "OutputSections.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstdint>
 #include <cstring>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
 
 // AArch64 long range Thunks
 class AArch64ABSLongThunk final : public Thunk {
 public:
   AArch64ABSLongThunk(Symbol &dest, int64_t addend) : Thunk(dest, addend) {}
   uint32_t size() override { return 16; }
   void writeTo(uint8_t *buf) override;
   void addSymbols(ThunkSection &isec) override;
 };

 class PPC64R12SetupStub final : public Thunk {
 public:
   PPC64R12SetupStub(Symbol &dest) : Thunk(dest, 0) {}
   uint32_t size() override { return 16; }
   void writeTo(uint8_t *buf) override;
   void addSymbols(ThunkSection &isec) override;
 };
 
+// PPC64 PC-relative PLT Stub
+// When a caller that does not maintain a toc-pointer performs an extern call
+// then this stub is needed for:
+// 1) Loading the target functions address from the procedure linkage table into
+//    r12 for use by the target functions global entry point, and into the count
+//    register with pc-relative instructions.
+// 2) Transferring control to the target function through an indirect branch.
+class PPC64PCRelPLTStub final : public Thunk {
+public:
+  PPC64PCRelPLTStub(Symbol &dest) : Thunk(dest, 0) {}
+  uint32_t size() override { return 16; }
+  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 PPC64R12SetupStub::writeTo(uint8_t *buf) {
   write32(buf + 12, BCTR);                  // bctr
 }
 
 void PPC64R12SetupStub::addSymbols(ThunkSection &isec) {
   addSymbol(saver.save("__gep_setup_" + destination.getName()), STT_FUNC, 0,
             isec);
 }
 
+void PPC64PCRelPLTStub::writeTo(uint8_t *buf) {
+  int64_t offset = destination.getGotPltVA() - getThunkTargetSym()->getVA();
+  if (!isInt<34>(offset))
+    fatal("offset must fit in 34 bits to encode in the instruction");
+  uint64_t pld =
+      PLD_R12_NO_DISP | (((offset >> 16) & 0x3ffff) << 32) | (offset & 0xffff);
+
+  writePrefixedInstruction(buf + 0, pld); // pld r12, func@plt@pcrel
+  write32(buf + 8, MTCTR_R12);            // mtctr r12
+  write32(buf + 12, BCTR);                // bctr
+}
+
+void PPC64PCRelPLTStub::addSymbols(ThunkSection &isec) {
+  addSymbol(saver.save("__plt_pcrel_" + destination.getName()), STT_FUNC, 0,
+            isec);
+}
+
 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 *addThunkPPC32(const InputSection &isec, const Relocation &rel,
   return make<PPC32LongThunk>(s, rel.addend);
 }
 
 static Thunk *addThunkPPC64(RelType type, Symbol &s, int64_t a) {
   assert((type == R_PPC64_REL14 || type == R_PPC64_REL24 ||
           type == R_PPC64_REL24_NOTOC) &&
          "unexpected relocation type for thunk");
   if (s.isInPlt())
-    return make<PPC64PltCallStub>(s);
+    return type == R_PPC64_REL24_NOTOC ? (Thunk *)make<PPC64PCRelPLTStub>(s)
+                                       : (Thunk *)make<PPC64PltCallStub>(s);
 
   // This check looks at the st_other bits of the callee. If the value is 1
   // then the callee clobbers the TOC and we need an R2 save stub.
   if ((s.stOther >> 5) == 1)
     return make<PPC64R2SaveStub>(s);
 
   if (type == R_PPC64_REL24_NOTOC && (s.stOther >> 5) > 1)
     return make<PPC64R12SetupStub>(s);

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

+# REQUIRES: ppc
+# RUN: echo 'SECTIONS { \
+# RUN:   .text_caller1 0x10010000 : { *(.text_caller1) } \
+# RUN:   .text_caller2 0x10020000 : { *(.text_caller2) } \
+# RUN:   .text_caller3 0x10030000 : { *(.text_caller3) } \
+# RUN:   }' > %t.script
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le --defsym AUX=1 %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le %s -o %t2.o
+# RUN: ld.lld --shared %t2.o -o %t2.so
+# RUN: ld.lld -T %t.script %t1.o %t2.so -o %t
+# RUN: llvm-readelf -s %t | FileCheck %s --check-prefix=SYMBOL
+# RUN: llvm-readelf -S -d %t | FileCheck %s --check-prefix=SEC
+# RUN: llvm-readobj -r %t | FileCheck %s --check-prefix=REL
+# RUN: llvm-objdump -d --no-show-raw-insn --mcpu=pwr10 %t | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64 --defsym AUX=1 %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=powerpc64 %s -o %t2.o
+# RUN: ld.lld --shared %t2.o -o %t2.so
+# RUN: ld.lld -T %t.script %t1.o %t2.so -o %t
+# RUN: llvm-readelf -s %t | FileCheck %s --check-prefix=SYMBOL
+# RUN: llvm-readelf -S -d %t | FileCheck %s --check-prefix=SEC
+# RUN: llvm-readobj -r %t | FileCheck %s --check-prefix=REL
+# RUN: llvm-objdump -d --no-show-raw-insn --mcpu=pwr10 %t | FileCheck %s
+
+## The test is created to check that when a function without TOC access an
+## external function, a r12 setup stub is inserted.
+
+# SYMBOL: Symbol table '.dynsym' contains 4 entries:
+# SYMBOL:      1: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x60>] UND callee_global_TOC
+# SYMBOL-NEXT: 2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT                UND callee_global_stother0
+# SYMBOL-NEXT: 3: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x20>] UND callee_global_stother1
+
+# SYMBOL: Symbol table '.symtab' contains 12 entries:
+# SYMBOL:      2: 0000000010010000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   6 caller1
+# SYMBOL-NEXT: 3: 0000000010020000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   7 caller2
+# SYMBOL-NEXT: 4: 0000000010030000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   8 caller3
+# SYMBOL:      6: 0000000010010008    16 FUNC    LOCAL  DEFAULT                  6 __plt_pcrel_callee_global_stother0
+# SYMBOL-NEXT: 7: 0000000010020008    16 FUNC    LOCAL  DEFAULT                  7 __plt_pcrel_callee_global_stother1
+# SYMBOL-NEXT: 8: 0000000010030008    16 FUNC    LOCAL  DEFAULT                  8 __plt_pcrel_callee_global_TOC
+# SYMBOL-NEXT: 9: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x60>] UND callee_global_TOC
+# SYMBOL-NEXT: 10: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT                UND callee_global_stother0
+# SYMBOL-NEXT: 11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT [<other: 0x20>] UND callee_global_stother1
+
+## DT_PLTGOT points to .plt
+# SEC: .plt              NOBITS          0000000010030140 040140 000028 00  WA  0   0  8
+# SEC: 0x0000000000000003 (PLTGOT)      0x10030140
+
+## The first 2 entries in the .plt are reserved for the dynamic linkers
+## usage. The JMP_SLOT relocations are stored at .plt[2], .plt[3], .plt[4].
+## Check that we emit 3 R_PPC64_JMP_SLOT in .rela.plt.
+# REL:      .rela.plt {
+# REL-NEXT:   0x10030150 R_PPC64_JMP_SLOT callee_global_stother0 0x0
+# REL-NEXT:   0x10030158 R_PPC64_JMP_SLOT callee_global_stother1 0x0
+# REL-NEXT:   0x10030160 R_PPC64_JMP_SLOT callee_global_TOC 0x0
+# REL-NEXT: }
+
+# CHECK-LABEL: <caller1>:
+# CHECK:       10010000: bl 0x10010008
+# CHECK-NEXT:  10010004: blr
+
+## .plt[2] - 0x10010008 = 0x10030150 - 0x10010008 = 0x20148 = 131400
+# CHECK-LABEL: <__plt_pcrel_callee_global_stother0>:
+# CHECK:       10010008: pld 12, 131400(0), 1
+# CHECK-NEXT:  10010010: mtctr 12
+# CHECK-NEXT:  10010014: bctr
+
+# CHECK-LABEL: <caller2>:
+# CHECK:       10020000: bl 0x10020008
+# CHECK-NEXT:  10020004: blr
+
+## .plt[3] - 0x10020008 = 0x10030158 - 0x10020008 = 0x10150 = 65872
+# CHECK-LABEL: <__plt_pcrel_callee_global_stother1>:
+# CHECK:       10020008: pld 12, 65872(0), 1
+# CHECK-NEXT:  10020010: mtctr 12
+# CHECK-NEXT:  10020014: bctr
+
+# CHECK-LABEL: <caller3>:
+# CHECK:       10030000: bl 0x10030008
+# CHECK-NEXT:  10030004: blr
+
+## .plt[4] - 0x10030008 = 0x10030160 - 0x10030008 = 0x158 = 344
+# CHECK-LABEL: <__plt_pcrel_callee_global_TOC>:
+# CHECK:       10030008: pld 12, 344(0), 1
+# CHECK-NEXT:  10030010: mtctr 12
+# CHECK-NEXT:  10030014: bctr
+
+.ifdef AUX
+.section .text_caller1, "ax", %progbits
+caller1:
+  .localentry caller1, 1
+  bl callee_global_stother0@notoc
+  blr
+.section .text_caller2, "ax", %progbits
+caller2:
+  .localentry caller2, 1
+  bl callee_global_stother1@notoc
+  blr
+
+.section .text_caller3, "ax", %progbits
+caller3:
+  .localentry caller3, 1
+  bl callee_global_TOC@notoc
+  blr
+
+.else
+func_extern:
+  blr
+.globl callee_global_stother0
+callee_global_stother0:
+  blr
+.globl callee_global_stother1
+callee_global_stother1:
+  .localentry callee_global_stother1, 1
+  ## nop is not needed after bl for R_PPC64_REL24_NOTOC
+  bl func_extern@notoc
+  blr
+.globl callee_global_TOC
+callee_global_TOC:
+.Lfunc_gep1:
+  addis 2, 12, .TOC.-.Lfunc_gep1@ha
+  addi 2, 2, .TOC.-.Lfunc_gep1@l
+.Lfunc_lep1:
+  .localentry callee_global_TOC, .Lfunc_lep1-.Lfunc_gep1
+  addis 4, 2, global@toc@ha
+  lwz 3, global@toc@l(4)
+  blr
+global:
+  .long  0
+  .size  global, 4
+.endif

llvm/include/llvm/Object/ELF.h

 }
 
 static inline Error createError(const Twine &Err) {
   return make_error<StringError>(Err, object_error::parse_failed);
 }
 
 enum PPCInstrMasks : uint64_t {
   PADDI_R12_NO_DISP = 0x0610000039800000,
+  PLD_R12_NO_DISP = 0x04100000E5800000,
   MTCTR_R12 = 0x7D8903A6,
   BCTR = 0x4E800420,
 };
 
 template <class ELFT> class ELFFile;
 
 template <class ELFT>
 std::string getSecIndexForError(const ELFFile<ELFT> *Obj,