Test source: git
Comments: LLVM PR49080
Source: <stdin> ERROR: Unsupported instruction: store volatile double %D, double* undef, align 8 ERROR: Unsupported instruction: store volatile double %D, double* undef, align 8 ---------------------------------------- define float @test_shrink_libcall_floor(float %C) { %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) { %0: %1 = floor float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_ceil(float %C) { %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) { %0: %1 = ceil float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_round(float %C) { %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) { %0: %1 = round float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_roundeven(float %C) { %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) { %0: %1 = roundeven float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_nearbyint(float %C) { %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) { %0: %1 = nearbyint float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_trunc(float %C) { %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) { %0: %1 = trunc float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_fabs(float %C) { %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) { %0: %1 = fabs float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_libcall_fabs_fast(float %C) { %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) { %0: %1 = fabs fast float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_ceil(float %C) { %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) { %0: %1 = ceil float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_fabs(float %C) { %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) { %0: %1 = fabs float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_floor(float %C) { %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) { %0: %1 = floor float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_nearbyint(float %C) { %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) { %0: %1 = nearbyint float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define half @test_shrink_intrin_rint(half %C) { %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) { %0: %1 = rint half %C, exceptions=ignore ret half %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_round(float %C) { %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) { %0: %1 = round float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_roundeven(float %C) { %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) { %0: %1 = roundeven float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_trunc(float %C) { %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) { %0: %1 = trunc float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) { %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) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_ceil_multi_use(<2 x float> %C) { %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) 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) { %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) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_fabs_multi_use(<2 x float> %C) { %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) ret <2 x float> %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) { %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) call void @use_v2f64(<2 x double> %E) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_floor_multi_use(<2 x float> %C) { %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) call void @use_v2f64(<2 x double> %E) 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) { %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) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_nearbyint_multi_use(<2 x float> %C) { %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) 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) { %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) ret <2 x half> %F } => define <2 x half> @test_shrink_intrin_rint_multi_use(<2 x half> %C) { %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) ret <2 x half> %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) { %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) call void @use_v2f64(<2 x double> %E) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_round_multi_use(<2 x float> %C) { %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) call void @use_v2f64(<2 x double> %E) 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) { %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) call void @use_v2f64(<2 x double> %E) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_roundeven_multi_use(<2 x float> %C) { %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) call void @use_v2f64(<2 x double> %E) 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) { %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) ret <2 x float> %F } => define <2 x float> @test_shrink_intrin_trunc_multi_use(<2 x float> %C) { %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) ret <2 x float> %F } Transformation seems to be correct! (syntactically equal) ---------------------------------------- define float @test_shrink_intrin_fabs_fast(float %C) { %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) { %0: %1 = fabs fast float %C, exceptions=ignore ret float %1 } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_no_shrink_intrin_floor(double %D) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %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) { %0: %1 = fptrunc double %D to float, exceptions=ignore %F = fabs float %1, exceptions=ignore ret float %F } Transformation doesn't verify! ERROR: Timeout ---------------------------------------- define float @test_shrink_intrin_fabs_fast_double_src(double %D) { %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) { %0: %1 = fptrunc double %D to float, exceptions=ignore %F = fabs fast float %1, exceptions=ignore ret float %F } Transformation doesn't verify! ERROR: Target is more poisonous than source Example: double %D = #x59f0000004000000 (169230330532032037900936988442247952605262882363959305446658678338938660428221897907069917003080153233617951290030171105525760) Source: double %E = NaN float %F = NaN Target: float %1 = #x7f800000 (+oo) float %F = poison Source value: NaN Target value: poison ------------------- SMT STATS ------------------- Num queries: 104 Num invalid: 0 Num skips: 0 Num trivial: 59 (36.2%) Num timeout: 20 (19.2%) Num errors: 0 (0.0%) Num SAT: 64 (61.5%) Num UNSAT: 20 (19.2%) Alive2: Transform doesn't verify; aborting!
+ : 'RUN: at line 2' + /home/nlopes/alive2/build/opt-alive.sh -instcombine -S -mtriple i386-pc-linux + /tmp/nlopes/llvm/build/bin/FileCheck /tmp/nlopes/llvm/llvm/test/Transforms/InstCombine/double-float-shrink-2.ll FileCheck error: '<stdin>' is empty. FileCheck command line: /tmp/nlopes/llvm/build/bin/FileCheck /tmp/nlopes/llvm/llvm/test/Transforms/InstCombine/double-float-shrink-2.ll