Test Failure: Transforms/InstCombine/fneg.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define float @fneg_fneg(float %a) {
%0:
  %f = fneg float %a, exceptions=ignore
  %r = fneg float %f, exceptions=ignore
  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, exceptions=ignore
  %r = fsub float -0.000000, %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fsub(float %x) {
%0:
  %r = fmul float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!


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


----------------------------------------
define float @fmul_fsub_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub nsz reassoc float -0.000000, %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fsub_fmf(float %x) {
%0:
  %r = fmul nsz reassoc float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fneg_fmf(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg nsz reassoc float %m, exceptions=ignore
  ret float %r
}
=>
define float @fmul_fneg_fmf(float %x) {
%0:
  %r = fmul nsz reassoc float %x, -42.000000, exceptions=ignore
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fsub float -0.000000, %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
=>
define float @fmul_fsub_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  call void @use(float %m)
  ret float %r
}
=>
define float @fmul_fneg_extra_use(float %x) {
%0:
  %m = fmul float %x, 42.000000, exceptions=ignore
  %r = fneg float %m, exceptions=ignore
  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 }, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %m, exceptions=ignore
  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 }, exceptions=ignore
  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 }, exceptions=ignore
  %r = fneg <4 x double> %m, exceptions=ignore
  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 }, exceptions=ignore
  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, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op1_constant_fsub(float %x) {
%0:
  %r = fdiv float %x, 42.000000, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!


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


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


----------------------------------------
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %d = fdiv float %x, -42.000000, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op1_constant_fneg_fmf(float %x) {
%0:
  %r = fdiv nnan float %x, 42.000000, exceptions=ignore
  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, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  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 }, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d, exceptions=ignore
  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 }, exceptions=ignore
  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 }, exceptions=ignore
  %r = fneg <4 x double> %d, exceptions=ignore
  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 }, exceptions=ignore
  ret <4 x double> %r
}
Transformation doesn't verify!
ERROR: SMT Error: resource limit exceeded during internalization


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


----------------------------------------
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg fast float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast_fast(float %x) {
%0:
  %r = fdiv fast float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg fast float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_fast(float %x) {
%0:
  %r = fdiv nnan arcp contract reassoc afn float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg nsz float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz_nsz(float %x) {
%0:
  %r = fdiv nsz float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg nsz float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nsz(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg ninf float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf_ninf(float %x) {
%0:
  %r = fdiv ninf float -42.000000, %x, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %d = fdiv float 42.000000, %x, exceptions=ignore
  %r = fneg ninf float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_ninf(float %x) {
%0:
  %r = fdiv float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan_nnan(float %x) {
%0:
  %r = fdiv nnan float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fneg nnan float %d, exceptions=ignore
  ret float %r
}
=>
define float @fdiv_op0_constant_fneg_nnan(float %x) {
%0:
  %r = fdiv nnan float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fsub float -0.000000, %d, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  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, exceptions=ignore
  %r = fneg float %d, exceptions=ignore
  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, exceptions=ignore
  %r = fsub <4 x double> { -0.000000, -0.000000, -0.000000, -0.000000 }, %d, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %r = fneg <4 x double> %d, exceptions=ignore
  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, exceptions=ignore
  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, exceptions=ignore
  %n2 = fneg <2 x double> %y, exceptions=ignore
  %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, exceptions=ignore
  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, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  %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, exceptions=ignore
  call void @use(float %n1)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v, exceptions=ignore
  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, exceptions=ignore
  %n2 = fneg float %y, exceptions=ignore
  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, exceptions=ignore
  call void @use(float %n2)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v, exceptions=ignore
  ret float %sel
}
Transformation seems to be correct!


----------------------------------------
define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
%0:
  %n1 = fsub float -0.000000, %x, exceptions=ignore
  call void @use(float %n1)
  %n2 = fsub float -0.000000, %y, exceptions=ignore
  %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, exceptions=ignore
  call void @use(float %n1)
  %sel.v = select i1 %cond, float %x, float %y
  %sel = fneg float %sel.v, exceptions=ignore
  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, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  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, exceptions=ignore
  call void @use(float %n1)
  %n2 = fneg float %y, exceptions=ignore
  call void @use(float %n2)
  %sel = select i1 %cond, float %n1, float %n2
  ret float %sel
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define double @fneg_fneg_sel_fmf1(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf1(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select i1 %cond, double %x, double %y
  %sel = fneg double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!


----------------------------------------
define double @fneg_fneg_sel_fmf2(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan ninf double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf2(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select ninf i1 %cond, double %x, double %y
  %sel = fneg ninf double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!


----------------------------------------
define double @fneg_fneg_sel_fmf3(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan ninf double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select ninf i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf3(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select ninf i1 %cond, double %x, double %y
  %sel = fneg ninf double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!


----------------------------------------
define double @fneg_fneg_sel_fmf4(double %x, double %y, i1 %cond) {
%0:
  %n1 = fneg nnan double %x, exceptions=ignore
  %n2 = fneg ninf double %y, exceptions=ignore
  %sel = select nnan ninf nsz i1 %cond, double %n1, double %n2
  ret double %sel
}
=>
define double @fneg_fneg_sel_fmf4(double %x, double %y, i1 %cond) {
%0:
  %sel.v = select nnan ninf nsz i1 %cond, double %x, double %y
  %sel = fneg nnan ninf nsz double %sel.v, exceptions=ignore
  ret double %sel
}
Transformation seems to be correct!


----------------------------------------
define float @fneg_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg float %a, exceptions=ignore
  ret float %r
}
=>
define float @fneg_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg float %a, exceptions=ignore
  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, exceptions=ignore
  %r = fsub float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
define float @fake_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg float %a, exceptions=ignore
  ret float %r
}
Transformation seems to be correct!


----------------------------------------
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
=>
define float @fneg_nsz_fadd_constant(float %x) {
%0:
  %r = fsub nsz float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  %r = fsub fast float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant(float %x) {
%0:
  %r = fsub fast float -42.000000, %x, exceptions=ignore
  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, exceptions=ignore
  call void @use(float %a)
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
=>
define float @fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fneg nsz float %a, exceptions=ignore
  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, exceptions=ignore
  call void @use(float %a)
  %r = fsub fast float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
%0:
  %a = fadd float %x, 42.000000, exceptions=ignore
  call void @use(float %a)
  %r = fneg fast float %a, exceptions=ignore
  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 }, exceptions=ignore
  %r = fneg nnan nsz reassoc <2 x float> %a, exceptions=ignore
  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, exceptions=ignore
  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 }, exceptions=ignore
  %r = fsub nsz <2 x float> { undef, -0.000000 }, %a, exceptions=ignore
  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, exceptions=ignore
  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 ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fneg nsz float %a, exceptions=ignore
  ret float %r
}
=>
@g = global 2 bytes, align 1

define float @fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_2 = ptrtoint ptr @g to i32
  %__constexpr_1 = bitcast i32 %__constexpr_2 to float
  %__constexpr_0 = fneg float %__constexpr_1, exceptions=ignore
  %r = fsub nsz float %__constexpr_0, %x, exceptions=ignore
  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 ptr @g to i32
  %__constexpr_0 = bitcast i32 %__constexpr_1 to float
  %a = fadd float %x, %__constexpr_0, exceptions=ignore
  %r = fsub nsz float -0.000000, %a, exceptions=ignore
  ret float %r
}
=>
@g = global 2 bytes, align 1

define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
%0:
  %__constexpr_2 = ptrtoint ptr @g to i32
  %__constexpr_1 = bitcast i32 %__constexpr_2 to float
  %__constexpr_0 = fneg float %__constexpr_1, exceptions=ignore
  %r = fsub nsz float %__constexpr_0, %x, exceptions=ignore
  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, exceptions=ignore
  %s = select i1 %b, float %nx, float %y
  %r = fneg float %s, exceptions=ignore
  ret float %r
}
=>
define float @select_fneg_true(float %x, float %y, i1 %b) {
%0:
  %y.neg = fneg float %y, exceptions=ignore
  %r = select i1 %b, float %x, float %y.neg
  ret float %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
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, exceptions=ignore
  %s = select ninf <2 x i1> %b, <2 x float> %x, <2 x float> %ny
  %r = fneg nnan nsz <2 x float> %s, exceptions=ignore
  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, exceptions=ignore
  %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 = < undef, #x00000000 (+0.0) >
<2 x float> %y = < #x00000000 (+0.0), #x80000000 (-0.0) >
<2 x i1> %b = < undef, undef >

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

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


------------------- SMT STATS -------------------
Num queries: 249
Num invalid: 0
Num skips:   0
Num trivial: 137 (35.5%)
Num timeout: 25 (10.0%)
Num errors:  1 (0.4%)
Num SAT:     142 (57.0%)
Num UNSAT:   81 (32.5%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -passes=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