[X86] enable PIE for functions

[AsafBadouh]

Summary

based on http://reviews.llvm.org/D13481 - Call locally defined function directly for PIE

[rnk]

Can you add a test for other linkages as Rafael asked?

This is still missing a testcase for other linkages (weak_odr and weak at least).

I would test internal, weak, and weak_odr. Include them even if they generate calls through the PLT.

../llvmOrg/lib/Target/X86/X86Subtarget.cpp

148

ditto, run the formatter

../llvmOrg/lib/Target/X86/X86Subtarget.h

559

Is this parameter really necessary? I expect you can remove it, even if you have to change a few test expectations.

561

Run clang-format

[AsafBadouh]

../llvmOrg/lib/Target/X86/X86Subtarget.h

559

I can remove isFast flag but in case it's called from "fastLowerCall" and the return value is "MO_GOTPCREL" I will need to reset it back to zero.
that's because in the fast path we don't handle "NonLazyBind" case in the fast path (see lib/Target/X86/X86ISelLowering.cpp:3333).

do you think we should handle it in the fast path?
or should I remove the flag and reset the return value inside "fastLowerCall"?

[AsafBadouh]

run clang-format and add other linkage testcases

[rnk]

Minor issues, I think this is basically ready

../llvmOrg/lib/Target/X86/X86Subtarget.h

559

Changing fastLowerCall seems nice, it keeps the complexity of what FastISel does local to itself.

../llvmOrg/test/CodeGen/X86/pie.ll

7

Should this be foo{{$}}?

9

Interesting. I would've expected a PLT call for such weak functions so that they can be provided by libraries, but it seems you cannot override a non-ODR weak function from an executable with GCC.

GCC generates a direct, non-PLT call in non-PIE mode, and a PLT call with -fPIE. I'm guessing they just don't do this optimization yet.

[AsafBadouh]

../llvmOrg/lib/Target/X86/X86Subtarget.h

559

NP, will upload fix for that shortly.

../llvmOrg/test/CodeGen/X86/pie.ll

7

yes!

9

I think they do have it in GCC5.3

[AsafBadouh]

update according to Reid comments.

[rnk]

lgtm, thanks!

../llvmOrg/lib/Target/X86/X86FastISel.cpp

if (CalleeOp) {
     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc))
       .addReg(CalleeOp);
   } else {
     // Direct call.
     assert(GV && "Not a direct call");
     unsigned CallOpc = Is64Bit ? X86::CALL64pcrel32 : X86::CALLpcrel32;
 
     // See if we need any target-specific flags on the GV operand.
-    unsigned char OpFlags = 0;
-
-    // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
-    // external symbols most go through the PLT in PIC mode.  If the symbol
-    // has hidden or protected visibility, or if it is static or local, then
-    // we don't need to use the PLT - we can directly call it.
-    if (Subtarget->isTargetELF() &&
-        TM.getRelocationModel() == Reloc::PIC_ &&
-        GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
-      OpFlags = X86II::MO_PLT;
-    } else if (Subtarget->isPICStyleStubAny() &&
-               !GV->isStrongDefinitionForLinker() &&
-               (!Subtarget->getTargetTriple().isMacOSX() ||
-                Subtarget->getTargetTriple().isMacOSXVersionLT(10, 5))) {
-      // PC-relative references to external symbols should go through $stub,
-      // unless we're building with the leopard linker or later, which
-      // automatically synthesizes these stubs.
-      OpFlags = X86II::MO_DARWIN_STUB;
-    }
+    unsigned char OpFlags = Subtarget->classifyGlobalFunctionReference(GV, TM, true);
 
     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc));
     if (Symbol)
       MIB.addSym(Symbol, OpFlags);
     else
       MIB.addGlobalAddress(GV, 0, OpFlags);
   }
 

../llvmOrg/lib/Target/X86/X86ISelLowering.cpp

if (DAG.getTarget().getCodeModel() == CodeModel::Large) {
     // is) turn it into a TargetGlobalAddress node so that legalize doesn't hack
     // it.
     GlobalAddressSDNode* G = cast<GlobalAddressSDNode>(Callee);
 
     // We should use extra load for direct calls to dllimported functions in
     // non-JIT mode.
     const GlobalValue *GV = G->getGlobal();
     if (!GV->hasDLLImportStorageClass()) {
-      unsigned char OpFlags = 0;
-
-      // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
-      // external symbols most go through the PLT in PIC mode.  If the symbol
-      // has hidden or protected visibility, or if it is static or local, then
-      // we don't need to use the PLT - we can directly call it.
-      if (Subtarget.isTargetELF() &&
-          DAG.getTarget().getRelocationModel() == Reloc::PIC_ &&
-          GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
-        OpFlags = X86II::MO_PLT;
-      } else if (Subtarget.isPICStyleStubAny() &&
-                 !GV->isStrongDefinitionForLinker() &&
-                 (!Subtarget.getTargetTriple().isMacOSX() ||
-                  Subtarget.getTargetTriple().isMacOSXVersionLT(10, 5))) {
-        // PC-relative references to external symbols should go through $stub,
-        // unless we're building with the leopard linker or later, which
-        // automatically synthesizes these stubs.
-        OpFlags = X86II::MO_DARWIN_STUB;
-      } else if (Subtarget.isPICStyleRIPRel() && isa<Function>(GV) &&
-                 cast<Function>(GV)->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).
-        OpFlags = X86II::MO_GOTPCREL;
-      }
+      unsigned char OpFlags =
+          Subtarget.classifyGlobalFunctionReference(GV, DAG.getTarget(), false);
 
       Callee = DAG.getTargetGlobalAddress(
           GV, dl, getPointerTy(DAG.getDataLayout()), G->getOffset(), OpFlags);
 
       if (OpFlags == X86II::MO_GOTPCREL) {
         // Add a wrapper.
         Callee = DAG.getNode(X86ISD::WrapperRIP, dl,
           getPointerTy(DAG.getDataLayout()), Callee);

../llvmOrg/lib/Target/X86/X86Subtarget.h

public:
   }
 
   /// ClassifyGlobalReference - Classify a global variable reference for the
   /// current subtarget according to how we should reference it in a non-pcrel
   /// context.
   unsigned char ClassifyGlobalReference(const GlobalValue *GV,
                                         const TargetMachine &TM)const;
 
+  /// classifyGlobalFunctionReference - Classify a global function reference
+  /// for the current subtarget.
+  /// isFast - indicate fastLowerCall, ignore NonLazyBind attribute
+  unsigned char classifyGlobalFunctionReference(const GlobalValue *GV,
+                                                const TargetMachine &TM,
+                                                bool isFast) const;
+
   /// Classify a blockaddress reference for the current subtarget according to
   /// how we should reference it in a non-pcrel context.
   unsigned char ClassifyBlockAddressReference() const;
 
   /// Return true if the subtarget allows calls to immediate address.
   bool IsLegalToCallImmediateAddr(const TargetMachine &TM) const;
 
   /// This function returns the name of a function which has an interface

../llvmOrg/lib/Target/X86/X86Subtarget.cpp

if (isPICStyleStubNoDynamic()) {  // Darwin/32 in -mdynamic-no-pic mode.
     // Otherwise, no stub.
     return X86II::MO_NO_FLAG;
   }
 
   // Direct static reference to global.
   return X86II::MO_NO_FLAG;
 }
 
+unsigned char X86Subtarget::classifyGlobalFunctionReference(
+    const GlobalValue *GV, const TargetMachine &TM, bool isFast) const {
+  // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
+  // external symbols most go through the PLT in PIC mode.  If the symbol
+  // has hidden or protected visibility, or if it is static or local, then
+  // we don't need to use the PLT - we can directly call it.
+  // In PIE mode, calls to global functions don't need to go through PLT
+  if (isTargetELF() && TM.getRelocationModel() == Reloc::PIC_ &&
+      (!TM.Options.PositionIndependentExecutable ||
+       GV->isDeclarationForLinker()) &&
+      GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
+    return X86II::MO_PLT;
+  } else if (isPICStyleStubAny() && !GV->isStrongDefinitionForLinker() &&
+             (!getTargetTriple().isMacOSX() ||
+              getTargetTriple().isMacOSXVersionLT(10, 5))) {
+    // PC-relative references to external symbols should go through $stub,
+    // unless we're building with the leopard linker or later, which
+    // automatically synthesizes these stubs.
+    return X86II::MO_DARWIN_STUB;
+  } else if (!isFast && isPICStyleRIPRel() && isa<Function>(GV) &&
+             cast<Function>(GV)->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).
+    return X86II::MO_GOTPCREL;
+  }
+
+  return X86II::MO_NO_FLAG;
+}
 
 /// This function returns the name of a function which has an interface like
 /// the non-standard bzero function, if such a function exists on the
 /// current subtarget and it is considered preferable over memset with zero
 /// passed as the second argument. Otherwise it returns null.
 const char *X86Subtarget::getBZeroEntry() const {
   // Darwin 10 has a __bzero entry point for this purpose.
   if (getTargetTriple().isMacOSX() &&

../llvmOrg/test/CodeGen/X86/pie.ll

+; RUN: llc < %s -O0 -mcpu=generic -mtriple=i686-linux-gnu -relocation-model=pic -enable-pie | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=i686-linux-gnu -fast-isel -relocation-model=pic -enable-pie | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic -enable-pie | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=x86_64-linux-gnu -fast-isel -relocation-model=pic -enable-pie | FileCheck %s 
+
+; CHECK-LABEL:  bar:
+; CHECK:  call{{l|q}}  foo
+; CHECK:  call{{l|q}}  weak_odr_foo{{$}}
+; CHECK:  call{{l|q}}  weak_foo{{$}}
+; CHECK:  call{{l|q}}  internal_foo{{$}}
+; CHECK:  call{{l|q}}  ext_baz@PLT
+
+define weak void @weak_foo() {
+  ret void
+}
+
+define weak_odr void @weak_odr_foo() {
+  ret void
+}
+
+define internal void @internal_foo() {
+  ret void
+}
+
+declare i32 @ext_baz()
+
+define void @foo() {
+  ret void
+}
+
+define void @bar() {
+entry:
+  call void @foo()
+  call void @weak_odr_foo()
+  call void @weak_foo()
+  call void @internal_foo()
+  call i32 @ext_baz()
+  ret void
+}
+
+; -fpie for local global data tests should be added here