Don't assume a null GV is local for ELF and MachO

[• espindola]

Summary

This is already a simplification, and should help with avoiding a plt reference when calling an intrinsic with -fno-plt.

With this change we return false for null GVs, so caller only needs to check the new metadata to decide if it should use foo@plt or *foo@got.

[davide]

LGTM (I also tested this on Mac). Haven't checked on ELF.

[rnk]

llvm/lib/Target/TargetMachine.cpp

140

Do we ever synthesize references to globals? Those will need a GOT reference if the global turns out to be non-local.

llvm/lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
 
   // Every other GV is local on COFF.
   // Make an exception for windows OS in the triple: Some firmwares builds use
   // *-win32-macho triples. This (accidentally?) produced windows relocations
   // without GOT tables in older clang versions; Keep this behaviour.
   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     return true;
 
+  // If GV is null we know that this is a call to an intrinsic. For ELF and
+  // MachO we don't need to assume those are local since the liker can trivially
+  // convert a call to a PLT to a direct call if the target (in the runtime
+  // library) turns out to be local.
+  if (!GV)
+    return false;
+
   // Most PIC code sequences that assume that a symbol is local cannot
   // produce a 0 if it turns out the symbol is undefined. While this
   // is ABI and relocation depended, it seems worth it to handle it
   // here.
-  if (GV && isPositionIndependent() && GV->hasExternalWeakLinkage())
+  if (isPositionIndependent() && GV->hasExternalWeakLinkage())
     return false;
 
-  if (GV && !GV->hasDefaultVisibility())
+  if (!GV->hasDefaultVisibility())
     return true;
 
   if (TT.isOSBinFormatMachO()) {
     if (RM == Reloc::Static)
       return true;
-    return GV && GV->isStrongDefinitionForLinker();
+    return GV->isStrongDefinitionForLinker();
   }
 
   assert(TT.isOSBinFormatELF());
   assert(RM != Reloc::DynamicNoPIC);
 
   bool IsExecutable =
       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
   if (IsExecutable) {
     // If the symbol is defined, it cannot be preempted.
-    if (GV && !GV->isDeclarationForLinker())
+    if (!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);
+    const Function *F = dyn_cast<Function>(GV);
     if (F && F->hasFnAttribute(Attribute::NonLazyBind))
       return false;
 
-    bool IsTLS = GV && GV->isThreadLocal();
+    bool IsTLS = GV->isThreadLocal();
     bool IsAccessViaCopyRelocs =
-        Options.MCOptions.MCPIECopyRelocations && GV && isa<GlobalVariable>(GV);
+        Options.MCOptions.MCPIECopyRelocations && 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))
       return true;
   }
 

llvm/test/CodeGen/X86/finite-libcalls.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-pc-linux-gnu     | FileCheck %s --check-prefix=CHECK --check-prefix=GNU
 ; RUN: llc < %s -mtriple=x86_64-pc-windows-msvc  | FileCheck %s --check-prefix=CHECK --check-prefix=WIN
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin     | FileCheck %s --check-prefix=CHECK --check-prefix=MAC
 
 ; PR35672 - https://bugs.llvm.org/show_bug.cgi?id=35672
 ; FIXME: We would not need the function-level attributes if FMF were propagated to DAG nodes for this case.
 
 define float @exp_f32(float %x) #0 {
 ; GNU-LABEL: exp_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __expf_finite # TAILCALL
+; GNU-NEXT:    jmp __expf_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: exp_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp expf # TAILCALL
 ;
 ; MAC-LABEL: exp_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _expf ## TAILCALL
   %r = tail call nnan ninf float @llvm.exp.f32(float %x)
   ret float %r
 }
 
 define double @exp_f64(double %x) #0 {
 ; GNU-LABEL: exp_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __exp_finite # TAILCALL
+; GNU-NEXT:    jmp __exp_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: exp_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp exp # TAILCALL
 ;
 ; MAC-LABEL: exp_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _exp ## TAILCALL

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.exp.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @exp2_f32(float %x) #0 {
 ; GNU-LABEL: exp2_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __exp2f_finite # TAILCALL
+; GNU-NEXT:    jmp __exp2f_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: exp2_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp exp2f # TAILCALL
 ;
 ; MAC-LABEL: exp2_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _exp2f ## TAILCALL
   %r = tail call nnan ninf float @llvm.exp2.f32(float %x)
   ret float %r
 }
 
 define double @exp2_f64(double %x) #0 {
 ; GNU-LABEL: exp2_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __exp2_finite # TAILCALL
+; GNU-NEXT:    jmp __exp2_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: exp2_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp exp2 # TAILCALL
 ;
 ; MAC-LABEL: exp2_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _exp2 ## TAILCALL

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.exp2.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @log_f32(float %x) #0 {
 ; GNU-LABEL: log_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __logf_finite # TAILCALL
+; GNU-NEXT:    jmp __logf_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: log_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp logf # TAILCALL
 ;
 ; MAC-LABEL: log_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _logf ## TAILCALL
   %r = tail call nnan ninf float @llvm.log.f32(float %x)
   ret float %r
 }
 
 define double @log_f64(double %x) #0 {
 ; GNU-LABEL: log_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log_finite # TAILCALL
+; GNU-NEXT:    jmp __log_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: log_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log # TAILCALL
 ;
 ; MAC-LABEL: log_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log ## TAILCALL

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.log.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @log2_f32(float %x) #0 {
 ; GNU-LABEL: log2_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log2f_finite # TAILCALL
+; GNU-NEXT:    jmp __log2f_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: log2_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log2f # TAILCALL
 ;
 ; MAC-LABEL: log2_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log2f ## TAILCALL
   %r = tail call nnan ninf float @llvm.log2.f32(float %x)
   ret float %r
 }
 
 define double @log2_f64(double %x) #0 {
 ; GNU-LABEL: log2_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log2_finite # TAILCALL
+; GNU-NEXT:    jmp __log2_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: log2_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log2 # TAILCALL
 ;
 ; MAC-LABEL: log2_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log2 ## TAILCALL

 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.log2.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @log10_f32(float %x) #0 {
 ; GNU-LABEL: log10_f32:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log10f_finite # TAILCALL
+; GNU-NEXT:    jmp __log10f_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: log10_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log10f # TAILCALL
 ;
 ; MAC-LABEL: log10_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log10f ## TAILCALL
   %r = tail call nnan ninf float @llvm.log10.f32(float %x)
   ret float %r
 }
 
 define double @log10_f64(double %x) #0 {
 ; GNU-LABEL: log10_f64:
 ; GNU:       # %bb.0:
-; GNU-NEXT:    jmp __log10_finite # TAILCALL
+; GNU-NEXT:    jmp __log10_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: log10_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    jmp log10 # TAILCALL
 ;
 ; MAC-LABEL: log10_f64:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    jmp _log10 ## TAILCALL
; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.log10.f80(x86_fp80 %x)
   ret x86_fp80 %r
 }
 
 define float @pow_f32(float %x) #0 {
 ; GNU-LABEL: pow_f32:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    movaps %xmm0, %xmm1
-; GNU-NEXT:    jmp __powf_finite # TAILCALL
+; GNU-NEXT:    jmp __powf_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: pow_f32:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    movaps %xmm0, %xmm1
 ; WIN-NEXT:    jmp powf # TAILCALL
 ;
 ; MAC-LABEL: pow_f32:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    movaps %xmm0, %xmm1
 ; MAC-NEXT:    jmp _powf ## TAILCALL
   %r = tail call nnan ninf float @llvm.pow.f32(float %x, float %x)
   ret float %r
 }
 
 define double @pow_f64(double %x) #0 {
 ; GNU-LABEL: pow_f64:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    movaps %xmm0, %xmm1
-; GNU-NEXT:    jmp __pow_finite # TAILCALL
+; GNU-NEXT:    jmp __pow_finite@PLT # TAILCALL
 ;
 ; WIN-LABEL: pow_f64:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    movaps %xmm0, %xmm1
 ; WIN-NEXT:    jmp pow # TAILCALL
 ;
 ; MAC-LABEL: pow_f64:
 ; MAC:       ## %bb.0:

llvm/test/CodeGen/X86/fp-intrinsics.ll

%result = call double @llvm.experimental.constrained.nearbyint.f64(
                                                metadata !"round.dynamic",
                                                metadata !"fpexcept.strict")
   ret double %result
 }
 
 ; Verify that fma(3.5) isn't simplified when the rounding mode is
 ; unknown.
 ; CHECK-LABEL: f17
-; FMACALL32: jmp fmaf  # TAILCALL
+; FMACALL32: jmp fmaf@PLT  # TAILCALL
 ; FMA32: vfmadd213ss
 define float @f17() {
 entry:
   %result = call float @llvm.experimental.constrained.fma.f32(
                                                float 3.5,
                                                float 3.5,
                                                float 3.5,
                                                metadata !"round.dynamic",
                                                metadata !"fpexcept.strict")
   ret float %result
 }
 
 ; Verify that fma(42.1) isn't simplified when the rounding mode is
 ; unknown.
 ; CHECK-LABEL: f18
-; FMACALL64: jmp fma  # TAILCALL
+; FMACALL64: jmp fma@PLT  # TAILCALL
 ; FMA64: vfmadd213sd
 define double @f18() {
 entry:
   %result = call double @llvm.experimental.constrained.fma.f64(
                                                double 42.1,
                                                double 42.1,
                                                double 42.1,
                                                metadata !"round.dynamic",

llvm/test/CodeGen/X86/half.ll

; CHECK-I686-NEXT:    retl
   store half %val_fp, half* %addr
   ret void
 }
 
 define float @test_extend32(half* %addr) #0 {
 ; CHECK-LIBCALL-LABEL: test_extend32:
 ; CHECK-LIBCALL:       # %bb.0:
 ; CHECK-LIBCALL-NEXT:    movzwl (%rdi), %edi
-; CHECK-LIBCALL-NEXT:    jmp __gnu_h2f_ieee # TAILCALL
+; CHECK-LIBCALL-NEXT:    jmp __gnu_h2f_ieee@PLT # TAILCALL
 ;
 ; BWON-F16C-LABEL: test_extend32:
 ; BWON-F16C:       # %bb.0:
 ; BWON-F16C-NEXT:    movswl (%rdi), %eax
 ; BWON-F16C-NEXT:    vmovd %eax, %xmm0
 ; BWON-F16C-NEXT:    vcvtph2ps %xmm0, %xmm0
 ; BWON-F16C-NEXT:    retq
 ;

llvm/test/CodeGen/X86/memset-nonzero.ll

; AVX2-NEXT:    retq
   tail call void @llvm.memset.p0i8.i64(i8* %x, i8 %c, i64 128, i32 1, i1 false)
   ret void
 }
 
 define void @memset_256_nonconst_bytes(i8* %x, i8 %c) {
 ; SSE-LABEL: memset_256_nonconst_bytes:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movl $256, %edx # imm = 0x100
-; SSE-NEXT:    jmp memset # TAILCALL
+; SSE-NEXT:    jmp memset@PLT # TAILCALL
 ;
 ; SSE2FAST-LABEL: memset_256_nonconst_bytes:
 ; SSE2FAST:       # %bb.0:
 ; SSE2FAST-NEXT:    movd %esi, %xmm0
 ; SSE2FAST-NEXT:    punpcklbw {{.*#+}} xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
 ; SSE2FAST-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,0,2,3,4,5,6,7]
 ; SSE2FAST-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[0,0,0,0]
 ; SSE2FAST-NEXT:    movdqu %xmm0, 240(%rdi)

llvm/test/CodeGen/X86/negative-sin.ll

 }
 
 ; 'fast' implies no-signed-zeros, so the negates fold away.
 ; The 'sin' does not need any fast-math-flags for this transform.
 
 define double @fast(double %e) nounwind {
 ; CHECK-LABEL: fast:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    jmp sin # TAILCALL
+; CHECK-NEXT:    jmp sin@PLT # TAILCALL
   %f = fsub fast double 0.0, %e
   %g = call double @sin(double %f) readonly
   %h = fsub fast double 0.0, %g
   ret double %h
 }
 
 ; No-signed-zeros is all that we need for this transform.
 
 define double @nsz(double %e) nounwind {
 ; CHECK-LABEL: nsz:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    jmp sin # TAILCALL
+; CHECK-NEXT:    jmp sin@PLT # TAILCALL
   %f = fsub nsz double 0.0, %e
   %g = call double @sin(double %f) readonly
   %h = fsub nsz double 0.0, %g
   ret double %h
 }
 
 ; The 1st negate is strict, so we can't kill that sub, but the 2nd disappears.
 

 }
 
 ; FIXME:
 ; Auto-upgrade function attribute to IR-level fast-math-flags.
 
 define double @fn_attr(double %e) nounwind #0 {
 ; CHECK-LABEL: fn_attr:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    jmp sin # TAILCALL
+; CHECK-NEXT:    jmp sin@PLT # TAILCALL
   %f = fsub double 0.0, %e
   %g = call double @sin(double %f) readonly
   %h = fsub double 0.0, %g
   ret double %h
 }
 
 attributes #0 = { "unsafe-fp-math"="true" "no-signed-zeros-fp-math"="true" }
 

llvm/test/CodeGen/X86/vector-half-conversions.ll

 
 ;
 ; Double to Half
 ;
 
 define i16 @cvt_f64_to_i16(double %a0) nounwind {
 ; ALL-LABEL: cvt_f64_to_i16:
 ; ALL:       # %bb.0:
-; ALL-NEXT:    jmp __truncdfhf2 # TAILCALL
+; ALL-NEXT:    jmp __truncdfhf2@PLT # TAILCALL
   %1 = fptrunc double %a0 to half
   %2 = bitcast half %1 to i16
   ret i16 %2
 }
 
 define <2 x i16> @cvt_2f64_to_2i16(<2 x double> %a0) nounwind {
 ; ALL-LABEL: cvt_2f64_to_2i16:
 ; ALL:       # %bb.0: