Attribute nonlazybind should not affect calls to functions with hidden visibility

[tmsriram]

Summary

Attribute nonlazybind should not affect calls to functions with hidden visibility.

https://reviews.llvm.org/D39065 skips the PLT for calls to external functions marked with "nonlazybind" attribute. However, this should not affect functions with hidden visibility or local linkage. This patch fixes that.

[tmsriram]

Change shouldAssumeDSOLocal to be aware of nonlazybind attribute.

[tmsriram]

Fix comment as suggested.

lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
 
   bool IsExecutable =
       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
   if (IsExecutable) {
     // If the symbol is defined, it cannot be preempted.
     if (GV && !GV->isDeclarationForLinker())
       return true;
 
+    // A symbol marked nonlazybind should not be accessed with a plt. If the
+    // symbol turns out to be external, the linker will convert a direct
+    // access to an access via the plt, so don't assume it is local.
+    const Function *F = dyn_cast_or_null<Function>(GV);
+    if (F && F->hasFnAttribute(Attribute::NonLazyBind))
+      return false;
+
     bool IsTLS = GV && GV->isThreadLocal();
     bool IsAccessViaCopyRelocs =
         Options.MCOptions.MCPIECopyRelocations && GV && isa<GlobalVariable>(GV);
     Triple::ArchType Arch = TT.getArch();
     bool IsPPC =
         Arch == Triple::ppc || Arch == Triple::ppc64 || Arch == Triple::ppc64le;
     // Check if we can use copy relocations. PowerPC has no copy relocations.
     if (!IsTLS && !IsPPC && (RM == Reloc::Static || IsAccessViaCopyRelocs))

lib/Target/X86/X86Subtarget.cpp

 unsigned char
 X86Subtarget::classifyGlobalFunctionReference(const GlobalValue *GV) const {
   return classifyGlobalFunctionReference(GV, *GV->getParent());
 }
 
 unsigned char
 X86Subtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
                                               const Module &M) const {
-  const Function *F = dyn_cast_or_null<Function>(GV);
-
-  // Do not use the PLT when explicitly told to do so for ELF 64-bit
-  // target.
-  if (isTargetELF() && is64Bit() && F &&
-      F->hasFnAttribute(Attribute::NonLazyBind) &&
-      GV->isDeclarationForLinker())
-    return X86II::MO_GOTPCREL;
-
   if (TM.shouldAssumeDSOLocal(M, GV))
     return X86II::MO_NO_FLAG;
 
   if (isTargetCOFF()) {
     assert(GV->hasDLLImportStorageClass() &&
            "shouldAssumeDSOLocal gave inconsistent answer");
     return X86II::MO_DLLIMPORT;
   }
 
+  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())
+      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).

test/CodeGen/X86/no-plt.ll

 ; RUN: llc < %s -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X64 %s
 ; RUN: llc < %s -mcpu=generic -mtriple=x86_64-linux-gnu \
 ; RUN:   | FileCheck -check-prefix=X64 %s
 
 define i32 @main() #0 {
 ; X64: callq *_Z3foov@GOTPCREL(%rip)
 ; X64: callq _Z3barv
+; X64: callq _Z3bazv
 
 entry:
   %retval = alloca i32, align 4
   store i32 0, i32* %retval, align 4
   %call1 = call i32 @_Z3foov()
   %call2 = call i32 @_Z3barv()
+  %call3 = call i32 @_Z3bazv()
   ret i32 0
 }
 
 ; Function Attrs: nonlazybind
 declare i32 @_Z3foov() #1
 
 declare i32 @_Z3barv() #2
 
+; Function Attrs: nonlazybind
+declare hidden i32 @_Z3bazv() #3
+
+
 attributes #1 = { nonlazybind }
+attributes #3 = { nonlazybind }