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 float @unary_neg_mul(float %x, float %y) {
%0:
  %neg = fneg float %x
  %mul = fmul float %neg, %y
  ret float %mul
}
=>
define float @unary_neg_mul(float %x, float %y) {
%0:
  %neg = fneg float %x
  %mul = fmul float %neg, %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> @unary_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
}
=>
define <2 x float> @unary_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 float @unary_neg_mul_multi_use(float %x, float %y) {
%0:
  %sub1 = fneg float %x
  %mul = fmul float %sub1, %y
  %mul2 = fmul float %mul, %sub1
  ret float %mul2
}
=>
define float @unary_neg_mul_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: Timeout


----------------------------------------
define float @fabs_squared_fast(float %x) {
%0:
  %x.fabs = fabs float %x
  %mul = fmul fast float %x.fabs, %x.fabs
  ret float %mul
}
=>
define float @fabs_squared_fast(float %x) {
%0:
  %mul = fmul fast float %x, %x
  ret float %mul
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_fabs(float %x, float %y) {
%0:
  %x.fabs = fabs float %x
  %y.fabs = fabs float %y
  %mul = fmul float %x.fabs, %y.fabs
  ret float %mul
}
=>
define float @fabs_fabs(float %x, float %y) {
%0:
  %1 = fmul float %x, %y
  %mul = fabs float %1
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_fabs_extra_use1(float %x, float %y) {
%0:
  %x.fabs = fabs float %x
  call void @use_f32(float %x.fabs)
  %y.fabs = fabs float %y
  %mul = fmul ninf float %x.fabs, %y.fabs
  ret float %mul
}
=>
define float @fabs_fabs_extra_use1(float %x, float %y) {
%0:
  %x.fabs = fabs float %x
  call void @use_f32(float %x.fabs)
  %1 = fmul ninf float %x, %y
  %mul = fabs ninf float %1
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_fabs_extra_use2(float %x, float %y) {
%0:
  %x.fabs = fabs fast float %x
  %y.fabs = fabs fast float %y
  call void @use_f32(float %y.fabs)
  %mul = fmul ninf reassoc float %x.fabs, %y.fabs
  ret float %mul
}
=>
define float @fabs_fabs_extra_use2(float %x, float %y) {
%0:
  %y.fabs = fabs fast float %y
  call void @use_f32(float %y.fabs)
  %1 = fmul ninf reassoc float %x, %y
  %mul = fabs ninf reassoc float %1
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_fabs_extra_use3(float %x, float %y) {
%0:
  %x.fabs = fabs float %x
  call void @use_f32(float %x.fabs)
  %y.fabs = fabs float %y
  call void @use_f32(float %y.fabs)
  %mul = fmul float %x.fabs, %y.fabs
  ret float %mul
}
=>
define float @fabs_fabs_extra_use3(float %x, float %y) {
%0:
  %x.fabs = fabs float %x
  call void @use_f32(float %x.fabs)
  %y.fabs = fabs float %y
  call void @use_f32(float %y.fabs)
  %mul = fmul float %x.fabs, %y.fabs
  ret float %mul
}
Transformation seems to be correct!


----------------------------------------
define float @reassoc_common_operand1(float %x, float %y) {
%0:
  %mul1 = fmul float %x, %y
  %mul2 = fmul reassoc float %mul1, %x
  ret float %mul2
}
=>
define float @reassoc_common_operand1(float %x, float %y) {
%0:
  %1 = fmul reassoc float %x, %x
  %mul2 = fmul reassoc float %1, %y
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @reassoc_common_operand2(float %x, float %y) {
%0:
  %mul1 = fmul float %y, %x
  %mul2 = fmul fast float %mul1, %x
  ret float %mul2
}
=>
define float @reassoc_common_operand2(float %x, float %y) {
%0:
  %1 = fmul fast float %x, %x
  %mul2 = fmul fast float %1, %y
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @reassoc_common_operand3(float %x1, float %y) {
%0:
  %x = fdiv float %x1, 3.000000
  %mul1 = fmul float %x, %y
  %mul2 = fmul nnan reassoc float %x, %mul1
  ret float %mul2
}
=>
define float @reassoc_common_operand3(float %x1, float %y) {
%0:
  %x = fdiv float %x1, 3.000000
  %1 = fmul nnan reassoc float %x, %x
  %mul2 = fmul nnan reassoc float %1, %y
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @reassoc_common_operand4(float %x1, float %y) {
%0:
  %x = fdiv float %x1, 3.000000
  %mul1 = fmul float %y, %x
  %mul2 = fmul ninf reassoc float %x, %mul1
  ret float %mul2
}
=>
define float @reassoc_common_operand4(float %x1, float %y) {
%0:
  %x = fdiv float %x1, 3.000000
  %1 = fmul ninf reassoc float %x, %x
  %mul2 = fmul ninf reassoc float %1, %y
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @reassoc_common_operand_multi_use(float %x, float %y) {
%0:
  %mul1 = fmul float %x, %y
  %mul2 = fmul fast float %mul1, %x
  call void @use_f32(float %mul1)
  ret float %mul2
}
=>
define float @reassoc_common_operand_multi_use(float %x, float %y) {
%0:
  %mul1 = fmul float %x, %y
  %mul2 = fmul fast float %mul1, %x
  call void @use_f32(float %mul1)
  ret float %mul2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @log2half(float %x, float %y) {
%0:
  %halfy = fmul float %y, 0.500000
  %log2 = call float @llvm.log2.f32(float %halfy) noread nowrite nofree
  %mul = fmul fast float %log2, %x
  ret float %mul
}
=>
define float @log2half(float %x, float %y) {
%0:
  %1 = call float @llvm.log2.f32(float %y) noread nowrite NNaN nofree
  %2 = fmul fast float %1, %x
  %mul = fsub fast float %2, %x
  ret float %mul
}
Transformation doesn't verify!
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @llvm.log2.f32



----------------------------------------
define float @log2half_commute(float %x1, float %y) {
%0:
  %x = fdiv float %x1, 7.000000
  %halfy = fmul float %y, 0.500000
  %log2 = call float @llvm.log2.f32(float %halfy) noread nowrite nofree
  %mul = fmul fast float %x, %log2
  ret float %mul
}
=>
define float @log2half_commute(float %x1, float %y) {
%0:
  %1 = call float @llvm.log2.f32(float %y) noread nowrite NNaN nofree
  %2 = fmul fast float %1, %x1
  %3 = fsub fast float %2, %x1
  %mul = fmul fast float %3, 0.142857
  ret float %mul
}
Transformation doesn't verify!
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - Unknown libcall: @llvm.log2.f32



----------------------------------------
define float @fdiv_constant_numerator_fmul(float %x) {
%0:
  %t1 = fdiv float 2000.000000, %x
  %t3 = fmul reassoc float %t1, 6000.000000
  ret float %t3
}
=>
define float @fdiv_constant_numerator_fmul(float %x) {
%0:
  %t3 = fdiv reassoc float 12000000.000000, %x
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
@fmul2_external = global 4 bytes, align 4

define float @fdiv_constant_numerator_fmul_extra_use(float %x) {
%0:
  %div = fdiv fast float 1.000000, %x
  store float %div, * @fmul2_external, align 4
  %mul = fmul fast float %div, 2.000000
  ret float %mul
}
=>
@fmul2_external = global 4 bytes, align 4

define float @fdiv_constant_numerator_fmul_extra_use(float %x) {
%0:
  %div = fdiv fast float 1.000000, %x
  store float %div, * @fmul2_external, align 4
  %mul = fmul fast float %div, 2.000000
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_constant_denominator_fmul(float %x) {
%0:
  %t1 = fdiv float %x, 2000.000000
  %t3 = fmul reassoc float %t1, 6000.000000
  ret float %t3
}
=>
define float @fdiv_constant_denominator_fmul(float %x) {
%0:
  %t3 = fmul reassoc float %x, 3.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - reassoc



----------------------------------------
define <4 x float> @fdiv_constant_denominator_fmul_vec(<4 x float> %x) {
%0:
  %t1 = fdiv <4 x float> %x, { 2000.000000, 3000.000000, 2000.000000, 1000.000000 }
  %t3 = fmul reassoc <4 x float> %t1, { 6000.000000, 6000.000000, 2000.000000, 1000.000000 }
  ret <4 x float> %t3
}
=>
define <4 x float> @fdiv_constant_denominator_fmul_vec(<4 x float> %x) {
%0:
  %t3 = fmul reassoc <4 x float> %x, { 3.000000, 2.000000, 1.000000, 1.000000 }
  ret <4 x float> %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x float> @fdiv_constant_denominator_fmul_vec_constexpr(<4 x float> %x) {
%0:
  %__constexpr_1 = bitcast <5 x float> { 6000.000000, 6000.000000, 2000.000000, 1000.000000, undef } to i160
  %__constexpr_0 = trunc i160 %__constexpr_1 to i128
  %constExprMul = bitcast i128 %__constexpr_0 to <4 x float>
  %t1 = fdiv <4 x float> %x, { 2000.000000, 3000.000000, 2000.000000, 1000.000000 }
  %t3 = fmul reassoc <4 x float> %t1, %constExprMul
  ret <4 x float> %t3
}
=>
define <4 x float> @fdiv_constant_denominator_fmul_vec_constexpr(<4 x float> %x) {
%0:
  %t3 = fmul reassoc <4 x float> %x, { 3.000000, 2.000000, 1.000000, 1.000000 }
  ret <4 x float> %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_constant_reassociation(float %x) {
%0:
  %mul_flt_min = fmul nsz reassoc float %x, 0.000000
  %r = fmul nsz reassoc float %mul_flt_min, 0.500000
  ret float %r
}
=>
define float @fmul_constant_reassociation(float %x) {
%0:
  %r = fmul nsz reassoc float %x, 0.000000
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_constant_denominator_fmul_denorm(float %x) {
%0:
  %t1 = fdiv float %x, 2000.000000
  %t3 = fmul fast float %t1, 0.000000
  ret float %t3
}
=>
define float @fdiv_constant_denominator_fmul_denorm(float %x) {
%0:
  %t3 = fmul fast float %x, 0.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Couldn't prove the correctness of the transformation
Alive2 approximated the semantics of the programs and therefore we
cannot conclude whether the bug found is valid or not.

Approximations done:
 - afn
 - afn
 - arcp
 - arcp
 - contract
 - contract
 - reassoc
 - reassoc



----------------------------------------
define float @fdiv_constant_denominator_fmul_denorm_try_harder(float %x) {
%0:
  %t1 = fdiv float %x, 3.000000
  %t3 = fmul reassoc float %t1, 0.000000
  ret float %t3
}
=>
define float @fdiv_constant_denominator_fmul_denorm_try_harder(float %x) {
%0:
  %t3 = fdiv reassoc float %x, 255211775190703847597530955573826158592.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_constant_denominator_fmul_denorm_try_harder_extra_use(float %x) {
%0:
  %t1 = fdiv float %x, 3.000000
  %t3 = fmul fast float %t1, 0.000000
  %r = fadd float %t1, %t3
  ret float %r
}
=>
define float @fdiv_constant_denominator_fmul_denorm_try_harder_extra_use(float %x) {
%0:
  %t1 = fdiv float %x, 3.000000
  %t3 = fmul fast float %t1, 0.000000
  %r = fadd float %t1, %t3
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fadd_distribute(float %x) {
%0:
  %t2 = fadd float %x, 2.000000
  %t3 = fmul reassoc float %t2, 3.000000
  ret float %t3
}
=>
define float @fmul_fadd_distribute(float %x) {
%0:
  %1 = fmul reassoc float %x, 3.000000
  %t3 = fadd reassoc float %1, 6.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_distribute1(float %x) {
%0:
  %t2 = fsub float %x, 2.000000
  %t3 = fmul reassoc float %t2, 3.000000
  ret float %t3
}
=>
define float @fmul_fsub_distribute1(float %x) {
%0:
  %1 = fmul reassoc float %x, 3.000000
  %t3 = fadd reassoc float %1, -6.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_distribute2(float %x) {
%0:
  %t2 = fsub float 2.000000, %x
  %t3 = fmul reassoc float %t2, 3.000000
  ret float %t3
}
=>
define float @fmul_fsub_distribute2(float %x) {
%0:
  %1 = fmul reassoc float %x, 3.000000
  %t3 = fsub reassoc float 6.000000, %1
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fadd_fmul_distribute(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fadd float %t1, 2.000000
  %t3 = fmul fast float %t2, 5.000000
  ret float %t3
}
=>
define float @fmul_fadd_fmul_distribute(float %x) {
%0:
  %1 = fmul fast float %x, 30.000000
  %t3 = fadd fast float %1, 10.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fadd_distribute_extra_use(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fadd float %t1, 2.000000
  %t3 = fmul fast float %t2, 5.000000
  call void @use_f32(float %t2)
  ret float %t3
}
=>
define float @fmul_fadd_distribute_extra_use(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fadd float %t1, 2.000000
  %t3 = fmul fast float %t2, 5.000000
  call void @use_f32(float %t2)
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fadd_fdiv_distribute2(double %x) {
%0:
  %t1 = fdiv double %x, 3.000000
  %t2 = fadd double %t1, 5.000000
  %t3 = fmul reassoc double %t2, 0.000000
  ret double %t3
}
=>
define double @fmul_fadd_fdiv_distribute2(double %x) {
%0:
  %1 = fdiv reassoc double %x, 134826985114673693079697889309176855021348273420672992955072560868299506854125722349531357991805652015840085409903545018244092326610812466869635572979605593283325920068649113957226664700934570589589812214063754326628613011756847161105434832905620427872512883013439723679960434453859787228626517247218168102912.000000
  %t3 = fadd reassoc double %1, 0.000000
  ret double %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fadd_fdiv_distribute3(double %x) {
%0:
  %t1 = fdiv double %x, 3.000000
  %t2 = fadd double %t1, 5.000000
  %t3 = fmul reassoc double %t2, 0.000000
  ret double %t3
}
=>
define double @fmul_fadd_fdiv_distribute3(double %x) {
%0:
  %1 = fdiv reassoc double %x, 134826985114673693079697889309176855021348273420672992955072560868299506854125722349531357991805652015840085409903545018244092326610812466869635572979605593283325920068649113957226664700934570589589812214063754326628613011756847161105434832905620427872512883013439723679960434453859787228626517247218168102912.000000
  %t3 = fadd reassoc double %1, 0.000000
  ret double %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_fmul_distribute(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fsub float 2.000000, %t1
  %t3 = fmul fast float %t2, 5.000000
  ret float %t3
}
=>
define float @fmul_fsub_fmul_distribute(float %x) {
%0:
  %1 = fmul fast float %x, 30.000000
  %t3 = fsub fast float 10.000000, %1
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_fmul_distribute_extra_use(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fsub float 2.000000, %t1
  %t3 = fmul fast float %t2, 5.000000
  call void @use_f32(float %t2)
  ret float %t3
}
=>
define float @fmul_fsub_fmul_distribute_extra_use(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fsub float 2.000000, %t1
  %t3 = fmul fast float %t2, 5.000000
  call void @use_f32(float %t2)
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_fmul_distribute2(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fsub float %t1, 2.000000
  %t3 = fmul fast float %t2, 5.000000
  ret float %t3
}
=>
define float @fmul_fsub_fmul_distribute2(float %x) {
%0:
  %1 = fmul fast float %x, 30.000000
  %t3 = fadd fast float %1, -10.000000
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_fmul_distribute2_extra_use(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fsub float 2.000000, %t1
  %t3 = fmul fast float %t2, 5.000000
  call void @use_f32(float %t2)
  ret float %t3
}
=>
define float @fmul_fsub_fmul_distribute2_extra_use(float %x) {
%0:
  %t1 = fmul float %x, 6.000000
  %t2 = fsub float 2.000000, %t1
  %t3 = fmul fast float %t2, 5.000000
  call void @use_f32(float %t2)
  ret float %t3
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @common_factor(float %x, float %y) {
%0:
  %mul = fmul float %x, %y
  %mul1 = fmul fast float %mul, %x
  %add = fadd float %mul1, %mul
  ret float %add
}
=>
define float @common_factor(float %x, float %y) {
%0:
  %mul = fmul float %x, %y
  %mul1 = fmul fast float %mul, %x
  %add = fadd float %mul1, %mul
  ret float %add
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fdiv_factor_squared(double %x, double %y) {
%0:
  %div = fdiv fast double %x, %y
  %squared = fmul fast double %div, %div
  ret double %squared
}
=>
define double @fmul_fdiv_factor_squared(double %x, double %y) {
%0:
  %div = fdiv fast double %x, %y
  %squared = fmul fast double %div, %div
  ret double %squared
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fdivs_factor_common_denominator(double %x, double %y, double %z) {
%0:
  %div1 = fdiv double %x, %z
  %div2 = fdiv double %y, %z
  %mul = fmul fast double %div1, %div2
  ret double %mul
}
=>
define double @fmul_fdivs_factor_common_denominator(double %x, double %y, double %z) {
%0:
  %1 = fmul fast double %y, %x
  %2 = fmul fast double %z, %z
  %mul = fdiv fast double %1, %2
  ret double %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fdivs_factor(double %x, double %y, double %z, double %w) {
%0:
  %div1 = fdiv double %x, %y
  %div2 = fdiv double %z, %w
  %mul = fmul reassoc double %div1, %div2
  ret double %mul
}
=>
define double @fmul_fdivs_factor(double %x, double %y, double %z, double %w) {
%0:
  %1 = fmul reassoc double %z, %x
  %2 = fdiv reassoc double %1, %w
  %mul = fdiv reassoc double %2, %y
  ret double %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fdiv_factor(double %x, double %y, double %z) {
%0:
  %div = fdiv double %x, %y
  %mul = fmul reassoc double %div, %z
  ret double %mul
}
=>
define double @fmul_fdiv_factor(double %x, double %y, double %z) {
%0:
  %1 = fmul reassoc double %x, %z
  %mul = fdiv reassoc double %1, %y
  ret double %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define double @fmul_fdiv_factor_constant1(double %x, double %y) {
%0:
  %div = fdiv double %x, %y
  %mul = fmul reassoc double %div, 42.000000
  ret double %mul
}
=>
define double @fmul_fdiv_factor_constant1(double %x, double %y) {
%0:
  %1 = fmul reassoc double %x, 42.000000
  %mul = fdiv reassoc double %1, %y
  ret double %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @fmul_fdiv_factor_constant2(<2 x float> %x, <2 x float> %y) {
%0:
  %div = fdiv <2 x float> %x, { 42.000000, 12.000000 }
  %mul = fmul reassoc <2 x float> %div, %y
  ret <2 x float> %mul
}
=>
define <2 x float> @fmul_fdiv_factor_constant2(<2 x float> %x, <2 x float> %y) {
%0:
  %1 = fmul reassoc <2 x float> %x, %y
  %mul = fdiv reassoc <2 x float> %1, { 42.000000, 12.000000 }
  ret <2 x float> %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fdiv_factor_extra_use(float %x, float %y) {
%0:
  %div = fdiv float %x, 42.000000
  call void @use_f32(float %div)
  %mul = fmul reassoc float %div, %y
  ret float %mul
}
=>
define float @fmul_fdiv_factor_extra_use(float %x, float %y) {
%0:
  %div = fdiv float %x, 42.000000
  call void @use_f32(float %div)
  %mul = fmul reassoc float %div, %y
  ret float %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
@g = global 16 bytes, align 1

define double @fmul_negated_constant_expression(double %x) {
%0:
  %__constexpr_3 = gep inbounds * @g, 16 x i64 0, 1 x i64 0, 8 x i64 2
  %__constexpr_2 = ptrtoint * %__constexpr_3 to i64
  %__constexpr_1 = bitcast i64 %__constexpr_2 to double
  %__constexpr_0 = fsub double -0.000000, %__constexpr_1
  %r = fmul double %x, %__constexpr_0
  ret double %r
}
=>
@g = global 16 bytes, align 1

define double @fmul_negated_constant_expression(double %x) {
%0:
  %__constexpr_3 = gep inbounds * @g, 16 x i64 0, 1 x i64 0, 8 x i64 2
  %__constexpr_2 = ptrtoint * %__constexpr_3 to i64
  %__constexpr_1 = bitcast i64 %__constexpr_2 to double
  %__constexpr_0 = fsub double -0.000000, %__constexpr_1
  %r = fmul double %x, %__constexpr_0
  ret double %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @negate_if_true(float %x, i1 %cond) {
%0:
  %sel = select i1 %cond, float -1.000000, float 1.000000
  %r = fmul float %sel, %x
  ret float %r
}
=>
define float @negate_if_true(float %x, i1 %cond) {
%0:
  %1 = fneg float %x
  %2 = select i1 %cond, float %1, float %x
  ret float %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @negate_if_false(float %x, i1 %cond) {
%0:
  %sel = select i1 %cond, float 1.000000, float -1.000000
  %r = fmul arcp float %sel, %x
  ret float %r
}
=>
define float @negate_if_false(float %x, i1 %cond) {
%0:
  %1 = fneg arcp float %x
  %2 = select i1 %cond, float %x, float %1
  ret float %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x double> @negate_if_true_commute(<2 x double> %px, i1 %cond) {
%0:
  %x = fdiv <2 x double> { 42.000000, 42.000000 }, %px
  %sel = select i1 %cond, <2 x double> { -1.000000, -1.000000 }, <2 x double> { 1.000000, 1.000000 }
  %r = fmul ninf <2 x double> %x, %sel
  ret <2 x double> %r
}
=>
define <2 x double> @negate_if_true_commute(<2 x double> %px, i1 %cond) {
%0:
  %x = fdiv <2 x double> { 42.000000, 42.000000 }, %px
  %1 = fneg ninf <2 x double> %x
  %2 = select i1 %cond, <2 x double> %1, <2 x double> %x
  ret <2 x double> %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x double> @negate_if_false_commute(<2 x double> %px, <2 x i1> %cond) {
%0:
  %x = fdiv <2 x double> { 42.000000, 5.100000 }, %px
  %sel = select <2 x i1> %cond, <2 x double> { 1.000000, 1.000000 }, <2 x double> { -1.000000, -1.000000 }
  %r = fmul <2 x double> %x, %sel
  ret <2 x double> %r
}
=>
define <2 x double> @negate_if_false_commute(<2 x double> %px, <2 x i1> %cond) {
%0:
  %x = fdiv <2 x double> { 42.000000, 5.100000 }, %px
  %1 = fneg <2 x double> %x
  %2 = select <2 x i1> %cond, <2 x double> %x, <2 x double> %1
  ret <2 x double> %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @negate_if_true_extra_use(float %x, i1 %cond) {
%0:
  %sel = select i1 %cond, float -1.000000, float 1.000000
  call void @use_f32(float %sel)
  %r = fmul float %sel, %x
  ret float %r
}
=>
define float @negate_if_true_extra_use(float %x, i1 %cond) {
%0:
  %sel = select i1 %cond, float -1.000000, float 1.000000
  call void @use_f32(float %sel)
  %r = fmul float %sel, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x double> @negate_if_true_wrong_constant(<2 x double> %px, i1 %cond) {
%0:
  %x = fdiv <2 x double> { 42.000000, 42.000000 }, %px
  %sel = select i1 %cond, <2 x double> { -1.000000, 0.000000 }, <2 x double> { 1.000000, 1.000000 }
  %r = fmul <2 x double> %x, %sel
  ret <2 x double> %r
}
=>
define <2 x double> @negate_if_true_wrong_constant(<2 x double> %px, i1 %cond) {
%0:
  %x = fdiv <2 x double> { 42.000000, 42.000000 }, %px
  %sel = select i1 %cond, <2 x double> { -1.000000, 0.000000 }, <2 x double> { 1.000000, 1.000000 }
  %r = fmul <2 x double> %x, %sel
  ret <2 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_select(float %x, i1 %c) {
%0:
  %sel = select i1 %c, float 1.000000, float 0.000000
  %mul = fmul fast float %sel, %x
  ret float %mul
}
=>
define float @fmul_select(float %x, i1 %c) {
%0:
  %mul = select i1 %c, float %x, float 0.000000
  ret float %mul
}
Transformation doesn't verify!
ERROR: Target's return value is more undefined

Example:
float %x = #x80000000 (-0.0)
i1 %c = undef

Source:
float %sel = #x00000000 (+0.0)	[based on undef value]
float %mul = poison

Target:
float %mul = #x00000000 (+0.0)
Source value: poison
Target value: #x00000000 (+0.0)


------------------- SMT STATS -------------------
Num queries: 225
Num invalid: 0
Num skips:   0
Num trivial: 209 (48.2%)
Num timeout: 74 (32.9%)
Num errors:  0 (0.0%)
Num SAT:     91 (40.4%)
Num UNSAT:   60 (26.7%)

stderr:

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

Alive2: Transform doesn't verify; aborting!
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck --allow-unused-prefixes=false /home/nlopes/llvm/llvm/test/Transforms/InstCombine/fmul.ll

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

<-- Back