Test Failure: Transforms/InstCombine/sitofp.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define i1 @test1(i8 %A) {
%0:
  %B = sitofp i8 %A to double, exceptions=ignore
  %C = fcmp ult double %B, 128.000000
  ret i1 %C
}
=>
define i1 @test1(i8 %A) {
%0:
  ret i1 1
}
Transformation seems to be correct!


----------------------------------------
define i1 @test2(i8 %A) {
%0:
  %B = sitofp i8 %A to double, exceptions=ignore
  %C = fcmp ugt double %B, -128.100000
  ret i1 %C
}
=>
define i1 @test2(i8 %A) {
%0:
  ret i1 1
}
Transformation seems to be correct!


----------------------------------------
define i1 @test3(i8 %A) {
%0:
  %B = sitofp i8 %A to double, exceptions=ignore
  %C = fcmp ule double %B, 127.000000
  ret i1 %C
}
=>
define i1 @test3(i8 %A) {
%0:
  ret i1 1
}
Transformation seems to be correct!


----------------------------------------
define i1 @test4(i8 %A) {
%0:
  %B = sitofp i8 %A to double, exceptions=ignore
  %C = fcmp ult double %B, 127.000000
  ret i1 %C
}
=>
define i1 @test4(i8 %A) {
%0:
  %C = icmp ne i8 %A, 127
  ret i1 %C
}
Transformation seems to be correct!


----------------------------------------
define i32 @test5(i32 %A) {
%0:
  %B = sitofp i32 %A to double, exceptions=ignore
  %C = fptosi double %B to i32, exceptions=ignore
  %D = uitofp i32 %C to double, exceptions=ignore
  %E = fptoui double %D to i32, exceptions=ignore
  ret i32 %E
}
=>
define i32 @test5(i32 %A) {
%0:
  ret i32 %A
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test6(i32 %A) {
%0:
  %B = and i32 %A, 7
  %C = and i32 %A, 32
  %D = sitofp i32 %B to double, exceptions=ignore
  %E = sitofp i32 %C to double, exceptions=ignore
  %F = fadd double %D, %E, exceptions=ignore
  %G = fptosi double %F to i32, exceptions=ignore
  ret i32 %G
}
=>
define i32 @test6(i32 %A) {
%0:
  %addconv = and i32 %A, 39
  ret i32 %addconv
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test7(i32 %A) {
%0:
  %B = sitofp i32 %A to double, exceptions=ignore
  %C = fptoui double %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test7(i32 %A) {
%0:
  ret i32 %A
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test8(i32 %A) {
%0:
  %B = uitofp i32 %A to double, exceptions=ignore
  %C = fptosi double %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test8(i32 %A) {
%0:
  ret i32 %A
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test9(i8 %A) {
%0:
  %B = sitofp i8 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test9(i8 %A) {
%0:
  %C = zext i8 %A to i32
  ret i32 %C
}
Transformation seems to be correct!


----------------------------------------
define i32 @test10(i8 %A) {
%0:
  %B = sitofp i8 %A to float, exceptions=ignore
  %C = fptosi float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test10(i8 %A) {
%0:
  %C = sext i8 %A to i32
  ret i32 %C
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @test11(i32 %A) {
%0:
  %B = sitofp i32 %A to float, exceptions=ignore
  %C = fptosi float %B to i8, exceptions=ignore
  ret i8 %C
}
=>
define i8 @test11(i32 %A) {
%0:
  %C = trunc i32 %A to i8
  ret i8 %C
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test12(i8 %A) {
%0:
  %B = sitofp i8 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test12(i8 %A) {
%0:
  %C = zext i8 %A to i32
  ret i32 %C
}
Transformation seems to be correct!


----------------------------------------
define i32 @test13(i25 %A) {
%0:
  %B = uitofp i25 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test13(i25 %A) {
%0:
  %B = uitofp i25 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i32 @test14(i24 %A) {
%0:
  %B = uitofp i24 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test14(i24 %A) {
%0:
  %C = zext i24 %A to i32
  ret i32 %C
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i24 @test15(i32 %A) {
%0:
  %B = uitofp i32 %A to float, exceptions=ignore
  %C = fptoui float %B to i24, exceptions=ignore
  ret i24 %C
}
=>
define i24 @test15(i32 %A) {
%0:
  %C = trunc i32 %A to i24
  ret i24 %C
}
Transformation seems to be correct!


----------------------------------------
define i32 @test16(i25 %A) {
%0:
  %B = sitofp i25 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test16(i25 %A) {
%0:
  %C = zext i25 %A to i32
  ret i32 %C
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test17(i26 %A) {
%0:
  %B = sitofp i26 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
=>
define i32 @test17(i26 %A) {
%0:
  %B = sitofp i26 %A to float, exceptions=ignore
  %C = fptoui float %B to i32, exceptions=ignore
  ret i32 %C
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i54 @test18(i64 %A) {
%0:
  %B = sitofp i64 %A to double, exceptions=ignore
  %C = fptosi double %B to i54, exceptions=ignore
  ret i54 %C
}
=>
define i54 @test18(i64 %A) {
%0:
  %C = trunc i64 %A to i54
  ret i54 %C
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i55 @test19(i64 %A) {
%0:
  %B = sitofp i64 %A to double, exceptions=ignore
  %C = fptosi double %B to i55, exceptions=ignore
  ret i55 %C
}
=>
define i55 @test19(i64 %A) {
%0:
  %B = sitofp i64 %A to double, exceptions=ignore
  %C = fptosi double %B to i55, exceptions=ignore
  ret i55 %C
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i25 @masked_input(i25 %A) {
%0:
  %m = and i25 %A, 65535
  %B = uitofp i25 %m to float, exceptions=ignore
  %C = fptoui float %B to i25, exceptions=ignore
  ret i25 %C
}
=>
define i25 @masked_input(i25 %A) {
%0:
  %m = and i25 %A, 65535
  %B = uitofp i25 %m to float, exceptions=ignore
  %C = fptoui float %B to i25, exceptions=ignore
  ret i25 %C
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i25 @low_masked_input(i25 %A) {
%0:
  %m = and i25 %A, 33554430
  %B = uitofp i25 %m to float, exceptions=ignore
  %C = fptoui float %B to i25, exceptions=ignore
  ret i25 %C
}
=>
define i25 @low_masked_input(i25 %A) {
%0:
  %m = and i25 %A, 33554430
  %B = uitofp i25 %m to float, exceptions=ignore
  %C = fptoui float %B to i25, exceptions=ignore
  ret i25 %C
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i11 @s32_half_s11(i32 %x) {
%0:
  %h = sitofp i32 %x to half, exceptions=ignore
  %r = fptosi half %h to i11, exceptions=ignore
  ret i11 %r
}
=>
define i11 @s32_half_s11(i32 %x) {
%0:
  %r = trunc i32 %x to i11
  ret i11 %r
}
Transformation seems to be correct!


----------------------------------------
define i11 @s32_half_u11(i32 %x) {
%0:
  %h = sitofp i32 %x to half, exceptions=ignore
  %r = fptoui half %h to i11, exceptions=ignore
  ret i11 %r
}
=>
define i11 @s32_half_u11(i32 %x) {
%0:
  %r = trunc i32 %x to i11
  ret i11 %r
}
Transformation seems to be correct!


----------------------------------------
define i11 @u32_half_s11(i32 %x) {
%0:
  %h = uitofp i32 %x to half, exceptions=ignore
  %r = fptosi half %h to i11, exceptions=ignore
  ret i11 %r
}
=>
define i11 @u32_half_s11(i32 %x) {
%0:
  %r = trunc i32 %x to i11
  ret i11 %r
}
Transformation seems to be correct!


----------------------------------------
define i11 @u32_half_u11(i32 %x) {
%0:
  %h = uitofp i32 %x to half, exceptions=ignore
  %r = fptoui half %h to i11, exceptions=ignore
  ret i11 %r
}
=>
define i11 @u32_half_u11(i32 %x) {
%0:
  %r = trunc i32 %x to i11
  ret i11 %r
}
Transformation seems to be correct!


----------------------------------------
define i12 @s32_half_s12(i32 %x) {
%0:
  %h = sitofp i32 %x to half, exceptions=ignore
  %r = fptosi half %h to i12, exceptions=ignore
  ret i12 %r
}
=>
define i12 @s32_half_s12(i32 %x) {
%0:
  %r = trunc i32 %x to i12
  ret i12 %r
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
i32 %x = #xfffff7ff (4294965247, -2049)

Source:
half %h = #xe800 (-2048)
i12 %r = #x800 (2048, -2048)

Target:
i12 %r = #x7ff (2047)
Source value: #x800 (2048, -2048)
Target value: #x7ff (2047)


------------------- SMT STATS -------------------
Num queries: 119
Num invalid: 0
Num skips:   0
Num trivial: 66 (35.7%)
Num timeout: 9 (7.6%)
Num errors:  0 (0.0%)
Num SAT:     64 (53.8%)
Num UNSAT:   46 (38.7%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

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

<-- Back