With -fno-plt, GOTPCREL references must use RIP

[tmsriram]

Summary

With -fno-plt, global value references can use GOTPCREL and RIP must be used.

A simple example that breaks with -fno-plt:

extern "C"
{
attribute((weak)) int weakfunc();

int fp_weakfunc() {

if (&weakfunc)
  return 1;
return 0;

}
}

$ clang -O2 -fno-plt -S file.cc
$ cat file.s
...
fp_weakfunc: # @fp_weakfunc
.cfi_startproc

%bb.0:

xorl %eax, %eax
cmpq $0, weakfunc@GOTPCREL
...

That's a GOTPCREL reference without %rip. This will force the linker to only patch it with the offset in the GOT and will get the exact opposite program behavior at run-time. This patch fixes it.

[• espindola]

LGTM with nits.

lib/Target/X86/X86ISelLowering.cpp

15511

The comment and assert feel a bit much. It is sufficient to say that a GOTPCREL always needs (%rip).

test/CodeGen/X86/no-plt.ll

6

you don't need:

dso_local
local_unnamed_addr
"#0"
entry:

please simplify.

[tmsriram]

Simplify test and condition.

lib/Target/X86/X86ISelLowering.h

std::pair<SDValue,SDValue> FP_TO_INTHelper(SDValue Op, SelectionDAG &DAG,
                                                bool isSigned,
                                                bool isReplace) const;
 
     SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerVSELECT(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
 
-    unsigned getGlobalWrapperKind(const GlobalValue *GV = nullptr) const;
+    unsigned getGlobalWrapperKind(const GlobalValue *GV = nullptr,
+                                  const unsigned char OpFlags = 0) const;
     SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerGlobalAddress(const GlobalValue *GV, const SDLoc &dl,
                                int64_t Offset, SelectionDAG &DAG) const;
     SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
 

lib/Target/X86/X86ISelLowering.cpp

static SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, const X86Subtarget &Subtarget,
   Vec = DAG.getNode(X86ISD::KSHIFTR, dl, WideVecVT, Vec,
                     DAG.getConstant(IdxVal, dl, MVT::i8));
 
   return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, Op.getValueType(), Vec,
                      DAG.getIntPtrConstant(0, dl));
 }
 
 // Returns the appropriate wrapper opcode for a global reference.
-unsigned X86TargetLowering::getGlobalWrapperKind(const GlobalValue *GV) const {
+unsigned X86TargetLowering::getGlobalWrapperKind(
+    const GlobalValue *GV, const unsigned char OpFlags) const {
   // References to absolute symbols are never PC-relative.
   if (GV && GV->isAbsoluteSymbolRef())
     return X86ISD::Wrapper;
 
   CodeModel::Model M = getTargetMachine().getCodeModel();
   if (Subtarget.isPICStyleRIPRel() &&
       (M == CodeModel::Small || M == CodeModel::Kernel))
     return X86ISD::WrapperRIP;
 
+  // GOTPCREL references are possible without PIC when using "nonlazybind"
+  // attribute.  Always use RIP when this is found.
+  if (OpFlags == X86II::MO_GOTPCREL) {
+    const Function *F = dyn_cast_or_null<Function>(GV);
+    assert(((F && F->hasFnAttribute(Attribute::NonLazyBind)) ||
+           (!F && GV->getParent()->getRtLibUseGOT())) &&
+           Subtarget.is64Bit());
+    return X86ISD::WrapperRIP;
+  }
+
   return X86ISD::Wrapper;
 }
 
 // ConstantPool, JumpTable, GlobalAddress, and ExternalSymbol are lowered as
 // their target counterpart wrapped in the X86ISD::Wrapper node. Suppose N is
 // one of the above mentioned nodes. It has to be wrapped because otherwise
 // Select(N) returns N. So the raw TargetGlobalAddress nodes, etc. can only
 // be used to form addressing mode. These wrapped nodes will be selected
if (OpFlags == X86II::MO_NO_FLAG &&
       X86::isOffsetSuitableForCodeModel(Offset, M)) {
     // A direct static reference to a global.
     Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset);
     Offset = 0;
   } else {
     Result = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, OpFlags);
   }
 
-  Result = DAG.getNode(getGlobalWrapperKind(GV), dl, PtrVT, Result);
+  Result = DAG.getNode(getGlobalWrapperKind(GV, OpFlags), dl, PtrVT, Result);
 
   // With PIC, the address is actually $g + Offset.
   if (isGlobalRelativeToPICBase(OpFlags)) {
     Result = DAG.getNode(ISD::ADD, dl, PtrVT,
                          DAG.getNode(X86ISD::GlobalBaseReg, dl, PtrVT), Result);
   }
 
   // For globals that require a load from a stub to get the address, emit the

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 dso_local i32 @fp_weakfunc() local_unnamed_addr #0 {
+entry:
+; X64: weakfunc@GOTPCREL(%rip)
+  ret i32 select (i1 icmp ne (i32 ()* @weakfunc, i32 ()* null), i32 1, i32 0)
+}
+declare extern_weak i32 @weakfunc() nonlazybind
+
 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)