Test Failure: Transforms/InstCombine/icmp-vec.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define <2 x i1> @sge(<2 x i8> %x) {
%0:
  %cmp = icmp sge <2 x i8> %x, { 129, 127 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @sge(<2 x i8> %x) {
%0:
  %cmp = icmp sgt <2 x i8> %x, { 128, 126 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @uge(<2 x i8> %x) {
%0:
  %cmp = icmp uge <2 x i8> %x, { 255, 1 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @uge(<2 x i8> %x) {
%0:
  %cmp = icmp ugt <2 x i8> %x, { 254, 0 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @sle(<2 x i8> %x) {
%0:
  %cmp = icmp sle <2 x i8> %x, { 126, 128 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @sle(<2 x i8> %x) {
%0:
  %cmp = icmp slt <2 x i8> %x, { 127, 129 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @ule(<2 x i8> %x) {
%0:
  %cmp = icmp ule <2 x i8> %x, { 254, 0 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @ule(<2 x i8> %x) {
%0:
  %cmp = icmp ult <2 x i8> %x, { 255, 1 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @ult_min_signed_value(<2 x i8> %x) {
%0:
  %cmp = icmp ult <2 x i8> %x, { 128, 128 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @ult_min_signed_value(<2 x i8> %x) {
%0:
  %cmp = icmp sgt <2 x i8> %x, { 255, 255 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @sge_zero(<2 x i8> %x) {
%0:
  %cmp = icmp sge <2 x i8> %x, { 0, 0 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @sge_zero(<2 x i8> %x) {
%0:
  %cmp = icmp sgt <2 x i8> %x, { 255, 255 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @uge_zero(<2 x i8> %x) {
%0:
  %cmp = icmp uge <2 x i8> %x, { 0, 0 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @uge_zero(<2 x i8> %x) {
%0:
  ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @sle_zero(<2 x i8> %x) {
%0:
  %cmp = icmp sle <2 x i8> %x, { 0, 0 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @sle_zero(<2 x i8> %x) {
%0:
  %cmp = icmp slt <2 x i8> %x, { 1, 1 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @ule_zero(<2 x i8> %x) {
%0:
  %cmp = icmp ule <2 x i8> %x, { 0, 0 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @ule_zero(<2 x i8> %x) {
%0:
  %cmp = icmp eq <2 x i8> %x, { 0, 0 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <3 x i1> @sge_weird(<3 x i3> %x) {
%0:
  %cmp = icmp sge <3 x i3> %x, { 5, 3, 0 }
  ret <3 x i1> %cmp
}
=>
define <3 x i1> @sge_weird(<3 x i3> %x) {
%0:
  %cmp = icmp sgt <3 x i3> %x, { 4, 2, 7 }
  ret <3 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <3 x i1> @uge_weird(<3 x i3> %x) {
%0:
  %cmp = icmp uge <3 x i3> %x, { 7, 1, 2 }
  ret <3 x i1> %cmp
}
=>
define <3 x i1> @uge_weird(<3 x i3> %x) {
%0:
  %cmp = icmp ugt <3 x i3> %x, { 6, 0, 1 }
  ret <3 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <3 x i1> @sle_weird(<3 x i3> %x) {
%0:
  %cmp = icmp sle <3 x i3> %x, { 2, 4, 0 }
  ret <3 x i1> %cmp
}
=>
define <3 x i1> @sle_weird(<3 x i3> %x) {
%0:
  %cmp = icmp slt <3 x i3> %x, { 3, 5, 1 }
  ret <3 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <3 x i1> @ule_weird(<3 x i3> %x) {
%0:
  %cmp = icmp ule <3 x i3> %x, { 6, 0, 1 }
  ret <3 x i1> %cmp
}
=>
define <3 x i1> @ule_weird(<3 x i3> %x) {
%0:
  %cmp = icmp ult <3 x i3> %x, { 7, 1, 2 }
  ret <3 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @sge_min(<2 x i3> %x) {
%0:
  %cmp = icmp sge <2 x i3> %x, { 4, 1 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @sge_min(<2 x i3> %x) {
%0:
  %cmp = icmp sge <2 x i3> %x, { 4, 1 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i1> @uge_min(<2 x i3> %x) {
%0:
  %cmp = icmp uge <2 x i3> %x, { 1, 0 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @uge_min(<2 x i3> %x) {
%0:
  %cmp = icmp uge <2 x i3> %x, { 1, 0 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i1> @sle_max(<2 x i3> %x) {
%0:
  %cmp = icmp sle <2 x i3> %x, { 1, 3 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @sle_max(<2 x i3> %x) {
%0:
  %cmp = icmp sle <2 x i3> %x, { 1, 3 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i1> @ule_max(<2 x i3> %x) {
%0:
  %cmp = icmp ule <2 x i3> %x, { 7, 1 }
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @ule_max(<2 x i3> %x) {
%0:
  %cmp = icmp ule <2 x i3> %x, { 7, 1 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <2 x i1> @PR27756_1(<2 x i8> %a) {
%0:
  %__constexpr_0 = bitcast <2 x i4> { 1, 2 } to i8
  %__copy_0 = <2 x i8> { %__constexpr_0, 0 }
  %cmp = icmp sle <2 x i8> %a, %__copy_0
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @PR27756_1(<2 x i8> %a) {
%0:
  %cmp = icmp slt <2 x i8> %a, { 34, 1 }
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <3 x i1> @PR27756_2(<3 x i8> %a) {
%0:
  %cmp = icmp sle <3 x i8> %a, { 42, undef, 0 }
  ret <3 x i1> %cmp
}
=>
define <3 x i1> @PR27756_2(<3 x i8> %a) {
%0:
  %cmp = icmp slt <3 x i8> %a, { 43, 43, 1 }
  ret <3 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <3 x i1> @PR27756_3(<3 x i8> %a) {
%0:
  %cmp = icmp sge <3 x i8> %a, { undef, 1, 42 }
  ret <3 x i1> %cmp
}
=>
define <3 x i1> @PR27756_3(<3 x i8> %a) {
%0:
  %cmp = icmp sgt <3 x i8> %a, { 0, 0, 41 }
  ret <3 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
@someglobal = global 4 bytes, align 4

define <2 x i1> @PR27786(<2 x i8> %a) {
%0:
  %__constexpr_1 = ptrtoint * @someglobal to i16
  %__constexpr_0 = bitcast i16 %__constexpr_1 to <2 x i8>
  %cmp = icmp sle <2 x i8> %a, %__constexpr_0
  ret <2 x i1> %cmp
}
=>
@someglobal = global 4 bytes, align 4

define <2 x i1> @PR27786(<2 x i8> %a) {
%0:
  %__constexpr_1 = ptrtoint * @someglobal to i16
  %__constexpr_0 = bitcast i16 %__constexpr_1 to <2 x i8>
  %cmp = icmp sle <2 x i8> %a, %__constexpr_0
  ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x i1> @same_shuffle_inputs_icmp(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufx = shufflevector <4 x i8> %x, <4 x i8> undef, 3, 3, 2, 0
  %shufy = shufflevector <4 x i8> %y, <4 x i8> undef, 3, 3, 2, 0
  %cmp = icmp sgt <4 x i8> %shufx, %shufy
  ret <4 x i1> %cmp
}
=>
define <4 x i1> @same_shuffle_inputs_icmp(<4 x i8> %x, <4 x i8> %y) {
%0:
  %1 = icmp sgt <4 x i8> %x, %y
  %cmp = shufflevector <4 x i1> %1, <4 x i1> undef, 3, 3, 2, 0
  ret <4 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <5 x i1> @same_shuffle_inputs_fcmp(<4 x float> %x, <4 x float> %y) {
%0:
  %shufx = shufflevector <4 x float> %x, <4 x float> undef, 0, 1, 3, 2, 0
  %shufy = shufflevector <4 x float> %y, <4 x float> undef, 0, 1, 3, 2, 0
  %cmp = fcmp oeq <5 x float> %shufx, %shufy
  ret <5 x i1> %cmp
}
=>
define <5 x i1> @same_shuffle_inputs_fcmp(<4 x float> %x, <4 x float> %y) {
%0:
  %1 = fcmp oeq <4 x float> %x, %y
  %cmp = shufflevector <4 x i1> %1, <4 x i1> undef, 0, 1, 3, 2, 0
  ret <5 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define <4 x i1> @same_shuffle_inputs_icmp_extra_use1(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufx = shufflevector <4 x i8> %x, <4 x i8> undef, 3, 3, 3, 3
  %shufy = shufflevector <4 x i8> %y, <4 x i8> undef, 3, 3, 3, 3
  %cmp = icmp ugt <4 x i8> %shufx, %shufy
  call void @use_v4i8(<4 x i8> %shufx)
  ret <4 x i1> %cmp
}
=>
define <4 x i1> @same_shuffle_inputs_icmp_extra_use1(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufx = shufflevector <4 x i8> %x, <4 x i8> undef, 3, 3, 3, 3
  %1 = icmp ugt <4 x i8> %x, %y
  %cmp = shufflevector <4 x i1> %1, <4 x i1> undef, 3, 3, 3, 3
  call void @use_v4i8(<4 x i8> %shufx)
  ret <4 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @same_shuffle_inputs_icmp_extra_use2(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufx = shufflevector <4 x i8> %x, <4 x i8> undef, 3, 2
  %shufy = shufflevector <4 x i8> %y, <4 x i8> undef, 3, 2
  %cmp = icmp eq <2 x i8> %shufx, %shufy
  call void @use_v2i8(<2 x i8> %shufy)
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @same_shuffle_inputs_icmp_extra_use2(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufy = shufflevector <4 x i8> %y, <4 x i8> undef, 3, 2
  %1 = icmp eq <4 x i8> %x, %y
  %cmp = shufflevector <4 x i1> %1, <4 x i1> undef, 3, 2
  call void @use_v2i8(<2 x i8> %shufy)
  ret <2 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <2 x i1> @same_shuffle_inputs_icmp_extra_use3(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufx = shufflevector <4 x i8> %x, <4 x i8> undef, 0, 0
  %shufy = shufflevector <4 x i8> %y, <4 x i8> undef, 0, 0
  %cmp = icmp eq <2 x i8> %shufx, %shufy
  call void @use_v2i8(<2 x i8> %shufx)
  call void @use_v2i8(<2 x i8> %shufy)
  ret <2 x i1> %cmp
}
=>
define <2 x i1> @same_shuffle_inputs_icmp_extra_use3(<4 x i8> %x, <4 x i8> %y) {
%0:
  %shufx = shufflevector <4 x i8> %x, <4 x i8> undef, 0, 0
  %shufy = shufflevector <4 x i8> %y, <4 x i8> undef, 0, 0
  %cmp = icmp eq <2 x i8> %shufx, %shufy
  call void @use_v2i8(<2 x i8> %shufx)
  call void @use_v2i8(<2 x i8> %shufy)
  ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x i1> @splat_icmp(<4 x i8> %x) {
%0:
  %splatx = shufflevector <4 x i8> %x, <4 x i8> undef, 3, 3, 3, 3
  %cmp = icmp sgt <4 x i8> %splatx, { 42, 42, 42, 42 }
  ret <4 x i1> %cmp
}
=>
define <4 x i1> @splat_icmp(<4 x i8> %x) {
%0:
  %1 = icmp sgt <4 x i8> %x, { 42, 42, 42, 42 }
  %cmp = shufflevector <4 x i1> %1, <4 x i1> undef, 3, 3, 3, 3
  ret <4 x i1> %cmp
}
Transformation seems to be correct!


----------------------------------------
define <4 x i1> @splat_icmp_undef(<4 x i8> %x) {
%0:
  %splatx = shufflevector <4 x i8> %x, <4 x i8> undef, 2, 4294967295, 4294967295, 2
  %cmp = icmp ult <4 x i8> %splatx, { undef, 42, undef, 42 }
  ret <4 x i1> %cmp
}
=>
define <4 x i1> @splat_icmp_undef(<4 x i8> %x) {
%0:
  %1 = icmp ult <4 x i8> %x, { 42, 42, 42, 42 }
  %cmp = shufflevector <4 x i1> %1, <4 x i1> undef, 2, 2, 2, 2
  ret <4 x i1> %cmp
}
Transformation doesn't verify!
ERROR: Target is more poisonous than source

Example:
<4 x i8> %x = < poison, poison, poison, poison >

Source:
<4 x i8> %splatx = < poison, any, any, poison >
<4 x i1> %cmp = < poison, any, any, poison >

Target:
<4 x i1> %1 = < poison, poison, poison, poison >
<4 x i1> %cmp = < poison, poison, poison, poison >
Source value: < poison, any, any, poison >
Target value: < poison, poison, poison, poison >


------------------- SMT STATS -------------------
Num queries: 76
Num invalid: 0
Num skips:   0
Num trivial: 90 (54.2%)
Num timeout: 2 (2.6%)
Num errors:  0 (0.0%)
Num SAT:     29 (38.2%)
Num UNSAT:   45 (59.2%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/icmp-vec.ll

<-- Back