Test Failure: Transforms/InstSimplify/floating-point-arithmetic.ll

Test source: git

Log:

Source: <stdin>

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


----------------------------------------
define float @fsub_-0_x(float %a) {
%0:
  %t1 = fsub float -0.000000, %a
  %ret = fneg float %t1
  ret float %ret
}
=>
define float @fsub_-0_x(float %a) {
%0:
  ret float %a
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fsub_-0_x_vec(<2 x float> %a) {
%0:
  %t1 = fsub <2 x float> { -0.000000, -0.000000 }, %a
  %ret = fneg <2 x float> %t1
  ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_x_vec(<2 x float> %a) {
%0:
  ret <2 x float> %a
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fsub_-0_x_vec_undef_elts(<2 x float> %a) {
%0:
  %t1 = fsub <2 x float> { -0.000000, undef }, %a
  %ret = fneg <2 x float> %t1
  ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_x_vec_undef_elts(<2 x float> %a) {
%0:
  ret <2 x float> %a
}
Transformation doesn't verify!
ERROR: Timeout


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


----------------------------------------
define float @fsub_-0_-0_x(float %a) {
%0:
  %t1 = fsub float -0.000000, %a
  %ret = fsub float -0.000000, %t1
  ret float %ret
}
=>
define float @fsub_-0_-0_x(float %a) {
%0:
  ret float %a
}
Transformation seems to be correct!


----------------------------------------
define float @fneg_x(float %a) {
%0:
  %t1 = fneg float %a
  %ret = fsub float -0.000000, %t1
  ret float %ret
}
=>
define float @fneg_x(float %a) {
%0:
  ret float %a
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fsub_-0_-0_x_vec(<2 x float> %a) {
%0:
  %t1 = fsub <2 x float> { -0.000000, -0.000000 }, %a
  %ret = fsub <2 x float> { -0.000000, -0.000000 }, %t1
  ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_-0_x_vec(<2 x float> %a) {
%0:
  ret <2 x float> %a
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fneg_x_vec(<2 x float> %a) {
%0:
  %t1 = fneg <2 x float> %a
  %ret = fsub <2 x float> { -0.000000, -0.000000 }, %t1
  ret <2 x float> %ret
}
=>
define <2 x float> @fneg_x_vec(<2 x float> %a) {
%0:
  ret <2 x float> %a
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fsub_-0_-0_x_vec_undef_elts(<2 x float> %a) {
%0:
  %t1 = fsub <2 x float> { undef, -0.000000 }, %a
  %ret = fsub <2 x float> { -0.000000, undef }, %t1
  ret <2 x float> %ret
}
=>
define <2 x float> @fsub_-0_-0_x_vec_undef_elts(<2 x float> %a) {
%0:
  ret <2 x float> %a
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <2 x float> @fneg_x_vec_undef_elts(<2 x float> %a) {
%0:
  %t1 = fneg <2 x float> %a
  %ret = fsub <2 x float> { -0.000000, undef }, %t1
  ret <2 x float> %ret
}
=>
define <2 x float> @fneg_x_vec_undef_elts(<2 x float> %a) {
%0:
  ret <2 x float> %a
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fsub_-0_0_x(float %a) {
%0:
  %t1 = fsub float 0.000000, %a
  %ret = fsub float -0.000000, %t1
  ret float %ret
}
=>
define float @fsub_-0_0_x(float %a) {
%0:
  %t1 = fsub float 0.000000, %a
  %ret = fsub float -0.000000, %t1
  ret float %ret
}
Transformation seems to be correct!


----------------------------------------
define float @fsub_0_-0_x(float %a) {
%0:
  %t1 = fsub float -0.000000, %a
  %ret = fsub float 0.000000, %t1
  ret float %ret
}
=>
define float @fsub_0_-0_x(float %a) {
%0:
  %t1 = fsub float -0.000000, %a
  %ret = fsub float 0.000000, %t1
  ret float %ret
}
Transformation seems to be correct!


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


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


----------------------------------------
define float @fadd_x_n0(float %a) {
%0:
  %ret = fadd float %a, -0.000000
  ret float %ret
}
=>
define float @fadd_x_n0(float %a) {
%0:
  ret float %a
}
Transformation seems to be correct!


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


----------------------------------------
define double @fmul_X_1(double %a) {
%0:
  %b = fmul double 1.000000, %a
  ret double %b
}
=>
define double @fmul_X_1(double %a) {
%0:
  ret double %a
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x float> @fmul_X_1_vec(<4 x float> %x) {
%0:
  %m = fmul <4 x float> %x, { 1.000000, 1.000000, 1.000000, 1.000000 }
  ret <4 x float> %m
}
=>
define <4 x float> @fmul_X_1_vec(<4 x float> %x) {
%0:
  ret <4 x float> %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fdiv_x_1(float %a) {
%0:
  %ret = fdiv float %a, 1.000000
  ret float %ret
}
=>
define float @fdiv_x_1(float %a) {
%0:
  ret float %a
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @PR22688(float %x) {
%0:
  assume_welldefined float %x
  %1 = sqrt float %x
  assume_welldefined float %1
  %2 = sqrt float %1
  assume_welldefined float %2
  %3 = sqrt float %2
  assume_welldefined float %3
  %4 = sqrt float %3
  assume_welldefined float %4
  %5 = sqrt float %4
  assume_welldefined float %5
  %6 = sqrt float %5
  %7 = fadd float %6, 0.000000
  ret float %7
}
=>
define float @PR22688(float %x) {
%0:
  assume_welldefined float %x
  %1 = sqrt float %x
  assume_welldefined float %1
  %2 = sqrt float %1
  assume_welldefined float %2
  %3 = sqrt float %2
  assume_welldefined float %3
  %4 = sqrt float %3
  assume_welldefined float %4
  %5 = sqrt float %4
  assume_welldefined float %5
  %6 = sqrt float %5
  %7 = fadd float %6, 0.000000
  ret float %7
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_positive_constants(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float 1.000000, float 2.000000
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_positive_constants(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float 1.000000, float 2.000000
  ret float %select
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_positive_constants_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_positive_constants_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
  ret <2 x float> %select
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_constant_variable(i32 %c, float %x) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float 1.000000, float %x
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_constant_variable(i32 %c, float %x) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float 1.000000, float %x
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_constant_variable_vector(i32 %c, <2 x float> %x) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> %x
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_constant_variable_vector(i32 %c, <2 x float> %x) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> %x
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_neg0_pos0(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -0.000000, float 0.000000
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_neg0_pos0(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -0.000000, float 0.000000
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_neg0_pos0_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { 0.000000, 0.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_neg0_pos0_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { 0.000000, 0.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_neg0_neg1(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -0.000000, float -1.000000
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_neg0_neg1(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -0.000000, float -1.000000
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_neg0_neg1_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { -1.000000, -1.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_neg0_neg1_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -0.000000, -0.000000 }, <2 x float> { -1.000000, -1.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_nan_nan(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float nan, float nan
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_nan_nan(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float nan, float nan
  ret float %select
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_nan_nan_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { nan, nan }, <2 x float> { nan, nan }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_nan_nan_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { nan, nan }, <2 x float> { nan, nan }
  ret <2 x float> %select
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_negnan_nan(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float nan
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_negnan_nan(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float nan
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_negnan_nan_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { nan, nan }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_negnan_nan_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { nan, nan }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_negnan_negnan(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float nan
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_negnan_negnan(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float nan
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_negnan_negnan_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { nan, nan }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_negnan_negnan_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { nan, nan }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_negnan_negzero(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float -0.000000
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_negnan_negzero(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float -0.000000
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_negnan_negzero_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { -0.000000, -0.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_negnan_negzero_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { -0.000000, -0.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_select_negnan_zero(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float 0.000000
  %fabs = fabs float %select
  ret float %fabs
}
=>
define float @fabs_select_negnan_zero(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, float -nan, float 0.000000
  %fabs = fabs float %select
  ret float %fabs
}
Transformation seems to be correct!


----------------------------------------
define <2 x float> @fabs_select_negnan_zero_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { 0.000000, 0.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
=>
define <2 x float> @fabs_select_negnan_zero_vector(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { -nan, -nan }, <2 x float> { 0.000000, 0.000000 }
  %fabs = fabs <2 x float> %select
  ret <2 x float> %fabs
}
Transformation seems to be correct!


----------------------------------------
define float @fabs_sqrt(float %a) {
%0:
  %sqrt = sqrt float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
=>
define float @fabs_sqrt(float %a) {
%0:
  %sqrt = sqrt float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_sqrt_nnan(float %a) {
%0:
  %sqrt = sqrt nnan float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
=>
define float @fabs_sqrt_nnan(float %a) {
%0:
  %sqrt = sqrt nnan float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_sqrt_nsz(float %a) {
%0:
  %sqrt = sqrt nsz float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
=>
define float @fabs_sqrt_nsz(float %a) {
%0:
  %sqrt = sqrt nsz float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_sqrt_nnan_nsz(float %a) {
%0:
  %sqrt = sqrt nnan nsz float %a
  %fabs = fabs float %sqrt
  ret float %fabs
}
=>
define float @fabs_sqrt_nnan_nsz(float %a) {
%0:
  %sqrt = sqrt nnan nsz float %a
  ret float %sqrt
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_sqrt_nnan_fabs(float %a) {
%0:
  %b = fabs float %a
  %sqrt = sqrt nnan float %b
  %fabs = fabs float %sqrt
  ret float %fabs
}
=>
define float @fabs_sqrt_nnan_fabs(float %a) {
%0:
  %b = fabs float %a
  %sqrt = sqrt nnan float %b
  ret float %sqrt
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define float @fabs_select_positive_constants_vector_extract(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
  %extract = extractelement <2 x float> %select, i32 0
  %fabs = fabs float %extract
  ret float %fabs
}
=>
define float @fabs_select_positive_constants_vector_extract(i32 %c) {
%0:
  %cmp = icmp eq i32 %c, 0
  %select = select i1 %cmp, <2 x float> { 1.000000, 1.000000 }, <2 x float> { 2.000000, 2.000000 }
  %extract = extractelement <2 x float> %select, i32 0
  ret float %extract
}
Transformation seems to be correct!


----------------------------------------
define float @fsub_fsub_common_op(float %x, float %y) {
%0:
  %s = fsub float %y, %x
  %r = fsub nsz reassoc float %y, %s
  ret float %r
}
=>
define float @fsub_fsub_common_op(float %x, float %y) {
%0:
  ret float %x
}
Transformation doesn't verify!
ERROR: Target's return value is more undefined

Example:
float %x = undef
float %y = #xff800000 (-oo)

Source:
float %s = NaN	[based on undef value]
float %r = NaN

Target:
Source value: NaN
Target value: #x80000000 (-0.0)


------------------- SMT STATS -------------------
Num queries: 124
Num invalid: 0
Num skips:   0
Num trivial: 177 (58.8%)
Num timeout: 14 (11.3%)
Num errors:  0 (0.0%)
Num SAT:     48 (38.7%)
Num UNSAT:   62 (50.0%)

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -instsimplify -S
+ /home/nlopes/llvm/build/bin/FileCheck --allow-unused-prefixes=false /home/nlopes/llvm/llvm/test/Transforms/InstSimplify/floating-point-arithmetic.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/InstSimplify/floating-point-arithmetic.ll

<-- Back