[RISCV] Support NonLazyBind

[M_ximus]

Summary

This patch is needed to load call address from shared library without the PLT(load from the GOT).

[lenary]

@jrtc27 your input here would be valuable.

[jrtc27]

Looks sensible in general, just various minor points.

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

2187–2189

This comment probably needs updating to reflect the fact that GlobalAddress/ExternalSymbol may now become a normal node and indirectly called if using NonLazyBind.

2194

This should only be an additional 4 spaces of indentation.

2195–2199

Please remove this extra line.

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

58

The dyn_cast seems a bit weird but AArch64 and X86 (the only other backends supporting this) both do that so I guess it's fine. However, the MO_CALL fallback case is a change of behaviour; non-function non-DSO-locals would previously have still been called with an MO_PLT, so the F && should be part of the F->hasFnAttribute condition.

llvm/lib/Target/RISCV/RISCVSubtarget.h

71

"the PLT" and "the GOT".

llvm/test/CodeGen/RISCV/no-plt.ll

2

Please do this for -mtriple=riscv32 and -mtriple=riscv64 (no -linux-gnu is generally used in the CodeGen tests unless it's necessary), and use a single - for -relocation-model.

7

Please use update_llc_test_checks.py (and my own personal opinion is this would look nicer with a lowercase plt in the function name).

[jrtc27]

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

2197

The 0 should be false since IsLocal is a bool, and ideally /*IsLocal=*/false to document what it means.

[M_ximus]

All mistakes in the patch were fixed.

[jrtc27]

A couple of minor remaining points.

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

2187–2189

Actually I should have been more accurate; only GlobalAddress nodes will become indirect calls, ExternalSymbols will always be direct calls through TargetExternalSymbol nodes, since this only changes the GlobalAddress branch (as you need the function to get its attributes).

llvm/test/CodeGen/RISCV/no-plt.ll

2

Still missing a -mtriple=riscv32 line.

[M_ximus]

I added -mtriple=riscv32 line and fixed the comment

[MaskRay]

-fno-plt essentially inlines the PLT entry into the call site. For x86-64, there are benefits if many call sites are defined in different DSOs.

If the callee is actually defined, -fno-plt is actually pessimization. I don't think -fno-plt is useful. Usually people just need some __attribute__((noplt)) on libc functions. Clang has not implemented it, though.

llvm/lib/Target/RISCV/RISCVISelLowering.cpp

SDValue RISCVTargetLowering::LowerCall(CallLoweringInfo &CLI,
   // Build a sequence of copy-to-reg nodes, chained and glued together.
   for (auto &Reg : RegsToPass) {
     Chain = DAG.getCopyToReg(Chain, DL, Reg.first, Reg.second, Glue);
     Glue = Chain.getValue(1);
   }
 
   // If the callee is a GlobalAddress/ExternalSymbol node, turn it into a
   // TargetGlobalAddress/TargetExternalSymbol node so that legalize won't
   // split it and then direct call can be matched by PseudoCALL.
+  // GlobalAddress may become a normal node
+  // and indirectly called if using NonLazyBind.
   if (GlobalAddressSDNode *S = dyn_cast<GlobalAddressSDNode>(Callee)) {
     const GlobalValue *GV = S->getGlobal();
 
-    unsigned OpFlags = RISCVII::MO_CALL;
-    if (!getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV))
-      OpFlags = RISCVII::MO_PLT;
+    unsigned OpFlags =
+        Subtarget.classifyGlobalFunctionReference(GV, getTargetMachine());
 
+    if (OpFlags == RISCVII::MO_GOT_HI)
+      Callee = getAddr(S, DAG, /*IsLocal=*/false);
+    else
       Callee = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, OpFlags);
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
     unsigned OpFlags = RISCVII::MO_CALL;
 
     if (!getTargetMachine().shouldAssumeDSOLocal(*MF.getFunction().getParent(),
                                                  nullptr))
       OpFlags = RISCVII::MO_PLT;
 
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), PtrVT, OpFlags);

llvm/lib/Target/RISCV/RISCVSubtarget.h

public:
   // Initializes the data members to match that of the specified triple.
   RISCVSubtarget(const Triple &TT, StringRef CPU, StringRef FS,
                  StringRef ABIName, const TargetMachine &TM);
 
   // Parses features string setting specified subtarget options. The
   // definition of this function is auto-generated by tblgen.
   void ParseSubtargetFeatures(StringRef CPU, StringRef FS);
 
+  // Return how the function given by GV should be invoked:
+  // via the PLT, by taking its address from the GOT, or with a direct call.
+  unsigned char classifyGlobalFunctionReference(const GlobalValue *GV,
+              const TargetMachine &TM) const;
+
   const RISCVFrameLowering *getFrameLowering() const override {
     return &FrameLowering;
   }
   const RISCVInstrInfo *getInstrInfo() const override { return &InstrInfo; }
   const RISCVRegisterInfo *getRegisterInfo() const override {
     return &RegInfo;
   }
   const RISCVTargetLowering *getTargetLowering() const override {

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

 RISCVSubtarget::RISCVSubtarget(const Triple &TT, StringRef CPU, StringRef FS,
                                StringRef ABIName, const TargetMachine &TM)
     : RISCVGenSubtargetInfo(TT, CPU, FS),
       FrameLowering(initializeSubtargetDependencies(TT, CPU, FS, ABIName)),
       InstrInfo(), RegInfo(getHwMode()), TLInfo(TM, *this) {
   CallLoweringInfo.reset(new RISCVCallLowering(*getTargetLowering()));
   Legalizer.reset(new RISCVLegalizerInfo(*this));
 
   auto *RBI = new RISCVRegisterBankInfo(*getRegisterInfo());
   RegBankInfo.reset(RBI);
   InstSelector.reset(createRISCVInstructionSelector(
       *static_cast<const RISCVTargetMachine *>(&TM), *this, *RBI));
 }
 
+unsigned char RISCVSubtarget::classifyGlobalFunctionReference(
+    const GlobalValue *GV, const TargetMachine &TM) const {
+  auto *F = dyn_cast<Function>(GV);
+  if (!TM.shouldAssumeDSOLocal(*GV->getParent(), GV)) {
+    if (F && F->hasFnAttribute(Attribute::NonLazyBind))
+      return RISCVII::MO_GOT_HI;
+    return RISCVII::MO_PLT;
+  }
+  return RISCVII::MO_CALL;
+}
+
 const CallLowering *RISCVSubtarget::getCallLowering() const {
   return CallLoweringInfo.get();
 }
 
 InstructionSelector *RISCVSubtarget::getInstructionSelector() const {
   return InstSelector.get();
 }
 
 const LegalizerInfo *RISCVSubtarget::getLegalizerInfo() const {
   return Legalizer.get();
 }
 
 const RegisterBankInfo *RISCVSubtarget::getRegBankInfo() const {
   return RegBankInfo.get();
 }

llvm/test/CodeGen/RISCV/no-plt.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -mtriple=riscv64 -relocation-model=pic < %s \
+; RUN:     | FileCheck -check-prefix=RV64 %s
+; RUN: llc -mtriple=riscv32 -relocation-model=pic < %s \
+; RUN:     | FileCheck -check-prefix=RV32 %s
+
+declare void @global() nonlazybind
+
+define void @no_plt_call() nounwind {
+; RV64-LABEL: no_plt_call:
+; RV64:       # %bb.0:
+; RV64-NEXT:    addi sp, sp, -16
+; RV64-NEXT:    sd ra, 8(sp)
+; RV64-NEXT:  .LBB0_1: # Label of block must be emitted
+; RV64-NEXT:    auipc a0, %got_pcrel_hi(global)
+; RV64-NEXT:    ld a0, %pcrel_lo(.LBB0_1)(a0)
+; RV64-NEXT:    jalr a0
+; RV64-NEXT:    ld ra, 8(sp)
+; RV64-NEXT:    addi sp, sp, 16
+; RV64-NEXT:    ret
+;
+; RV32-LABEL: no_plt_call:
+; RV32:       # %bb.0:
+; RV32-NEXT:    addi sp, sp, -16
+; RV32-NEXT:    sw ra, 12(sp)
+; RV32-NEXT:  .LBB0_1: # Label of block must be emitted
+; RV32-NEXT:    auipc a0, %got_pcrel_hi(global)
+; RV32-NEXT:    lw a0, %pcrel_lo(.LBB0_1)(a0)
+; RV32-NEXT:    jalr a0
+; RV32-NEXT:    lw ra, 12(sp)
+; RV32-NEXT:    addi sp, sp, 16
+; RV32-NEXT:    ret
+  call void @global()
+  ret void
+}