Test Failure: Transforms/InstCombine/fmul.ll

Test source: git

Log:

Source: <stdin>
ERROR: Unsupported type: <vscale x 2 x float>

----------------------------------------
define float @neg_constant(float %x) {
%0:
  %sub = fsub float -0.000000, %x
  %mul = fmul ninf float %sub, 20.000000
  ret float %mul
}
=>
define float @neg_constant(float %x) {
%0:
  %mul = fmul ninf float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_constant(float %x) {
%0:
  %sub = fneg float %x
  %mul = fmul ninf float %sub, 20.000000
  ret float %mul
}
=>
define float @unary_neg_constant(float %x) {
%0:
  %mul = fmul ninf float %x, -20.000000
  ret float %mul
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @neg_constant_vec(<2 x float> %x) {
%0:
  %sub = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_constant_vec(<2 x float> %x) {
%0:
  %mul = fmul ninf <2 x float> %x, { -2.000000, -3.000000 }
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @unary_neg_constant_vec(<2 x float> %x) {
%0:
  %sub = fneg <2 x float> %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_constant_vec(<2 x float> %x) {
%0:
  %mul = fmul ninf <2 x float> %x, { -2.000000, -3.000000 }
  ret <2 x float> %mul
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @neg_constant_vec_undef(<2 x float> %x) {
%0:
  %sub = fsub <2 x float> { undef, -0.000000 }, %x
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_constant_vec_undef(<2 x float> %x) {
%0:
  %mul = fmul ninf <2 x float> %x, { -2.000000, -3.000000 }
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_nsz_constant(float %x) {
%0:
  %sub = fsub nsz float 0.000000, %x
  %mul = fmul nnan float %sub, 20.000000
  ret float %mul
}
=>
define float @neg_nsz_constant(float %x) {
%0:
  %mul = fmul nnan float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_nsz_constant(float %x) {
%0:
  %sub = fneg nsz float %x
  %mul = fmul nnan float %sub, 20.000000
  ret float %mul
}
=>
define float @unary_neg_nsz_constant(float %x) {
%0:
  %mul = fmul nnan float %x, -20.000000
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_neg(float %x, float %y) {
%0:
  %sub1 = fsub float -0.000000, %x
  %sub2 = fsub float -0.000000, %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @neg_neg(float %x, float %y) {
%0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_unary_neg(float %x, float %y) {
%0:
  %sub1 = fneg float %x
  %sub2 = fneg float %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @unary_neg_unary_neg(float %x, float %y) {
%0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_neg(float %x, float %y) {
%0:
  %sub1 = fneg float %x
  %sub2 = fsub float -0.000000, %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @unary_neg_neg(float %x, float %y) {
%0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_unary_neg(float %x, float %y) {
%0:
  %sub1 = fsub float -0.000000, %x
  %sub2 = fneg float %y
  %mul = fmul arcp float %sub1, %sub2
  ret float %mul
}
=>
define float @neg_unary_neg(float %x, float %y) {
%0:
  %mul = fmul arcp float %x, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @neg_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub1 = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @unary_neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub1 = fneg <2 x float> %x
  %sub2 = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @unary_neg_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub1 = fneg <2 x float> %x
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub1 = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %sub2 = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_unary_neg_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @neg_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %sub1 = fsub <2 x float> { -0.000000, undef }, %x
  %sub2 = fsub <2 x float> { undef, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %sub1, %sub2
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @unary_neg_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %neg = fneg <2 x float> %x
  %sub = fsub <2 x float> { undef, -0.000000 }, %y
  %mul = fmul arcp <2 x float> %neg, %sub
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @neg_unary_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fsub <2 x float> { -0.000000, undef }, %x
  %neg = fneg <2 x float> %y
  %mul = fmul arcp <2 x float> %sub, %neg
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_unary_neg_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %mul = fmul arcp <2 x float> %x, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_neg_nsz(float %x, float %y) {
%0:
  %sub1 = fsub nsz float 0.000000, %x
  %sub2 = fsub nsz float 0.000000, %y
  %mul = fmul afn float %sub1, %sub2
  ret float %mul
}
=>
define float @neg_neg_nsz(float %x, float %y) {
%0:
  %mul = fmul afn float %x, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_neg_multi_use(float %x, float %y) {
%0:
  %nx = fsub float -0.000000, %x
  %ny = fsub float -0.000000, %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
define float @neg_neg_multi_use(float %x, float %y) {
%0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_unary_neg_multi_use(float %x, float %y) {
%0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
define float @unary_neg_unary_neg_multi_use(float %x, float %y) {
%0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_neg_multi_use(float %x, float %y) {
%0:
  %nx = fneg float %x
  %ny = fsub float -0.000000, %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
define float @unary_neg_neg_multi_use(float %x, float %y) {
%0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_unary_neg_multi_use(float %x, float %y) {
%0:
  %nx = fsub float -0.000000, %x
  %ny = fneg float %y
  %mul = fmul afn float %nx, %ny
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
=>
define float @neg_unary_neg_multi_use(float %x, float %y) {
%0:
  %nx = fneg float %x
  %ny = fneg float %y
  %mul = fmul afn float %x, %y
  call void @use_f32(float %nx)
  call void @use_f32(float %ny)
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_mul(float %x, float %y) {
%0:
  %sub = fsub float -0.000000, %x
  %mul = fmul float %sub, %y
  ret float %mul
}
=>
define float @neg_mul(float %x, float %y) {
%0:
  %sub = fneg float %x
  %mul = fmul float %sub, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @neg_mul_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fsub <2 x float> { -0.000000, -0.000000 }, %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_mul_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @neg_mul_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fsub <2 x float> { undef, -0.000000 }, %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
=>
define <2 x float> @neg_mul_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fneg <2 x float> %x
  %mul = fmul <2 x float> %sub, %y
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_sink_nsz(float %x, float %y) {
%0:
  %sub1 = fsub nsz float 0.000000, %x
  %mul = fmul float %sub1, %y
  ret float %mul
}
=>
define float @neg_sink_nsz(float %x, float %y) {
%0:
  %sub1 = fneg nsz float %x
  %mul = fmul float %sub1, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @neg_sink_multi_use(float %x, float %y) {
%0:
  %sub1 = fsub float -0.000000, %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
=>
define float @neg_sink_multi_use(float %x, float %y) {
%0:
  %sub1 = fneg float %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @test8(* %inout) {
%entry:
  %0 = load i32, * %inout, align 4
  %conv = uitofp i32 %0 to float
  %vecinit = insertelement <4 x float> { 0.000000, 0.000000, 0.000000, undef }, float %conv, i32 3
  %sub = fsub <4 x float> { -0.000000, -0.000000, -0.000000, -0.000000 }, %vecinit
  %1 = shufflevector <4 x float> %sub, <4 x float> undef, 1, 1, 1, 1
  %mul = fmul <4 x float> { 0.000000, 0.000000, 0.000000, 0.000000 }, %1
  br label %for.cond

%for.cond:
  %local_var_7.0 = phi <4 x float> [ %mul, %entry ], [ %2, %for.body ]
  br i1 undef, label %for.body, label %for.end

%for.body:
  %2 = insertelement <4 x float> %local_var_7.0, float 0.000000, i32 2
  br label %for.cond

%for.end:
  ret void
}
=>
define void @test8(* %inout) {
%entry:
  br label %for.cond

%for.cond:
  %local_var_7.0 = phi <4 x float> [ { -0.000000, -0.000000, -0.000000, -0.000000 }, %entry ], [ %0, %for.body ]
  br i1 undef, label %for.body, label %for.end

%for.body:
  %0 = insertelement <4 x float> %local_var_7.0, float 0.000000, i32 2
  br label %for.cond

%for.end:
  ret void
}
Transformation seems to be correct!


----------------------------------------
define float @test9(float %x) {
%0:
  %mul = fmul float %x, -1.000000
  ret float %mul
}
=>
define float @test9(float %x) {
%0:
  %mul = fneg float %x
  ret float %mul
}
Transformation seems to be correct!


----------------------------------------
define <4 x float> @test10(<4 x float> %x) {
%0:
  %mul = fmul arcp afn <4 x float> %x, { -1.000000, -1.000000, -1.000000, -1.000000 }
  ret <4 x float> %mul
}
=>
define <4 x float> @test10(<4 x float> %x) {
%0:
  %mul = fneg arcp afn <4 x float> %x
  ret <4 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @test11(float %x, float %y) {
%0:
  %a = fadd fast float %x, 1.000000
  %b = fadd fast float %y, 2.000000
  %c = fadd fast float %a, %b
  ret float %c
}
=>
define float @test11(float %x, float %y) {
%0:
  %b = fadd fast float %x, %y
  %c = fadd fast float %b, 3.000000
  ret float %c
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @sqrt_squared2(double %f) {
%0:
  %sqrt = sqrt double %f
  %mul1 = fmul fast double %sqrt, %sqrt
  %mul2 = fmul double %mul1, %sqrt
  ret double %mul2
}
=>
define double @sqrt_squared2(double %f) {
%0:
  %sqrt = sqrt double %f
  %mul2 = fmul double %sqrt, %f
  ret double %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_squared(float %x) {
%0:
  %x.fabs = fabs float %x
  %mul = fmul float %x.fabs, %x.fabs
  ret float %mul
}
=>
define float @fabs_squared(float %x) {
%0:
  %mul = fmul float %x, %x
  ret float %mul
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
float %x = undef

Source:
float %x.fabs = NaN	[based on undef value]
float %mul = NaN	[based on undef value]

Target:
float %mul = #xa1a040a5 (-0.000000000000?)
Source value: NaN
Target value: #xa1a040a5 (-0.000000000000?)


------------------- SMT STATS -------------------
Num queries: 88
Num invalid: 0
Num skips:   0
Num trivial: 101 (53.4%)
Num timeout: 29 (33.0%)
Num errors:  0 (0.0%)
Num SAT:     37 (42.0%)
Num UNSAT:   22 (25.0%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -S -instcombine
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll

NOTE: This test would pass if undef didn't exist!

<-- Back