Test Failure: Transforms/InstCombine/double-float-shrink-2.ll

Test source: git

Comments: LLVM PR49080

Log:

Source: <stdin>
ERROR: Unsupported instruction:   store volatile double %D, ptr undef, align 8
ERROR: Unsupported instruction:   store volatile double %D, ptr undef, align 8

----------------------------------------
define float @test_shrink_libcall_floor(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = floor double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_floor(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = floor float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_ceil(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = ceil double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_ceil(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = ceil float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_round(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = round double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_round(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = round float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_roundeven(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = roundeven double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_roundeven(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = roundeven float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_nearbyint(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = nearbyint double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_nearbyint(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = nearbyint float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_trunc(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = trunc double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_trunc(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = trunc float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_fabs(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = fabs double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_fabs(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = fabs float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_libcall_fabs_fast(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = fabs fast double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_libcall_fabs_fast(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = fabs fast float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_ceil(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = ceil double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_ceil(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = ceil float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_fabs(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = fabs double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_fabs(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = fabs float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_floor(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = floor double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_floor(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = floor float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_nearbyint(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = nearbyint double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_nearbyint(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = nearbyint float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define half @test_shrink_intrin_rint(half %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext half %C to float, exceptions=ignore
  %E = rint float %D, exceptions=ignore
  %F = fptrunc float %E to half, exceptions=ignore
  ret half %F
}
=>
define half @test_shrink_intrin_rint(half %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = rint half %C, exceptions=ignore
  ret half %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_round(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = round double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_round(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = round float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_roundeven(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = roundeven double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_roundeven(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = roundeven float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_shrink_intrin_trunc(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = trunc double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_trunc(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = trunc float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = ceil <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = ceil <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x float> @test_shrink_intrin_fabs_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = fabs <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_fabs_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = fabs <2 x float> %C, exceptions=ignore
  %E = fpext <2 x float> %1 to <2 x double>, exceptions=ignore
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = floor <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = floor <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x float> @test_shrink_intrin_nearbyint_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = nearbyint <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_nearbyint_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = nearbyint <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x half> @test_shrink_intrin_rint_multi_use(<2 x half> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x half> %C to <2 x float>, exceptions=ignore
  %E = rint <2 x float> %D, exceptions=ignore
  %F = fptrunc <2 x float> %E to <2 x half>, exceptions=ignore
  call void @use_v2f32(<2 x float> %E) denormal-fp-math=ieee,ieee
  ret <2 x half> %F
}
=>
define <2 x half> @test_shrink_intrin_rint_multi_use(<2 x half> %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = rint <2 x half> %C, exceptions=ignore
  %E = fpext <2 x half> %1 to <2 x float>, exceptions=ignore
  call void @use_v2f32(<2 x float> %E) denormal-fp-math=ieee,ieee
  ret <2 x half> %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = round <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = round <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x float> @test_shrink_intrin_roundeven_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = roundeven <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_roundeven_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = roundeven <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  call void @use_v2f64(<2 x double> %E) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = trunc <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
=>
define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext <2 x float> %C to <2 x double>, exceptions=ignore
  %E = trunc <2 x double> %D, exceptions=ignore
  %F = fptrunc <2 x double> %E to <2 x float>, exceptions=ignore
  call void @use_v2f64(<2 x double> %D) denormal-fp-math=ieee,ieee
  ret <2 x float> %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_shrink_intrin_fabs_fast(float %C) denormal-fp-math=ieee,ieee {
%0:
  %D = fpext float %C to double, exceptions=ignore
  %E = fabs fast double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_fabs_fast(float %C) denormal-fp-math=ieee,ieee {
%0:
  %1 = fabs fast float %C, exceptions=ignore
  ret float %1
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout

----------------------------------------
define float @test_no_shrink_intrin_floor(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = floor double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_no_shrink_intrin_floor(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = floor double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_no_shrink_intrin_ceil(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = ceil double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_no_shrink_intrin_ceil(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = ceil double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_no_shrink_intrin_round(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = round double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_no_shrink_intrin_round(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = round double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_no_shrink_intrin_roundeven(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = roundeven double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_no_shrink_intrin_roundeven(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = roundeven double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_no_shrink_intrin_nearbyint(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = nearbyint double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_no_shrink_intrin_nearbyint(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = nearbyint double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_no_shrink_intrin_trunc(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = trunc double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_no_shrink_intrin_trunc(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = trunc double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @test_shrink_intrin_fabs_double_src(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = fabs double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_fabs_double_src(double %D) denormal-fp-math=ieee,ieee {
%0:
  %1 = fptrunc double %D to float, exceptions=ignore
  %F = fabs float %1, exceptions=ignore
  ret float %F
}
Transformation seems to be correct!


----------------------------------------
define float @test_shrink_intrin_fabs_fast_double_src(double %D) denormal-fp-math=ieee,ieee {
%0:
  %E = fabs fast double %D, exceptions=ignore
  %F = fptrunc double %E to float, exceptions=ignore
  ret float %F
}
=>
define float @test_shrink_intrin_fabs_fast_double_src(double %D) denormal-fp-math=ieee,ieee {
%0:
  %1 = fptrunc double %D to float, exceptions=ignore
  %F = fabs fast float %1, exceptions=ignore
  ret float %F
}
Transformation doesn't verify! (unsound)
ERROR: Target is more poisonous than source

Example:
double %D = #x58f0015ef8006530 (2583114182655651338247823035071900255382535331591702140808965737448017332694647792277492805944677030350613680369967300608)

Source:
double %E = NaN
float %F = NaN

Target:
float %1 = #x7f800000 (+oo)
float %F = poison
Source value: NaN
Target value: poison

Pass: ModuleToFunctionPassAdaptor
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-tv' '-instcombine' '-S' '-mtriple' 'i386-pc-linux' '-tv' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'


------------------- SMT STATS -------------------
Num queries: 107
Num invalid: 0
Num skips:   0
Num trivial: 61 (36.3%)
Num timeout: 19 (17.8%)
Num errors:  0 (0.0%)
Num SAT:     64 (59.8%)
Num UNSAT:   24 (22.4%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh -instcombine -S -mtriple i386-pc-linux
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/double-float-shrink-2.ll

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/double-float-shrink-2.ll

<-- Back