Test Failure: Transforms/InstCombine/fcmp.ll

Test source: git

Comments: LLVM PR45152

Log:

Source: <stdin>
ERROR: Unsupported type: ppc_fp128
ERROR: Unsupported instruction:   %ext = fpext float %x to ppc_fp128
ERROR: Unsupported instruction:   %call = tail call double %p(double %a)

----------------------------------------
define i1 @fpext_fpext(float %x, float %y) {
%0:
  %ext1 = fpext float %x to double, exceptions=ignore
  %ext2 = fpext float %y to double, exceptions=ignore
  %cmp = fcmp nnan ogt double %ext1, %ext2
  ret i1 %cmp
}
=>
define i1 @fpext_fpext(float %x, float %y) {
%0:
  %cmp = fcmp nnan ogt float %x, %y
  ret i1 %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @fpext_constant(float %a) {
%0:
  %ext = fpext float %a to double, exceptions=ignore
  %cmp = fcmp ninf ogt double %ext, 1.000000
  ret i1 %cmp
}
=>
define i1 @fpext_constant(float %a) {
%0:
  %cmp = fcmp ninf ogt float %a, 1.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fpext_constant_vec_splat(<2 x half> %a) {
%0:
  %ext = fpext <2 x half> %a to <2 x double>, exceptions=ignore
  %cmp = fcmp nnan ole <2 x double> %ext, { 42.000000, 42.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fpext_constant_vec_splat(<2 x half> %a) {
%0:
  %cmp = fcmp nnan ole <2 x half> %a, { 20800, 20800 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fpext_constant_lossy(float %a) {
%0:
  %ext = fpext float %a to double, exceptions=ignore
  %cmp = fcmp ogt double %ext, 1.000000
  ret i1 %cmp
}
=>
define i1 @fpext_constant_lossy(float %a) {
%0:
  %ext = fpext float %a to double, exceptions=ignore
  %cmp = fcmp ogt double %ext, 1.000000
  ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @fpext_constant_denorm(float %a) {
%0:
  %ext = fpext float %a to double, exceptions=ignore
  %cmp = fcmp ogt double %ext, 0.000000
  ret i1 %cmp
}
=>
define i1 @fpext_constant_denorm(float %a) {
%0:
  %ext = fpext float %a to double, exceptions=ignore
  %cmp = fcmp ogt double %ext, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @fneg_constant_swap_pred(float %x) {
%0:
  %neg = fsub float -0.000000, %x, exceptions=ignore
  %cmp = fcmp ogt float %neg, 1.000000
  ret i1 %cmp
}
=>
define i1 @fneg_constant_swap_pred(float %x) {
%0:
  %cmp = fcmp olt float %x, -1.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @unary_fneg_constant_swap_pred(float %x) {
%0:
  %neg = fneg float %x, exceptions=ignore
  %cmp = fcmp ogt float %neg, 1.000000
  ret i1 %cmp
}
=>
define i1 @unary_fneg_constant_swap_pred(float %x) {
%0:
  %cmp = fcmp olt float %x, -1.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fneg_constant_swap_pred_vec(<2 x float> %x) {
%0:
  %neg = fsub <2 x float> { -0.000000, -0.000000 }, %x, exceptions=ignore
  %cmp = fcmp ogt <2 x float> %neg, { 1.000000, 2.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fneg_constant_swap_pred_vec(<2 x float> %x) {
%0:
  %cmp = fcmp olt <2 x float> %x, { -1.000000, -2.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @unary_fneg_constant_swap_pred_vec(<2 x float> %x) {
%0:
  %neg = fneg <2 x float> %x, exceptions=ignore
  %cmp = fcmp ogt <2 x float> %neg, { 1.000000, 2.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @unary_fneg_constant_swap_pred_vec(<2 x float> %x) {
%0:
  %cmp = fcmp olt <2 x float> %x, { -1.000000, -2.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fneg_constant_swap_pred_vec_undef(<2 x float> %x) {
%0:
  %neg = fsub <2 x float> { undef, -0.000000 }, %x, exceptions=ignore
  %cmp = fcmp ogt <2 x float> %neg, { 1.000000, 2.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fneg_constant_swap_pred_vec_undef(<2 x float> %x) {
%0:
  %cmp = fcmp olt <2 x float> %x, { -1.000000, -2.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fneg_fmf(float %x) {
%0:
  %n = fsub fast float -0.000000, %x, exceptions=ignore
  %r = fcmp fast oeq float %n, 42.000000
  ret i1 %r
}
=>
define i1 @fneg_fmf(float %x) {
%0:
  %r = fcmp fast oeq float %x, -42.000000
  ret i1 %r
}
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
 - arcp
 - contract
 - reassoc



----------------------------------------
define i1 @unary_fneg_fmf(float %x) {
%0:
  %n = fneg fast float %x, exceptions=ignore
  %r = fcmp fast oeq float %n, 42.000000
  ret i1 %r
}
=>
define i1 @unary_fneg_fmf(float %x) {
%0:
  %r = fcmp fast oeq float %x, -42.000000
  ret i1 %r
}
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
 - arcp
 - contract
 - reassoc



----------------------------------------
define <2 x i1> @fcmp_fneg_fmf_vec(<2 x float> %x) {
%0:
  %n = fsub nsz <2 x float> { 0.000000, 0.000000 }, %x, exceptions=ignore
  %r = fcmp nnan reassoc uge <2 x float> %n, { 42.000000, -19.000000 }
  ret <2 x i1> %r
}
=>
define <2 x i1> @fcmp_fneg_fmf_vec(<2 x float> %x) {
%0:
  %r = fcmp nnan reassoc ule <2 x float> %x, { -42.000000, 19.000000 }
  ret <2 x i1> %r
}
Transformation seems to be correct!


----------------------------------------
define i1 @fneg_fneg_swap_pred(float %x, float %y) {
%0:
  %neg1 = fsub float -0.000000, %x, exceptions=ignore
  %neg2 = fsub float -0.000000, %y, exceptions=ignore
  %cmp = fcmp nnan olt float %neg1, %neg2
  ret i1 %cmp
}
=>
define i1 @fneg_fneg_swap_pred(float %x, float %y) {
%0:
  %cmp = fcmp nnan ogt float %x, %y
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @unary_fneg_unary_fneg_swap_pred(float %x, float %y) {
%0:
  %neg1 = fneg float %x, exceptions=ignore
  %neg2 = fneg float %y, exceptions=ignore
  %cmp = fcmp nnan olt float %neg1, %neg2
  ret i1 %cmp
}
=>
define i1 @unary_fneg_unary_fneg_swap_pred(float %x, float %y) {
%0:
  %cmp = fcmp nnan ogt float %x, %y
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @unary_fneg_fneg_swap_pred(float %x, float %y) {
%0:
  %neg1 = fneg float %x, exceptions=ignore
  %neg2 = fsub float -0.000000, %y, exceptions=ignore
  %cmp = fcmp nnan olt float %neg1, %neg2
  ret i1 %cmp
}
=>
define i1 @unary_fneg_fneg_swap_pred(float %x, float %y) {
%0:
  %cmp = fcmp nnan ogt float %x, %y
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fneg_unary_fneg_swap_pred(float %x, float %y) {
%0:
  %neg1 = fsub float -0.000000, %x, exceptions=ignore
  %neg2 = fneg float %y, exceptions=ignore
  %cmp = fcmp nnan olt float %neg1, %neg2
  ret i1 %cmp
}
=>
define i1 @fneg_unary_fneg_swap_pred(float %x, float %y) {
%0:
  %cmp = fcmp nnan ogt float %x, %y
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fneg_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fsub <2 x float> { -0.000000, -0.000000 }, %x, exceptions=ignore
  %neg2 = fsub <2 x float> { -0.000000, -0.000000 }, %y, exceptions=ignore
  %cmp = fcmp ninf olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fneg_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ninf ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i1> @unary_fneg_unary_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fneg <2 x float> %x, exceptions=ignore
  %neg2 = fneg <2 x float> %y, exceptions=ignore
  %cmp = fcmp ninf olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @unary_fneg_unary_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ninf ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @unary_fneg_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fneg <2 x float> %x, exceptions=ignore
  %neg2 = fsub <2 x float> { -0.000000, -0.000000 }, %y, exceptions=ignore
  %cmp = fcmp ninf olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @unary_fneg_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ninf ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i1> @fneg_unary_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fsub <2 x float> { -0.000000, -0.000000 }, %x, exceptions=ignore
  %neg2 = fneg <2 x float> %y, exceptions=ignore
  %cmp = fcmp ninf olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fneg_unary_fneg_swap_pred_vec(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ninf ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i1> @fneg_fneg_swap_pred_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fsub <2 x float> { -0.000000, undef }, %x, exceptions=ignore
  %neg2 = fsub <2 x float> { undef, -0.000000 }, %y, exceptions=ignore
  %cmp = fcmp olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fneg_fneg_swap_pred_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i1> @unary_fneg_fneg_swap_pred_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fneg <2 x float> %x, exceptions=ignore
  %neg2 = fsub <2 x float> { undef, -0.000000 }, %y, exceptions=ignore
  %cmp = fcmp olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @unary_fneg_fneg_swap_pred_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x i1> @fneg_unary_fneg_swap_pred_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %neg1 = fsub <2 x float> { -0.000000, undef }, %x, exceptions=ignore
  %neg2 = fneg <2 x float> %y, exceptions=ignore
  %cmp = fcmp olt <2 x float> %neg1, %neg2
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fneg_unary_fneg_swap_pred_vec_undef(<2 x float> %x, <2 x float> %y) {
%0:
  %cmp = fcmp ogt <2 x float> %x, %y
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @test8(float %x) {
%0:
  %conv = fpext float %x to double, exceptions=ignore
  %cmp = fcmp olt double %conv, 0.000000
  %conv1 = zext i1 %cmp to i32
  %conv2 = sitofp i32 %conv1 to float, exceptions=ignore
  ret float %conv2
}
=>
define float @test8(float %x) {
%0:
  %cmp = fcmp olt float %x, 0.000000
  %conv2 = uitofp i1 %cmp to float, exceptions=ignore
  ret float %conv2
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_uge(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp uge double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_uge(double %a) {
%0:
  ret i1 1
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_olt(half %a) {
%0:
  %call = fabs half %a, exceptions=ignore
  %cmp = fcmp olt half %call, 0
  ret i1 %cmp
}
=>
define i1 @fabs_olt(half %a) {
%0:
  ret i1 0
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fabs_ole(<2 x float> %a) {
%0:
  %call = fabs <2 x float> %a, exceptions=ignore
  %cmp = fcmp ninf ole <2 x float> %call, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fabs_ole(<2 x float> %a) {
%0:
  %cmp = fcmp ninf oeq <2 x float> %a, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fabs_ule(<2 x float> %a) {
%0:
  %call = fabs <2 x float> %a, exceptions=ignore
  %cmp = fcmp ninf arcp ule <2 x float> %call, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fabs_ule(<2 x float> %a) {
%0:
  %cmp = fcmp ninf arcp ueq <2 x float> %a, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_ogt(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp reassoc ogt double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_ogt(double %a) {
%0:
  %cmp = fcmp reassoc one double %a, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_ugt(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp ninf reassoc ugt double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_ugt(double %a) {
%0:
  %cmp = fcmp ninf reassoc une double %a, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_oge(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp afn oge double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_oge(double %a) {
%0:
  %cmp = fcmp afn ord double %a, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_ult(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp arcp reassoc ult double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_ult(double %a) {
%0:
  %cmp = fcmp arcp reassoc uno double %a, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fabs_ult_nnan(<2 x float> %a) {
%0:
  %call = fabs <2 x float> %a, exceptions=ignore
  %cmp = fcmp nnan arcp reassoc ult <2 x float> %call, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fabs_ult_nnan(<2 x float> %a) {
%0:
  ret <2 x i1> { 0, 0 }
}
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:
 - arcp
 - reassoc



----------------------------------------
define i1 @fabs_une(half %a) {
%0:
  %call = fabs half %a, exceptions=ignore
  %cmp = fcmp ninf une half %call, 0
  ret i1 %cmp
}
=>
define i1 @fabs_une(half %a) {
%0:
  %cmp = fcmp ninf une half %a, 0
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_oeq(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp ninf reassoc oeq double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_oeq(double %a) {
%0:
  %cmp = fcmp ninf reassoc oeq double %a, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @fabs_one(double %a) {
%0:
  %call = fabs double %a, exceptions=ignore
  %cmp = fcmp fast one double %call, 0.000000
  ret i1 %cmp
}
=>
define i1 @fabs_one(double %a) {
%0:
  %cmp = fcmp fast one double %a, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fabs_ueq(<2 x float> %a) {
%0:
  %call = fabs <2 x float> %a, exceptions=ignore
  %cmp = fcmp arcp ueq <2 x float> %call, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fabs_ueq(<2 x float> %a) {
%0:
  %cmp = fcmp arcp ueq <2 x float> %a, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fabs_ord(<2 x float> %a) {
%0:
  %call = fabs <2 x float> %a, exceptions=ignore
  %cmp = fcmp arcp ord <2 x float> %call, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fabs_ord(<2 x float> %a) {
%0:
  %cmp = fcmp arcp ord <2 x float> %a, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @fabs_uno(<2 x float> %a) {
%0:
  %call = fabs <2 x float> %a, exceptions=ignore
  %cmp = fcmp arcp uno <2 x float> %call, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @fabs_uno(<2 x float> %a) {
%0:
  %cmp = fcmp arcp uno <2 x float> %a, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!

ERROR: Unsupported instruction:   %call = tail call double %p(double %a)

----------------------------------------
define i32 @test18_undef_unordered(float %a) {
%0:
  %cmp = fcmp ueq float %a, undef
  %conv = zext i1 %cmp to i32
  ret i32 %conv
}
=>
define i32 @test18_undef_unordered(float %a) {
%0:
  ret i32 1
}
Transformation seems to be correct!


----------------------------------------
define i32 @test18_undef_ordered(float %a) {
%0:
  %cmp = fcmp oeq float %a, undef
  %conv = zext i1 %cmp to i32
  ret i32 %conv
}
=>
define i32 @test18_undef_ordered(float %a) {
%0:
  ret i32 0
}
Transformation seems to be correct!


----------------------------------------
define i1 @test19_undef_unordered() {
%0:
  %cmp = fcmp ueq float undef, undef
  ret i1 %cmp
}
=>
define i1 @test19_undef_unordered() {
%0:
  ret i1 1
}
Transformation seems to be correct!


----------------------------------------
define i1 @test19_undef_ordered() {
%0:
  %cmp = fcmp oeq float undef, undef
  ret i1 %cmp
}
=>
define i1 @test19_undef_ordered() {
%0:
  ret i1 0
}
Transformation seems to be correct!


----------------------------------------
define i1 @test20_recipX_olt_0(float %X) {
%0:
  %div = fdiv ninf float 1.000000, %X, exceptions=ignore
  %cmp = fcmp ninf olt float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test20_recipX_olt_0(float %X) {
%0:
  %cmp = fcmp ninf olt float %X, 0.000000
  ret i1 %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @test21_recipX_ole_0(float %X) {
%0:
  %div = fdiv ninf float -2.000000, %X, exceptions=ignore
  %cmp = fcmp ninf ole float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test21_recipX_ole_0(float %X) {
%0:
  %cmp = fcmp ninf oge float %X, 0.000000
  ret i1 %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @test22_recipX_ogt_0(float %X) {
%0:
  %div = fdiv ninf float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ninf ogt float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test22_recipX_ogt_0(float %X) {
%0:
  %cmp = fcmp ninf ogt float %X, 0.000000
  ret i1 %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @test23_recipX_oge_0(float %X) {
%0:
  %div = fdiv ninf float -1.000000, %X, exceptions=ignore
  %cmp = fcmp ninf oge float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test23_recipX_oge_0(float %X) {
%0:
  %cmp = fcmp ninf ole float %X, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct!


----------------------------------------
define i1 @test24_recipX_noninf_cmp(float %X) {
%0:
  %div = fdiv ninf float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ogt float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test24_recipX_noninf_cmp(float %X) {
%0:
  %div = fdiv ninf float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ogt float %div, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @test25_recipX_noninf_div(float %X) {
%0:
  %div = fdiv float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ninf ogt float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test25_recipX_noninf_div(float %X) {
%0:
  %div = fdiv float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ninf ogt float %div, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i1 @test26_recipX_unorderd(float %X) {
%0:
  %div = fdiv ninf float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ninf ugt float %div, 0.000000
  ret i1 %cmp
}
=>
define i1 @test26_recipX_unorderd(float %X) {
%0:
  %div = fdiv ninf float 2.000000, %X, exceptions=ignore
  %cmp = fcmp ninf ugt float %div, 0.000000
  ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i1> @test27_recipX_gt_vecsplat(<2 x float> %X) {
%0:
  %div = fdiv ninf <2 x float> { -1.000000, -1.000000 }, %X, exceptions=ignore
  %cmp = fcmp ninf ogt <2 x float> %div, { -0.000000, -0.000000 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @test27_recipX_gt_vecsplat(<2 x float> %X) {
%0:
  %cmp = fcmp ninf olt <2 x float> %X, { 0.000000, 0.000000 }
  ret <2 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @is_signbit_set(double %x) {
%0:
  %s = copysign double 1.000000, %x, exceptions=ignore
  %r = fcmp olt double %s, 0.000000
  ret i1 %r
}
=>
define i1 @is_signbit_set(double %x) {
%0:
  %1 = bitcast double %x to i64
  %r = icmp slt i64 %1, 0
  ret i1 %r
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
double %x = NaN

Source:
double %s = #x3ff0000000000000 (1)
i1 %r = #x0 (0)

Target:
i64 %1 = #xfff8000000000000 (18444492273895866368, -2251799813685248)
i1 %r = #x1 (1)
Source value: #x0 (0)
Target value: #x1 (1)


------------------- SMT STATS -------------------
Num queries: 246
Num invalid: 0
Num skips:   0
Num trivial: 166 (40.3%)
Num timeout: 11 (4.5%)
Num errors:  0 (0.0%)
Num SAT:     148 (60.2%)
Num UNSAT:   87 (35.4%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

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

 

<-- Back