Test Failure: Transforms/InstCombine/fneg.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define float @fneg_fneg(float %a) {
%0:
  %f = fneg float %a
  %r = fneg float %f
  ret float %r
}
=>
define float @fneg_fneg(float %a) {
%0:
  ret float %a
}
Transformation seems to be correct!


----------------------------------------
define float @fmul_fsub(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fsub float -0.000000, %m
  ret float %r
}
=>
define float @fmul_fsub(float %x) {
%0:
  %r = fmul float %x, -42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fmul_fneg(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fneg float %m
  ret float %r
}
=>
define float @fmul_fneg(float %x) {
%0:
  %r = fmul float %x, -42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fmul_fsub_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fsub nsz reassoc float -0.000000, %m
  ret float %r
}
=>
define float @fmul_fsub_fmf(float %x) {
%0:
  %r = fmul nsz reassoc float %x, -42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fmul_fneg_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fneg nsz reassoc float %m
  ret float %r
}
=>
define float @fmul_fneg_fmf(float %x) {
%0:
  %r = fmul nsz reassoc float %x, -42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fsub float -0.000000, %m
  call void @use(float %m)
  ret float %r
}
=>
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fneg float %m
  call void @use(float %m)
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fmul_fneg_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fneg float %m
  call void @use(float %m)
  ret float %r
}
=>
define float @fmul_fneg_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000
  %r = fneg float %m
  call void @use(float %m)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x double> @fmul_fsub_vec(<4 x double> %x) {
%0:
  %m = fmul <4 x double> %x, { 42.000000, nan, inf, undef }
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %m
  ret <4 x double> %r
}
=>
define <4 x double> @fmul_fsub_vec(<4 x double> %x) {
%0:
  %r = fmul <4 x double> %x, { -42.000000, -nan, -inf, undef }
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
%0:
  %m = fmul <4 x double> %x, { 42.000000, nan, inf, undef }
  %r = fneg <4 x double> %m
  ret <4 x double> %r
}
=>
define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
%0:
  %r = fmul <4 x double> %x, { -42.000000, -nan, -inf, undef }
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op1_constant_fsub(float %x) {
%0:
  %d = fdiv float %x, -42.000000
  %r = fsub float -0.000000, %d
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub(float %x) {
%0:
  %r = fdiv float %x, 42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op1_constant_fneg(float %x) {
%0:
  %d = fdiv float %x, -42.000000
  %r = fneg float %d
  ret float %r
}
=>
define float @fdiv_op1_constant_fneg(float %x) {
%0:
  %r = fdiv float %x, 42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op1_constant_fsub_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000
  %r = fsub nnan float -0.000000, %d
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub_fmf(float %x) {
%0:
  %r = fdiv nnan float %x, 42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000
  %r = fneg nnan float %d
  ret float %r
}
=>
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %r = fdiv nnan float %x, 42.000000
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000
  %r = fsub float -0.000000, %d
  call void @use(float %d)
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000
  %r = fneg float %d
  call void @use(float %d)
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op1_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000
  %r = fneg float %d
  call void @use(float %d)
  ret float %r
}
=>
define float @fdiv_op1_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float %x, 42.000000
  %r = fneg float %d
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x double> @fdiv_op1_constant_fsub_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> %x, { -42.000000, -nan, -inf, undef }
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op1_constant_fsub_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> %x, { 42.000000, nan, inf, undef }
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> %x, { -42.000000, -nan, -inf, undef }
  %r = fneg <4 x double> %d
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> %x, { 42.000000, nan, inf, undef }
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fsub(float %x) {
%0:
  %d = fdiv float 42.000000, %x
  %r = fsub float -0.000000, %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fsub(float %x) {
%0:
  %r = fdiv float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %d = fdiv float 42.000000, %x
  %r = fneg float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %r = fdiv float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
%0:
  %d = fdiv fast float 42.000000, %x
  %r = fneg fast float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
%0:
  %r = fdiv fast float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg_fast(float %x) {
%0:
  %d = fdiv float 42.000000, %x
  %r = fneg fast float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast(float %x) {
%0:
  %r = fdiv nnan arcp contract reassoc afn float -42.000000, %x
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
%0:
  %d = fdiv nsz float 42.000000, %x
  %r = fneg nsz float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
%0:
  %r = fdiv nsz float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg_nsz(float %x) {
%0:
  %d = fdiv float 42.000000, %x
  %r = fneg nsz float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz(float %x) {
%0:
  %r = fdiv float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
%0:
  %d = fdiv ninf float 42.000000, %x
  %r = fneg ninf float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
%0:
  %r = fdiv ninf float -42.000000, %x
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %d = fdiv float 42.000000, %x
  %r = fneg ninf float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %r = fdiv float -42.000000, %x
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
%0:
  %d = fdiv nnan float 42.000000, %x
  %r = fneg nnan float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
%0:
  %r = fdiv nnan float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg_nnan(float %x) {
%0:
  %d = fdiv float 42.000000, %x
  %r = fneg nnan float %d
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan(float %x) {
%0:
  %r = fdiv nnan float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x
  %r = fsub float -0.000000, %d
  call void @use(float %d)
  ret float %r
}
=>
define float @fdiv_op0_constant_fsub_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x
  %r = fneg float %d
  call void @use(float %d)
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_op0_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x
  %r = fneg float %d
  call void @use(float %d)
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_extra_use(float %x) {
%0:
  %d = fdiv float -42.000000, %x
  %r = fneg float %d
  call void @use(float %d)
  ret float %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x double> @fdiv_op0_constant_fsub_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> { -42.000000, nan, -inf, undef }, %x
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op0_constant_fsub_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> { 42.000000, -nan, inf, undef }, %x
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
%0:
  %d = fdiv <4 x double> { -42.000000, nan, -inf, undef }, %x
  %r = fneg <4 x double> %d
  ret <4 x double> %r
}
=>
define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
%0:
  %r = fdiv <4 x double> { 42.000000, -nan, inf, undef }, %x
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x double> @fneg_fneg_sel(<2 x double> %x, <2 x double> %y, i1 %cond) {
%0:
  %n1 = fneg <2 x double> %x
  %n2 = fneg <2 x double> %y
  %sel = select i1 %cond, <2 x double> %n1, <2 x double> %n2
  ret <2 x double> %sel
}
=>
define <2 x double> @fneg_fneg_sel(<2 x double> %x, <2 x double> %y, i1 %cond) {
%0:
  %sel.v = select i1 %cond, <2 x double> %x, <2 x double> %y
  %sel = fneg <2 x double> %sel.v
  ret <2 x double> %sel
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x
  call void @use(float %n1)
  %n2 = fneg float %y
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fneg_fneg_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x
  call void @use(float %n1)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v
  ret float %sel
}
Transformation seems to be correct!


----------------------------------------
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x
  %n2 = fneg float %y
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fneg_fneg_sel_extra_use2(float %x, float %y, i1 %cond) {
%0:
  %n2 = fneg float %y
  call void @use(float %n2)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v
  ret float %sel
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fsub float -0.000000, %x
  call void @use(float %n1)
  %n2 = fsub float -0.000000, %y
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x
  call void @use(float %n1)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v
  ret float %sel
}
Transformation seems to be correct!


----------------------------------------
define float @fneg_fneg_sel_extra_use3(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x
  call void @use(float %n1)
  %n2 = fneg float %y
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
=>
define float @fneg_fneg_sel_extra_use3(float %x, float %y, i1 %cond) {
%0:
  %n1 = fneg float %x
  call void @use(float %n1)
  %n2 = fneg float %y
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @fneg_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000
  %r = fneg float %a
  ret float %r
}
=>
define float @fneg_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000
  %r = fneg float %a
  ret float %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @fake_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000
  %r = fsub float -0.000000, %a
  ret float %r
}
=>
define float @fake_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000
  %r = fneg float %a
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000
  %r = fneg nsz float %a
  ret float %r
}
=>
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %r = fsub nsz float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fake_fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000
  %r = fsub fast float -0.000000, %a
  ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant(float %x) {
%0:
  %r = fsub fast float -42.000000, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000
  call void @use(float %a)
  %r = fneg nsz float %a
  ret float %r
}
=>
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000
  call void @use(float %a)
  %r = fneg nsz float %a
  ret float %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000
  call void @use(float %a)
  %r = fsub fast float -0.000000, %a
  ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000
  call void @use(float %a)
  %r = fneg fast float %a
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %a = fadd <2 x float> %x, { 42.000000, 43.000000 }
  %r = fneg nnan nsz reassoc <2 x float> %a
  ret <2 x float> %r
}
=>
define <2 x float> @fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %r = fsub nnan nsz reassoc <2 x float> { -42.000000, -43.000000 }, %x
  ret <2 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @fake_fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %a = fadd <2 x float> %x, { 42.000000, undef }
  %r = fsub nsz <2 x float> { undef, -0.000000 }, %a
  ret <2 x float> %r
}
=>
define <2 x float> @fake_fneg_nsz_fadd_constant_vec(<2 x float> %x) {
%0:
  %r = fsub nsz <2 x float> { -42.000000, undef }, %x
  ret <2 x float> %r
}
Transformation doesn't verify!
ERROR: Timeout


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

define float @fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint * @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0
  %r = fneg nsz float %a
  ret float %r
}
=>
@g = global 2 bytes, align 1

define float @fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_2 = ptrtoint * @g to i32
  %__constexpr_1 = bitcast i32 %__constexpr_2 to float
  %__constexpr_0 = fneg float %__constexpr_1
  %r = fsub nsz float %__constexpr_0, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


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

define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_1 = ptrtoint * @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0
  %r = fsub nsz float -0.000000, %a
  ret float %r
}
=>
@g = global 2 bytes, align 1

define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_2 = ptrtoint * @g to i32
  %__constexpr_1 = bitcast i32 %__constexpr_2 to float
  %__constexpr_0 = fneg float %__constexpr_1
  %r = fsub nsz float %__constexpr_0, %x
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @select_fneg_true(float %x, float %y, i1 %b) {
%0:
  %nx = fneg float %x
  %s = select i1 %b, float %nx, float %y
  %r = fneg float %s
  ret float %r
}
=>
define float @select_fneg_true(float %x, float %y, i1 %b) {
%0:
  %y.neg = fneg float %y
  %r = select i1 %b, float %x, float %y.neg
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @select_fneg_false(<2 x float> %x, <2 x float> %y, <2 x i1> %b) {
%0:
  %ny = fneg nnan <2 x float> %y
  %s = select ninf <2 x i1> %b, <2 x float> %x, <2 x float> %ny
  %r = fneg nnan nsz <2 x float> %s
  ret <2 x float> %r
}
=>
define <2 x float> @select_fneg_false(<2 x float> %x, <2 x float> %y, <2 x i1> %b) {
%0:
  %x.neg = fneg nnan nsz <2 x float> %x
  %r = select nnan <2 x i1> %b, <2 x float> %x.neg, <2 x float> %y
  ret <2 x float> %r
}
Transformation doesn't verify!
ERROR: Target's return value is more undefined

Example:
<2 x float> %x = < poison, #x80000000 (-0.0) >
<2 x float> %y = < poison, #x00000000 (+0.0) >
<2 x i1> %b = < poison, undef >

Source:
<2 x float> %ny = < poison, #x80000000 (-0.0) >
<2 x float> %s = < poison, #x80000000 (-0.0) >
<2 x float> %r = < poison, #x00000000 (+0.0) >

Target:
<2 x float> %x.neg = < poison, #x80000000 (-0.0) >
<2 x float> %r = < poison, #x00000000 (+0.0) >
Source value: < poison, #x00000000 (+0.0) >
Target value: < poison, #x00000000 (+0.0) >


------------------- SMT STATS -------------------
Num queries: 131
Num invalid: 0
Num skips:   0
Num trivial: 123 (48.4%)
Num timeout: 24 (18.3%)
Num errors:  0 (0.0%)
Num SAT:     45 (34.4%)
Num UNSAT:   62 (47.3%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

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

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

<-- Back