Test Failure: Transforms/InstCombine/or.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define i32 @test12(i32 %A) {
%0:
  %B = or i32 %A, 4
  %C = and i32 %B, 8
  ret i32 %C
}
=>
define i32 @test12(i32 %A) {
%0:
  %C = and i32 %A, 8
  ret i32 %C
}
Transformation seems to be correct!


----------------------------------------
define i32 @test13(i32 %A) {
%0:
  %B = or i32 %A, 12
  %C = and i32 %B, 8
  ret i32 %C
}
=>
define i32 @test13(i32 %A) {
%0:
  ret i32 8
}
Transformation seems to be correct!


----------------------------------------
define i1 @test14(i32 %A, i32 %B) {
%0:
  %C1 = icmp ult i32 %A, %B
  %C2 = icmp ugt i32 %A, %B
  %D = or i1 %C1, %C2
  ret i1 %D
}
=>
define i1 @test14(i32 %A, i32 %B) {
%0:
  %1 = icmp ne i32 %A, %B
  ret i1 %1
}
Transformation seems to be correct!


----------------------------------------
define i1 @test15(i32 %A, i32 %B) {
%0:
  %C1 = icmp ult i32 %A, %B
  %C2 = icmp eq i32 %A, %B
  %D = or i1 %C1, %C2
  ret i1 %D
}
=>
define i1 @test15(i32 %A, i32 %B) {
%0:
  %1 = icmp ule i32 %A, %B
  ret i1 %1
}
Transformation seems to be correct!


----------------------------------------
define i32 @test16(i32 %A) {
%0:
  %B = and i32 %A, 1
  %C = and i32 %A, 4294967294
  %D = or i32 %B, %C
  ret i32 %D
}
=>
define i32 @test16(i32 %A) {
%0:
  ret i32 %A
}
Transformation seems to be correct!


----------------------------------------
define i32 @test17(i32 %A) {
%0:
  %B = and i32 %A, 1
  %C = and i32 %A, 4
  %D = or i32 %B, %C
  ret i32 %D
}
=>
define i32 @test17(i32 %A) {
%0:
  %D = and i32 %A, 5
  ret i32 %D
}
Transformation seems to be correct!


----------------------------------------
define i1 @test18(i32 %A) {
%0:
  %B = icmp sge i32 %A, 100
  %C = icmp slt i32 %A, 50
  %D = or i1 %B, %C
  ret i1 %D
}
=>
define i1 @test18(i32 %A) {
%0:
  %A.off = add i32 %A, 4294967246
  %1 = icmp ugt i32 %A.off, 49
  ret i1 %1
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @test18vec(<2 x i32> %A) {
%0:
  %B = icmp sge <2 x i32> %A, { 100, 100 }
  %C = icmp slt <2 x i32> %A, { 50, 50 }
  %D = or <2 x i1> %B, %C
  ret <2 x i1> %D
}
=>
define <2 x i1> @test18vec(<2 x i32> %A) {
%0:
  %B = icmp sgt <2 x i32> %A, { 99, 99 }
  %C = icmp slt <2 x i32> %A, { 50, 50 }
  %D = or <2 x i1> %B, %C
  ret <2 x i1> %D
}
Transformation seems to be correct!


----------------------------------------
define i32 @test20(i32 %x) {
%0:
  %y = and i32 %x, 123
  %z = or i32 %y, %x
  ret i32 %z
}
=>
define i32 @test20(i32 %x) {
%0:
  ret i32 %x
}
Transformation seems to be correct!


----------------------------------------
define i32 @test21(i32 %tmp.1) {
%0:
  %tmp.1.mask1 = add i32 %tmp.1, 2
  %tmp.3 = and i32 %tmp.1.mask1, 4294967294
  %tmp.5 = and i32 %tmp.1, 1
  %tmp.6 = or i32 %tmp.5, %tmp.3
  ret i32 %tmp.6
}
=>
define i32 @test21(i32 %tmp.1) {
%0:
  %tmp.1.mask1 = add i32 %tmp.1, 2
  ret i32 %tmp.1.mask1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @test22(i32 %B) {
%0:
  %ELIM41 = and i32 %B, 1
  %ELIM7 = and i32 %B, 4294967294
  %ELIM5 = or i32 %ELIM41, %ELIM7
  ret i32 %ELIM5
}
=>
define i32 @test22(i32 %B) {
%0:
  ret i32 %B
}
Transformation seems to be correct!


----------------------------------------
define i16 @test23(i16 %A) {
%0:
  %B = lshr i16 %A, 1
  %C = or i16 %B, 32768
  %D = xor i16 %C, 8193
  ret i16 %D
}
=>
define i16 @test23(i16 %A) {
%0:
  %B = lshr i16 %A, 1
  %D = xor i16 %B, 40961
  ret i16 %D
}
Transformation seems to be correct!


----------------------------------------
define <2 x i16> @test23vec(<2 x i16> %A) {
%0:
  %B = lshr <2 x i16> %A, { 1, 1 }
  %C = or <2 x i16> %B, { 32768, 32768 }
  %D = xor <2 x i16> %C, { 8193, 8193 }
  ret <2 x i16> %D
}
=>
define <2 x i16> @test23vec(<2 x i16> %A) {
%0:
  %B = lshr <2 x i16> %A, { 1, 1 }
  %D = xor <2 x i16> %B, { 40961, 40961 }
  ret <2 x i16> %D
}
Transformation seems to be correct!


----------------------------------------
define i1 @test25(i32 %A, i32 %B) {
%0:
  %C = icmp eq i32 %A, 0
  %D = icmp eq i32 %B, 57
  %E = or i1 %C, %D
  %F = xor i1 %E, 1
  ret i1 %F
}
=>
define i1 @test25(i32 %A, i32 %B) {
%0:
  %C = icmp ne i32 %A, 0
  %D = icmp ne i32 %B, 57
  %F = and i1 %C, %D
  ret i1 %F
}
Transformation seems to be correct!


----------------------------------------
define i1 @test26(i32 %A, i32 %B) {
%0:
  %C1 = icmp eq i32 %A, 0
  %C2 = icmp eq i32 %B, 0
  %D = and i1 %C1, %C2
  ret i1 %D
}
=>
define i1 @test26(i32 %A, i32 %B) {
%0:
  %1 = or i32 %A, %B
  %2 = icmp eq i32 %1, 0
  ret i1 %2
}
Transformation seems to be correct!


----------------------------------------
define i1 @test27(* %A, * %B) {
%0:
  %C1 = ptrtoint * %A to i32
  %C2 = ptrtoint * %B to i32
  %D = or i32 %C1, %C2
  %E = icmp eq i32 %D, 0
  ret i1 %E
}
=>
define i1 @test27(* %A, * %B) {
%0:
  %1 = icmp eq * %A, null
  %2 = icmp eq * %B, null
  %E = and i1 %1, %2
  ret i1 %E
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
* %A = null
* %B = pointer(non-local, block_id=2, offset=-1073741888)

Source:
i32 %C1 = #x00000000 (0)
i32 %C2 = #x00000000 (0)
i32 %D = #x00000000 (0)
i1 %E = #x1 (1)

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 32	alloc type: 0	address: 0
Block 1 >	size: 557113	align: 2	alloc type: 0	address: 538714624
Block 2 >	size: 1073741759	align: 2	alloc type: 0	address: 1073741888

Target:
i1 %1 = #x1 (1)
i1 %2 = #x0 (0)
i1 %E = #x0 (0)
Source value: #x1 (1)
Target value: #x0 (0)


------------------- SMT STATS -------------------
Num queries: 31
Num invalid: 0
Num skips:   0
Num trivial: 63 (67.0%)
Num timeout: 1 (3.2%)
Num errors:  0 (0.0%)
Num SAT:     17 (54.8%)
Num UNSAT:   13 (41.9%)

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/scripts/opt-alive.sh -instcombine -S
+ /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/or.ll

Alive2: Transform doesn't verify; aborting!
FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/or.ll

<-- Back