Expand intrinsic coverage

Author: Keno

src/analysis/ipoincidence.jl

@@ -100,11 +100,11 @@ function process_template!(𝕃, coeffs, eq_mapping, applied_scopes, argtypes, t
             if isa(arg, PartialStruct)
                 fields = arg.fields
             else
-                fields = Any[getfield_tfunc(𝕃, arg, Const(i)) for i = 1:length(template.fields)]
+                fields = Any[Compiler.getfield_tfunc(𝕃, arg, Const(i)) for i = 1:length(template.fields)]
             end
             process_template!(𝕃, coeffs, eq_mapping, applied_scopes, fields, template.fields)
         else
-            @show (arg, template)
+            @show (arg, template, template_argtypes)
             error()
         end
     end

src/analysis/lattice.jl

@@ -188,7 +188,7 @@ function Incidence(T::PartialStruct)
 end
 
 Base.:(==)(a::Incidence, b::Incidence) = a.typ === b.typ &&
-    a.row.nzind == b.row.nzind && a.row.nzval == b.row.nzval && a.eps == b.eps
+    a.row.nzind == b.row.nzind && a.row.nzval == b.row.nzval
 Base.:(+)(a::Incidence, b::Incidence) = tfunc(Val{Core.Intrinsics.add_float}(), a, b)
 Base.:(+)(a::Const, b::Incidence) = tfunc(Val{Core.Intrinsics.add_float}(), a, b)
 Base.:(+)(a::Incidence, b::Const) = tfunc(Val{Core.Intrinsics.add_float}(), a, b)
@@ -210,8 +210,8 @@ function epsnum(a::Incidence)
     return only(a.eps)
 end
 
-Base.copy(inc::Incidence) = Incidence(inc.typ, copy(inc.row), copy(inc.eps))
-Base.isempty(inc::Incidence) = iszero(inc.row) && isempty(inc.eps)  # slightly weaker than iszero as that also requires it to be Const(0.0)
+Base.copy(inc::Incidence) = Incidence(inc.typ, copy(inc.row))
+Base.isempty(inc::Incidence) = iszero(inc.row) # slightly weaker than iszero as that also requires it to be Const(0.0)
 
 #################################### Eq ########################################
 struct Eq

src/analysis/refiner.jl

@@ -124,12 +124,10 @@ function tfunc(::Val{Core.Intrinsics.neg_float}, @nospecialize(a::Union{Const, I
         for (i, v) in zip(rowvals(a.row), nonzeros(a.row))
             arow[i] = -v
         end
-        eps = copy(a.eps)
     else
         arow = _zero_row()
-        eps = BitSet()
     end
-    return Incidence(builtin_math_tfunc(Core.Intrinsics.neg_float, isa(a, Incidence) ? a.typ : a), arow, eps)
+    return Incidence(builtin_math_tfunc(Core.Intrinsics.neg_float, isa(a, Incidence) ? a.typ : a), arow)
 end
 
 get_eps(inc::Incidence) = inc.eps
@@ -220,6 +218,38 @@ function tfunc(::Val{Core.Intrinsics.div_float}, @nospecialize(a::Union{Const, T
     return Incidence(builtin_math_tfunc(Core.Intrinsics.div_float, isa(a, Incidence) ? a.typ : a, widenconst(b.typ)), rrow)
 end
 
+function tfunc(::Val{Core.Intrinsics.or_int}, @nospecialize(a::Union{Const, Type, Incidence}), @nospecialize(b::Union{Const, Type, Incidence}))
+    if isa(a, Const) && isa(b, Const)
+        return builtin_math_tfunc(Core.Intrinsics.or_int, a, b)
+    end
+    if !isa(a, Incidence) && !isa(b, Incidence)
+        return builtin_math_tfunc(Core.Intrinsics.or_int, a, b)
+    end
+    rrow = _zero_row()
+    arow = isa(a, Incidence) ? a.row : _ZERO_ROW
+    brow = isa(b, Incidence) ? b.row : _ZERO_ROW
+    for i in Iterators.flatten((rowvals(arow), rowvals(brow)))
+        rrow[i] = nonlinear
+    end
+    return Incidence(builtin_math_tfunc(Core.Intrinsics.or_int, widenconst(a), widenconst(b)), rrow)
+end
+
+function tfunc(::Val{Core.Intrinsics.and_int}, @nospecialize(a::Union{Const, Type, Incidence}), @nospecialize(b::Union{Const, Type, Incidence}))
+    if isa(a, Const) && isa(b, Const)
+        return builtin_math_tfunc(Core.Intrinsics.and_int, a, b)
+    end
+    if !isa(a, Incidence) && !isa(b, Incidence)
+        return builtin_math_tfunc(Core.Intrinsics.and_int, a, b)
+    end
+    rrow = _zero_row()
+    arow = isa(a, Incidence) ? a.row : _ZERO_ROW
+    brow = isa(b, Incidence) ? b.row : _ZERO_ROW
+    for i in Iterators.flatten((rowvals(arow), rowvals(brow)))
+        rrow[i] = nonlinear
+    end
+    return Incidence(builtin_math_tfunc(Core.Intrinsics.and_int, widenconst(a), widenconst(b)), rrow)
+end
+
 function builtin_math_tfunc(@nospecialize(f), @nospecialize(a), @nospecialize(b), @nospecialize(c))
     if isa(a, Const) && isa(b, Const) && isa(c, Const)
         return Const(f(a.val::Float64, b.val::Float64, c.val::Float64))
@@ -277,7 +307,14 @@ is_any_incidence(@nospecialize args...) = any(@nospecialize(x)->isa(x, Incidence
                 (f == Core.Intrinsics.mul_float || f == Core.Intrinsics.div_float) ||
                 f == Core.Intrinsics.copysign_float
                 return tfunc(Val(f), a, b)
-            elseif f == Core.Intrinsics.lt_float
+            elseif f == Core.Intrinsics.or_int
+                return tfunc(Val(f), a, b)
+            elseif f == Core.Intrinsics.and_int
+                return tfunc(Val(f), a, b)
+            elseif f == Core.Intrinsics.fptosi || f == Core.Intrinsics.sitofp
+                # We keep the linearity structure here and absorb the rounding error into be base Int64
+                return Incidence(Compiler.conversion_tfunc(Compiler.typeinf_lattice(interp), widenconst(a), widenconst(b)), b.row)
+            elseif f == Core.Intrinsics.lt_float || f == Core.Intrinsics.eq_float || f == Core.Intrinsics.slt_int
                 r = Compiler.tmerge(Compiler.typeinf_lattice(interp), argtypes[1], argtypes[2])
                 @assert isa(r, Incidence)
                 return Incidence(Bool, r.row)

src/analysis/structural.jl

@@ -298,8 +298,8 @@ function _structural_analysis!(ci::CodeInstance, world::UInt)
                 return result
             end
 
-            argtypes = Compiler.collect_argtypes(refiner, stmt.args, Compiler.StatementState(nothing, false), irsv)[2:end]
-            mapping = CalleeMapping(Compiler.optimizer_lattice(refiner), argtypes, result)
+            callee_argtypes = Compiler.collect_argtypes(refiner, stmt.args, Compiler.StatementState(nothing, false), irsv)[2:end]
+            mapping = CalleeMapping(Compiler.optimizer_lattice(refiner), callee_argtypes, result)
             inst[:info] = MappingInfo(info, result, mapping)
         end
 

src/transform/tearing/schedule.jl

@@ -170,7 +170,8 @@ function schedule_nonlinear!(compact, param_vars, var_eq_matching, ir, val::Unio
         f = f.val
         @assert f in (Core.Intrinsics.sub_float, Core.Intrinsics.add_float,
                       Core.Intrinsics.mul_float, Core.Intrinsics.copysign_float,
-                      Core.ifelse)
+                      Core.ifelse, Core.Intrinsics.or_int, Core.Intrinsics.and_int)
+        # TODO: or_int is linear in Bool
         call_is_linear = f in (Core.Intrinsics.sub_float, Core.Intrinsics.add_float)
     end
 

test/regression.jl

@@ -10,6 +10,7 @@ using OrdinaryDiffEq
 const cf = Base.copysign_float
 const ief = Core.ifelse
 const -ᵢ = Core.Intrinsics.sub_float
+const oif = Core.Intrinsics.or_int
 
 function tfb1()
     x = continuous()
@@ -21,4 +22,31 @@ end
 sol = solve(DAECProblem(tfb1, (1,) .=> 1.), IDA())
 @test all(map((x,y)->isapprox(x[], y, atol=1e-2), sol.u[:, 1], exp.(sol.t)))
 
+function tfb1_ipo()
+    x = continuous()
+    always!(ddt(x) - (x < 43200.)*x)
+end
+
+sol = solve(DAECProblem(tfb1_ipo, (1,) .=> 1.), IDA())
+@test all(map((x,y)->isapprox(x[], y, atol=1e-2), sol.u[:, 1], exp.(sol.t)))
+
+function tfb2()
+    x = continuous()
+
+    fx = Float64(-100)
+    b = oif(fx < x,
+        ((fx == x) & oif((fx == Float64(typemax(Int64))), (-100 < unsafe_trunc(Int64,fx)) )))
+
+    always!(ddt(x) - b*x)
+end
+sol = solve(DAECProblem(tfb2, (1,) .=> 1.), IDA())
+@test all(map((x,y)->isapprox(x[], y, atol=1e-2), sol.u[:, 1], exp.(sol.t)))
+
+function tfb2_ipo()
+    x = continuous()
+    always!(ddt(x) - (-100 < x)*x)
+end
+sol = solve(DAECProblem(tfb2_ipo, (1,) .=> 1.), IDA())
+@test all(map((x,y)->isapprox(x[], y, atol=1e-2), sol.u[:, 1], exp.(sol.t)))
+
 end