Allow eliminating nothrow intrinsics during optimization

Author: Keno

base/compiler/optimize.jl

@@ -262,19 +262,6 @@ function is_pure_intrinsic_infer(f::IntrinsicFunction)
              f === Intrinsics.cglobal)  # cglobal lookup answer changes at runtime
 end
 
-# whether `f` is pure for optimizations
-function is_pure_intrinsic_optim(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.checked_sdiv_int ||  # these may throw errors
-             f === Intrinsics.checked_udiv_int ||
-             f === Intrinsics.checked_srem_int ||
-             f === Intrinsics.checked_urem_int ||
-             f === Intrinsics.cglobal)  # cglobal throws an error for symbol-not-found
-end
-
 ## Computing the cost of a function body
 
 # saturating sum (inputs are nonnegative), prevents overflow with typemax(Int) below

base/compiler/ssair/inlining.jl

@@ -1047,9 +1047,12 @@ function early_inline_special_case(ir::IRCode, @nospecialize(f), @nospecialize(f
         if isa(etype, Const) # || isconstType(etype)
             val = etype.val
             is_inlineable_constant(val) || return nothing
-            if ispuretopfunction(f) ||
-                    (isa(f, IntrinsicFunction) ? is_pure_intrinsic_optim(f) :
-                    contains_is(_PURE_BUILTINS, f))
+            if isa(f, IntrinsicFunction)
+                if is_pure_intrinsic_infer(f) &&
+                    (intrinsic_nothrow(f) || intrinsic_nothrow(f, atypes[2:end]))
+                    return quoted(val)
+                end
+            elseif ispuretopfunction(f) || contains_is(_PURE_BUILTINS, f)
                 return quoted(val)
             elseif contains_is(_PURE_OR_ERROR_BUILTINS, f)
                 if _builtin_nothrow(f, atypes[2:end], etype)

base/compiler/ssair/queries.jl

@@ -22,6 +22,12 @@ function stmt_effect_free(@nospecialize(stmt), @nospecialize(rt), src, spvals::S
             f = singleton_type(f)
             f === nothing && return false
             is_return_type(f) && return true
+            if isa(f, IntrinsicFunction)
+                is_pure_intrinsic_infer(f) || return false
+                return intrinsic_nothrow(f) ||
+                    intrinsic_nothrow(f,
+                        Any[argextype(ea[i], src, spvals) for i = 2:length(ea)])
+            end
             contains_is(_PURE_BUILTINS, f) && return true
             contains_is(_PURE_OR_ERROR_BUILTINS, f) || return false
             rt === Bottom && return false

base/compiler/tfuncs.jl

@@ -1240,6 +1240,32 @@ function builtin_tfunction(@nospecialize(f), argtypes::Array{Any,1},
     return tf[3](argtypes...)
 end
 
+# Query whether the given intrinsic is nothrow
+intrinsic_nothrow(f::IntrinsicFunction) = !(
+        f === Intrinsics.checked_sdiv_int ||
+        f === Intrinsics.checked_udiv_int ||
+        f === Intrinsics.checked_srem_int ||
+        f === Intrinsics.checked_urem_int ||
+        f === Intrinsics.cglobal
+    )
+
+function intrinsic_nothrow(f::IntrinsicFunction, argtypes::Array{Any, 1})
+    # TODO: We could do better for cglobal
+    f === Intrinsics.cglobal && return false
+    if f === Intrinsics.checked_udiv_int || f === Intrinsics.checked_urem_int || f === Intrinsics.checked_srem_int || f === Intrinsics.checked_sdiv_int
+        # Nothrow as long as the second argument is guaranteed not to be zero
+        isa(argtypes[2], Const) || return false
+        den_val = argtypes[2].val
+        den_val !== zero(typeof(den_val)) || return false
+    end
+    if f === Intrinsics.checked_sdiv_int
+        # Nothrow as long as we additionally don't do typemin(T)/-1
+        return den_val !== -1 || (isa(argtypes[1], Const) &&
+            argtypes[1].val !== typemin(typeof(den_val)))
+    end
+    return true
+end
+
 # TODO: this function is a very buggy and poor model of the return_type function
 # since abstract_call_gf_by_type is a very inaccurate model of _method and of typeinf_type,
 # while this assumes that it is an absolutely precise and accurate and exact model of both

test/inline.jl

@@ -204,3 +204,16 @@ function f_apply_typevar(T)
     return T
 end
 @test length(code_typed(f_apply_typevar, (Type{Any},))[1][1].code) == 1
+
+# check that div can be fully eliminated
+function f_div(x)
+	div(x, 1)
+	return x
+end
+@test length(code_typed(f_div, (Int,))[1][1].code) == 1
+# ...unless we div by an unknown amount
+function f_div(x, y)
+    div(x, y)
+    return x
+end
+@test length(code_typed(f_div, (Int, Int))[1][1].code) > 1