Test source: git
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 = #x80000000 (-0.0) Source value: NaN Target value: #x80000000 (-0.0) ------------------- 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: 103 (65.2%) Num UNSAT: 27 (17.1%) Alive2: Transform doesn't verify; aborting!
+ : 'RUN: at line 2' + /home/nlopes/alive2/build/opt-alive.sh -S -passes=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!