Allow constant-folding intrinsics that are non-pure for inference only

base/compiler/optimize.jl

@@ -252,17 +252,21 @@ function optimize(opt::OptimizationState, @nospecialize(result))
     nothing
 end
 
-
-# whether `f` is pure for inference
-function is_pure_intrinsic_infer(f::IntrinsicFunction)
+# whether `f` is pure for optimization purposes
+function is_pure_intrinsic_optimize(f::IntrinsicFunction)
     return !(f === Intrinsics.pointerref || # this one is volatile
              f === Intrinsics.pointerset || # this one is never effect-free
              f === Intrinsics.llvmcall ||   # this one is never effect-free
              f === Intrinsics.arraylen ||   # this one is volatile
-             f === Intrinsics.sqrt_llvm ||  # this one may differ at runtime (by a few ulps)
              f === Intrinsics.cglobal)  # cglobal lookup answer changes at runtime
 end
 
+# whether `f` is pure for inference
+is_pure_intrinsic_optimize_only(f) = f === Intrinsics.sqrt_llvm # this one may differ by a few ulps at runtime
+function is_pure_intrinsic_infer(f::IntrinsicFunction)
+    return is_pure_intrinsic_optimize(f) && !is_pure_intrinsic_optimize_only(f)
+end
+
 # whether `f` is effect free if nothrow
 intrinsic_effect_free_if_nothrow(f) = f === Intrinsics.pointerref || is_pure_intrinsic_infer(f)
 

base/compiler/ssair/inlining.jl

@@ -1077,6 +1077,21 @@ function ispuretopfunction(@nospecialize(f))
         istopfunction(f, :promote_type)
 end
 
+function intrinsic_tfunc_optimize(f::IntrinsicFunction, atypes::Vector{Any})
+    is_pure_intrinsic_optimize(f) || return nothing
+    args = atypes[2:end]
+    _all(@nospecialize(a) -> isa(a, Const), args) || return nothing
+    iidx = Int(reinterpret(Int32, f::IntrinsicFunction)) + 1
+    if iidx < 0 || iidx > length(T_IFUNC)
+        # invalid intrinsic
+        return nothing
+    end
+    (min, max, _) = T_IFUNC[iidx]
+    min <= length(atypes) - 1 <= max || return nothing
+    argvals = anymap(a::Const -> a.val, atypes[2:end])
+    return f(argvals...)
+end
+
 function early_inline_special_case(ir::IRCode, @nospecialize(f), @nospecialize(ft), e::Expr, atypes::Vector{Any}, sv::OptimizationState,
                                    @nospecialize(etype))
     if (f === typeassert || ft ⊑ typeof(typeassert)) && length(atypes) == 3
@@ -1106,6 +1121,12 @@ function early_inline_special_case(ir::IRCode, @nospecialize(f), @nospecialize(f
                     return quoted(val)
                 end
             end
+        elseif isa(f, IntrinsicFunction) && is_pure_intrinsic_optimize_only(f)
+            # If this intrinsic was not eligible for constant propagation during
+            # inference, but is now, try to do that here.
+            val = intrinsic_tfunc_optimize(f, atypes)
+            val === nothing && return nothing
+            return quoted(val)
         end
     end
 

test/compiler/inline.jl

@@ -247,3 +247,14 @@ let code = code_typed(f_pointerref, Tuple{Type{Int}})[1][1].code
     end
     @test !any_ptrref
 end
+
+f_sqrt() = sqrt(2)
+let code = code_typed(f_sqrt, Tuple{})[1][1].code
+    @test length(code) == 1
+    @test isa(code[1], Expr) && code[1].head == :return && isa(code[1].args[1], Float64)
+end
+# Make sure that the optimization doesn't apply to invalid calls
+f_sqrt_wrong() = Base.Math.sqrt_llvm(1.0, 2.0)
+let (ci, rt) = (code_typed(f_sqrt_wrong, Tuple{})[1])
+    @test rt === Union{}
+end