Use New Module Metadata String "AvoidPLT" to avoid calls via PLT

[tmsriram]

Summary

Introduce a Module Metadata String "AvoidPLT" to avoid calls via PLT.

Annotating functions with nonlazybind attribute to avoid the PLT does not work for intrinsics. Intrinsics need to be handled specially and it seems easier to handle them by just annotating the module.

[rnk]

AvoidPLT doesn't seem like the best name. A more affirmative name like "RtlibUseGOT" might be better.

lib/IR/Module.cpp

518 ↗

(On Diff #130314)

Maybe this should check Val->getZExtValue for a non-zero value.

test/CodeGen/X86/no-plt.ll

14 ↗

(On Diff #130314)

Can you test a few other RTLIB functions like i128 multiply and memset, just for generality?

[tmsriram]

Rafael's change included and test case updated. "Avoid PLT" changed to "RtLibUseGOT".

[tmsriram]

Updated to incorporate Rafael's changes.

[tmsriram]

Updated patch.

[tmsriram]

Patch updated.

llvm/trunk/include/llvm/IR/Module.h

/// @}
 
   /// \brief Attach profile summary metadata to this module.
   void setProfileSummary(Metadata *M);
 
   /// \brief Returns profile summary metadata
   Metadata *getProfileSummary();
   /// @}
 
+  /// Returns true if PLT should be avoided for RTLib calls.
+  bool getRtLibUseGOT() const;
+
+  /// Set that PLT should be avoid for RTLib calls.
+  void setRtLibUseGOT();
+
+
   /// Take ownership of the given memory buffer.
   void setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB);
 };
 
 /// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect
 /// the initializer elements of that global in Set and return the global itself.
 GlobalVariable *collectUsedGlobalVariables(const Module &M,
                                            SmallPtrSetImpl<GlobalValue *> &Set,

llvm/trunk/lib/IR/Module.cpp

 Metadata *Module::getProfileSummary() {
   return getModuleFlag("ProfileSummary");
 }
 
 void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
   OwnedMemoryBuffer = std::move(MB);
 }
 
+bool Module::getRtLibUseGOT() const {
+  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
+  return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
+}
+
+void Module::setRtLibUseGOT() {
+  addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
+}
+
 GlobalVariable *llvm::collectUsedGlobalVariables(
     const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
   const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
   GlobalVariable *GV = M.getGlobalVariable(Name);
   if (!GV || !GV->hasInitializer())
     return GV;
 
   const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
   for (Value *Op : Init->operands()) {
     GlobalValue *G = cast<GlobalValue>(Op->stripPointerCastsNoFollowAliases());
     Set.insert(G);
   }
   return GV;
 }

llvm/trunk/lib/Target/X86/X86ISelLowering.cpp

if (DAG.getTarget().getCodeModel() == CodeModel::Large) {
     }
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
     const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
     unsigned char OpFlags =
         Subtarget.classifyGlobalFunctionReference(nullptr, *Mod);
 
     Callee = DAG.getTargetExternalSymbol(
         S->getSymbol(), getPointerTy(DAG.getDataLayout()), OpFlags);
+
+    if (OpFlags == X86II::MO_GOTPCREL) {
+      Callee = DAG.getNode(X86ISD::WrapperRIP, dl,
+          getPointerTy(DAG.getDataLayout()), Callee);
+      Callee = DAG.getLoad(
+          getPointerTy(DAG.getDataLayout()), dl, DAG.getEntryNode(), Callee,
+          MachinePointerInfo::getGOT(DAG.getMachineFunction()));
+    }
   } else if (Subtarget.isTarget64BitILP32() &&
              Callee->getValueType(0) == MVT::i32) {
     // Zero-extend the 32-bit Callee address into a 64-bit according to x32 ABI
     Callee = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Callee);
   }
 
   // Returns a chain & a flag for retval copy to use.
   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);

llvm/trunk/lib/Target/X86/X86Subtarget.cpp

X86Subtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
   const Function *F = dyn_cast_or_null<Function>(GV);
 
   if (isTargetELF()) {
     if (is64Bit() && F && (CallingConv::X86_RegCall == F->getCallingConv()))
       // According to psABI, PLT stub clobbers XMM8-XMM15.
       // In Regcall calling convention those registers are used for passing
       // parameters. Thus we need to prevent lazy binding in Regcall.
       return X86II::MO_GOTPCREL;
-    if (F && F->hasFnAttribute(Attribute::NonLazyBind) && is64Bit())
+    // If PLT must be avoided then the call should be via GOTPCREL.
+    if (((F && F->hasFnAttribute(Attribute::NonLazyBind)) ||
+         (!F && M.getRtLibUseGOT())) &&
+        is64Bit())
        return X86II::MO_GOTPCREL;
     return X86II::MO_PLT;
   }
 
   if (is64Bit()) {
     if (F && F->hasFnAttribute(Attribute::NonLazyBind))
       // If the function is marked as non-lazy, generate an indirect call
       // which loads from the GOT directly. This avoids runtime overhead
       // at the cost of eager binding (and one extra byte of encoding).

llvm/trunk/test/CodeGen/X86/no-plt.ll

 ; RUN: llc < %s -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X64 --check-prefix=PIC %s
 ; RUN: llc < %s -mcpu=generic -mtriple=x86_64-linux-gnu \
 ; RUN:   | FileCheck -check-prefix=X64 --check-prefix=STATIC %s
 
+define void @memset_call(i8* nocapture %a, i8 %c, i32 %n) {
+; X64: callq *memset@GOTPCREL(%rip)
+  call void @llvm.memset.p0i8.i32(i8* %a, i8 %c, i32 %n, i1 false)
+  ret void
+}
+
+define void @memcpy_call(i8* nocapture %a, i8* nocapture readonly %b, i64 %n) {
+; X64: callq *memcpy@GOTPCREL(%rip)
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 %n, i32 1, i1 false)
+  ret void
+}
+
 define i32 @main() {
 ; X64:    callq *foo@GOTPCREL(%rip)
 ; PIC:    callq bar@PLT
 ; STATIC: callq bar{{$}}
 ; X64:    callq baz
 
   %retval = alloca i32, align 4
   store i32 0, i32* %retval, align 4
   %call1 = call i32 @foo()
   %call2 = call i32 @bar()
   %call3 = call i32 @baz()
   ret i32 0
 }
 
 declare i32 @foo() nonlazybind
 declare i32 @bar()
 declare hidden i32 @baz() nonlazybind
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
+declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1)
+
+!llvm.module.flags = !{!1}
+!1 = !{i32 7, !"RtLibUseGOT", i32 1}