Test Failure: Transforms/InstCombine/fmul.ll

Test source: git

Log:

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

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


----------------------------------------
define float @unary_neg_constant(float %x) {
%0:
  %sub = fneg float %x, exceptions=ignore
  %mul = fmul ninf float %sub, 20.000000, exceptions=ignore
  ret float %mul
}
=>
define float @unary_neg_constant(float %x) {
%0:
  %mul = fmul ninf float %x, -20.000000, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }, exceptions=ignore
  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 }, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }, exceptions=ignore
  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 }, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul ninf <2 x float> %sub, { 2.000000, 3.000000 }, exceptions=ignore
  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 }, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul nnan float %sub, 20.000000, exceptions=ignore
  ret float %mul
}
=>
define float @neg_nsz_constant(float %x) {
%0:
  %mul = fmul nnan float %x, -20.000000, exceptions=ignore
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_nsz_constant(float %x) {
%0:
  %sub = fneg nsz float %x, exceptions=ignore
  %mul = fmul nnan float %sub, 20.000000, exceptions=ignore
  ret float %mul
}
=>
define float @unary_neg_nsz_constant(float %x) {
%0:
  %mul = fmul nnan float %x, -20.000000, exceptions=ignore
  ret float %mul
}
Transformation seems to be correct!


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


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


----------------------------------------
define float @unary_neg_neg(float %x, float %y) {
%0:
  %sub1 = fneg float %x, exceptions=ignore
  %sub2 = fsub float -0.000000, %y, exceptions=ignore
  %mul = fmul arcp float %sub1, %sub2, exceptions=ignore
  ret float %mul
}
=>
define float @unary_neg_neg(float %x, float %y) {
%0:
  %mul = fmul arcp float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fneg float %y, exceptions=ignore
  %mul = fmul arcp float %sub1, %sub2, exceptions=ignore
  ret float %mul
}
=>
define float @neg_unary_neg(float %x, float %y) {
%0:
  %mul = fmul arcp float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %sub1, %sub2, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fneg <2 x float> %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %sub1, %sub2, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fsub <2 x float> { -0.000000, -0.000000 }, %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %sub1, %sub2, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fneg <2 x float> %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %sub1, %sub2, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fsub <2 x float> { undef, -0.000000 }, %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %sub1, %sub2, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %sub = fsub <2 x float> { undef, -0.000000 }, %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %neg, %sub, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %neg = fneg <2 x float> %y, exceptions=ignore
  %mul = fmul arcp <2 x float> %sub, %neg, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %sub2 = fsub nsz float 0.000000, %y, exceptions=ignore
  %mul = fmul afn float %sub1, %sub2, exceptions=ignore
  ret float %mul
}
=>
define float @neg_neg_nsz(float %x, float %y) {
%0:
  %mul = fmul afn float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %ny = fsub float -0.000000, %y, exceptions=ignore
  %mul = fmul afn float %nx, %ny, exceptions=ignore
  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, exceptions=ignore
  %ny = fneg float %y, exceptions=ignore
  %mul = fmul afn float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %ny = fneg float %y, exceptions=ignore
  %mul = fmul afn float %nx, %ny, exceptions=ignore
  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, exceptions=ignore
  %ny = fneg float %y, exceptions=ignore
  %mul = fmul afn float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %ny = fsub float -0.000000, %y, exceptions=ignore
  %mul = fmul afn float %nx, %ny, exceptions=ignore
  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, exceptions=ignore
  %ny = fneg float %y, exceptions=ignore
  %mul = fmul afn float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %ny = fneg float %y, exceptions=ignore
  %mul = fmul afn float %nx, %ny, exceptions=ignore
  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, exceptions=ignore
  %ny = fneg float %y, exceptions=ignore
  %mul = fmul afn float %x, %y, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul float %sub, %y, exceptions=ignore
  ret float %mul
}
=>
define float @neg_mul(float %x, float %y) {
%0:
  %sub = fneg float %x, exceptions=ignore
  %mul = fmul float %sub, %y, exceptions=ignore
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_mul(float %x, float %y) {
%0:
  %neg = fneg float %x, exceptions=ignore
  %mul = fmul float %neg, %y, exceptions=ignore
  ret float %mul
}
=>
define float @unary_neg_mul(float %x, float %y) {
%0:
  %neg = fneg float %x, exceptions=ignore
  %mul = fmul float %neg, %y, exceptions=ignore
  ret float %mul
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
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, exceptions=ignore
  %mul = fmul <2 x float> %sub, %y, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul <2 x float> %sub, %y, exceptions=ignore
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @unary_neg_mul_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fneg <2 x float> %x, exceptions=ignore
  %mul = fmul <2 x float> %sub, %y, exceptions=ignore
  ret <2 x float> %mul
}
=>
define <2 x float> @unary_neg_mul_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %sub = fneg <2 x float> %x, exceptions=ignore
  %mul = fmul <2 x float> %sub, %y, exceptions=ignore
  ret <2 x float> %mul
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
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, exceptions=ignore
  %mul = fmul <2 x float> %sub, %y, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul <2 x float> %sub, %y, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul float %sub1, %y, exceptions=ignore
  ret float %mul
}
=>
define float @neg_sink_nsz(float %x, float %y) {
%0:
  %sub1 = fneg nsz float %x, exceptions=ignore
  %mul = fmul float %sub1, %y, exceptions=ignore
  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, exceptions=ignore
  %mul = fmul float %sub1, %y, exceptions=ignore
  %mul2 = fmul float %mul, %sub1, exceptions=ignore
  ret float %mul2
}
=>
define float @neg_sink_multi_use(float %x, float %y) {
%0:
  %sub1 = fneg float %x, exceptions=ignore
  %mul = fmul float %sub1, %y, exceptions=ignore
  %mul2 = fmul float %mul, %sub1, exceptions=ignore
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @unary_neg_mul_multi_use(float %x, float %y) {
%0:
  %sub1 = fneg float %x, exceptions=ignore
  %mul = fmul float %sub1, %y, exceptions=ignore
  %mul2 = fmul float %mul, %sub1, exceptions=ignore
  ret float %mul2
}
=>
define float @unary_neg_mul_multi_use(float %x, float %y) {
%0:
  %sub1 = fneg float %x, exceptions=ignore
  %mul = fmul float %sub1, %y, exceptions=ignore
  %mul2 = fmul float %mul, %sub1, exceptions=ignore
  ret float %mul2
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @test8(ptr %inout) {
%entry:
  %0 = load i32, ptr %inout, align 4
  %conv = uitofp i32 %0 to float, exceptions=ignore
  %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, exceptions=ignore
  %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, exceptions=ignore
  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(ptr %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, i64 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, exceptions=ignore
  ret float %mul
}
=>
define float @test9(float %x) {
%0:
  %mul = fneg float %x, exceptions=ignore
  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 }, exceptions=ignore
  ret <4 x float> %mul
}
=>
define <4 x float> @test10(<4 x float> %x) {
%0:
  %mul = fneg arcp afn <4 x float> %x, exceptions=ignore
  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, exceptions=ignore
  %b = fadd fast float %y, 2.000000, exceptions=ignore
  %c = fadd fast float %a, %b, exceptions=ignore
  ret float %c
}
=>
define float @test11(float %x, float %y) {
%0:
  %b = fadd fast float %x, %y, exceptions=ignore
  %c = fadd fast float %b, 3.000000, exceptions=ignore
  ret float %c
}
Transformation doesn't verify!
ERROR: Timeout


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


----------------------------------------
define float @fabs_squared(float %x) {
%0:
  %x.fabs = fabs float %x, exceptions=ignore
  %mul = fmul float %x.fabs, %x.fabs, exceptions=ignore
  ret float %mul
}
=>
define float @fabs_squared(float %x) {
%0:
  %mul = fmul float %x, %x, exceptions=ignore
  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 = #xc030fccc (-2.765429496765?)
Source value: NaN
Target value: #xc030fccc (-2.765429496765?)


------------------- SMT STATS -------------------
Num queries: 158
Num invalid: 0
Num skips:   0
Num trivial: 97 (38.0%)
Num timeout: 28 (17.7%)
Num errors:  0 (0.0%)
Num SAT:     105 (66.5%)
Num UNSAT:   25 (15.8%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

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

 

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

 

<-- Back