inference: fix #41450, replace constant-folded muladd with fma

So that we can get more accurate results when performance doesn't matter

base/compiler/compiler.jl

@@ -111,6 +111,9 @@ using .Sort
 something(x::Nothing, y...) = something(y...)
 something(x::Any, y...) = x
 
+const ARCH = ccall(:jl_get_ARCH, Any, ())
+include("build_h.jl")
+
 ############
 # compiler #
 ############
@@ -142,4 +145,3 @@ Core.eval(Core, :(_parse = Compiler.fl_parse))
 
 end # baremodule Compiler
 ))
-

base/compiler/tfuncs.jl

@@ -1514,6 +1514,24 @@ function builtin_nothrow(@nospecialize(f), argtypes::Array{Any, 1}, @nospecializ
     return _builtin_nothrow(f, argtypes, rt)
 end
 
+# NOTE sync the definitions below with those defined in floatfuncs.jl
+fma_libm(x::Float32, y::Float32, z::Float32) =
+    ccall(("fmaf", libm_name), Float32, (Float32,Float32,Float32), x, y, z)
+fma_libm(x::Float64, y::Float64, z::Float64) =
+    ccall(("fma", libm_name), Float64, (Float64,Float64,Float64), x, y, z)
+fma_llvm(x::Float32, y::Float32, z::Float32) = fma_float(x, y, z)
+fma_llvm(x::Float64, y::Float64, z::Float64) = fma_float(x, y, z)
+if ARCH !== :i686 &&
+   fma_llvm(1.0000305f0, 1.0000305f0, -1.0f0) == 6.103609f-5 &&
+   fma_llvm(1.0000000009313226, 1.0000000009313226, -1.0) == 1.8626451500983188e-9 &&
+   add_float(0.1, 0.2) == 0.30000000000000004
+    fma(x::Float32, y::Float32, z::Float32) = fma_llvm(x,y,z)
+    fma(x::Float64, y::Float64, z::Float64) = fma_llvm(x,y,z)
+else
+    fma(x::Float32, y::Float32, z::Float32) = fma_libm(x,y,z)
+    fma(x::Float64, y::Float64, z::Float64) = fma_libm(x,y,z)
+end
+
 function builtin_tfunction(interp::AbstractInterpreter, @nospecialize(f), argtypes::Array{Any,1},
                            sv::Union{InferenceState,Nothing})
     if f === tuple
@@ -1522,6 +1540,15 @@ function builtin_tfunction(interp::AbstractInterpreter, @nospecialize(f), argtyp
     if isa(f, IntrinsicFunction)
         if is_pure_intrinsic_infer(f) && _all(@nospecialize(a) -> isa(a, Const), argtypes)
             argvals = anymap(a::Const -> a.val, argtypes)
+            # https://github.com/JuliaLang/julia/issues/41450
+            # enforce no rounding for better accuracy
+            if f === muladd_float && length(argvals) == 3
+                if _all(@nospecialize(a) -> isa(a, Float32), argvals)
+                    return Const(fma(argvals[1]::Float32, argvals[2]::Float32, argvals[3]::Float32))
+                elseif _all(@nospecialize(a) -> isa(a, Float64), argvals)
+                    return Const(fma(argvals[1]::Float64, argvals[2]::Float64, argvals[3]::Float64))
+                end
+            end
             try
                 return Const(f(argvals...))
             catch

base/floatfuncs.jl

@@ -340,9 +340,11 @@ fma_llvm(x::Float64, y::Float64, z::Float64) = fma_float(x, y, z)
 # 1.0000000009313226 = 1 + 1/2^30
 # If fma_llvm() clobbers the rounding mode, the result of 0.1 + 0.2 will be 0.3
 # instead of the properly-rounded 0.30000000000000004; check after calling fma
-if (Sys.ARCH !== :i686 && fma_llvm(1.0000305f0, 1.0000305f0, -1.0f0) == 6.103609f-5 &&
-    (fma_llvm(1.0000000009313226, 1.0000000009313226, -1.0) ==
-     1.8626451500983188e-9) && 0.1 + 0.2 == 0.30000000000000004)
+# NOTE this system level check is also used in compiler/tfuncs.jl, make sure to sync them
+if Sys.ARCH !== :i686 &&
+   fma_llvm(1.0000305f0, 1.0000305f0, -1.0f0) == 6.103609f-5 &&
+   fma_llvm(1.0000000009313226, 1.0000000009313226, -1.0) == 1.8626451500983188e-9 &&
+   0.1 + 0.2 == 0.30000000000000004
     fma(x::Float32, y::Float32, z::Float32) = fma_llvm(x,y,z)
     fma(x::Float64, y::Float64, z::Float64) = fma_llvm(x,y,z)
 else

test/compiler/inference.jl

@@ -3395,3 +3395,9 @@ end
         x.x
     end) == Any[Int]
 end
+
+# https://github.com/JuliaLang/julia/issues/41450
+@test (@eval Module() begin
+    foo(x=1.0) = muladd(1 + eps(x), 1 - eps(x), -1)
+    foo() == foo(1.0)
+end)

test/mpfr.jl

@@ -606,8 +606,7 @@ end
         @test log(x) == log(42)
         @test isinf(log(BigFloat(0)))
         @test_throws DomainError log(BigFloat(-1))
-        # issue #41450
-        @test_skip log2(x) == log2(42)
+        @test log2(x) == log2(42)
         @test isinf(log2(BigFloat(0)))
         @test_throws DomainError log2(BigFloat(-1))
         @test log10(x) == log10(42)