Test Failure: Transforms/InstCombine/sub-minmax.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define i32 @max_na_b_minux_na(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, %B
  %l1 = select i1 %l0, i32 %not, i32 %B
  %x = sub i32 %l1, %not
  ret i32 %x
}
=>
define i32 @max_na_b_minux_na(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = usub_sat i32 %not, %B
  %x = sub i32 0, %1
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @na_minus_max_na_b(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, %B
  %l1 = select i1 %l0, i32 %not, i32 %B
  %x = sub i32 %not, %l1
  ret i32 %x
}
=>
define i32 @na_minus_max_na_b(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = usub_sat i32 %not, %B
  ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i5 @sub_umin(i5 %a, i5 %b) {
%0:
  %umin = umin i5 %a, %b
  %r = sub i5 %a, %umin
  ret i5 %r
}
=>
define i5 @sub_umin(i5 %a, i5 %b) {
%0:
  %1 = usub_sat i5 %a, %b
  ret i5 %1
}
Transformation seems to be correct!


----------------------------------------
define <2 x i8> @sub_umin_commute_vec(<2 x i8> %a, <2 x i8> %b) {
%0:
  %umin = umin <2 x i8> %b, %a
  %r = sub <2 x i8> %b, %umin
  ret <2 x i8> %r
}
=>
define <2 x i8> @sub_umin_commute_vec(<2 x i8> %a, <2 x i8> %b) {
%0:
  %1 = usub_sat <2 x i8> %b, %a
  ret <2 x i8> %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i5 @sub_umin_uses(i5 %a, i5 %b, ptr %p) {
%0:
  %umin = umin i5 %a, %b
  store i5 %umin, ptr %p, align 1
  %r = sub i5 %a, %umin
  ret i5 %r
}
=>
define i5 @sub_umin_uses(i5 %a, i5 %b, ptr %p) {
%0:
  %umin = umin i5 %a, %b
  store i5 %umin, ptr %p, align 1
  %r = sub i5 %a, %umin
  ret i5 %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i5 @sub_umin_no_common_op(i5 %a, i5 %b, i5 %c) {
%0:
  %umin = umin i5 %a, %b
  %r = sub i5 %c, %umin
  ret i5 %r
}
=>
define i5 @sub_umin_no_common_op(i5 %a, i5 %b, i5 %c) {
%0:
  %umin = umin i5 %a, %b
  %r = sub i5 %c, %umin
  ret i5 %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i32 @max_b_na_minus_na(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ugt i32 %not, %B
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %l1, %not
  ret i32 %x
}
=>
define i32 @max_b_na_minus_na(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = usub_sat i32 %not, %B
  %x = sub i32 0, %1
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @na_minus_max_b_na(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ugt i32 %not, %B
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %not, %l1
  ret i32 %x
}
=>
define i32 @na_minus_max_b_na(i32 %A, i32 %B) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = usub_sat i32 %not, %B
  ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @max_na_bi_minux_na(i32 %A, i32 %Bi) {
%0:
  %B = xor i32 %Bi, 4294967295
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, %B
  %l1 = select i1 %l0, i32 %not, i32 %B
  %x = sub i32 %l1, %not
  ret i32 %x
}
=>
define i32 @max_na_bi_minux_na(i32 %A, i32 %Bi) {
%0:
  %1 = usub_sat i32 %Bi, %A
  %x = sub i32 0, %1
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @na_minus_max_na_bi(i32 %A, i32 %Bi) {
%0:
  %B = xor i32 %Bi, 4294967295
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, %B
  %l1 = select i1 %l0, i32 %not, i32 %B
  %x = sub i32 %not, %l1
  ret i32 %x
}
=>
define i32 @na_minus_max_na_bi(i32 %A, i32 %Bi) {
%0:
  %1 = usub_sat i32 %Bi, %A
  ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @max_bi_na_minus_na(i32 %A, i32 %Bi) {
%0:
  %B = xor i32 %Bi, 4294967295
  %not = xor i32 %A, 4294967295
  %l0 = icmp ugt i32 %not, %B
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %l1, %not
  ret i32 %x
}
=>
define i32 @max_bi_na_minus_na(i32 %A, i32 %Bi) {
%0:
  %1 = usub_sat i32 %Bi, %A
  %x = sub i32 0, %1
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @na_minus_max_bi_na(i32 %A, i32 %Bi) {
%0:
  %B = xor i32 %Bi, 4294967295
  %not = xor i32 %A, 4294967295
  %l0 = icmp ugt i32 %not, %B
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %not, %l1
  ret i32 %x
}
=>
define i32 @na_minus_max_bi_na(i32 %A, i32 %Bi) {
%0:
  %1 = usub_sat i32 %Bi, %A
  ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @max_na_bi_minux_na_use(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, 31
  %l1 = select i1 %l0, i32 %not, i32 31
  %x = sub i32 %l1, %not
  call void @use32(i32 %l1)
  ret i32 %x
}
=>
define i32 @max_na_bi_minux_na_use(i32 %A, i32 %Bi) {
%0:
  %1 = umax i32 %A, 4294967264
  %2 = xor i32 %1, 4294967295
  %x = sub i32 %A, %1
  call void @use32(i32 %2)
  ret i32 %x
}
Transformation seems to be correct!


----------------------------------------
define i32 @na_minus_max_na_bi_use(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, 31
  %l1 = select i1 %l0, i32 %not, i32 31
  %x = sub i32 %not, %l1
  call void @use32(i32 %l1)
  ret i32 %x
}
=>
define i32 @na_minus_max_na_bi_use(i32 %A, i32 %Bi) {
%0:
  %1 = umax i32 %A, 4294967264
  %2 = xor i32 %1, 4294967295
  %x = sub i32 %1, %A
  call void @use32(i32 %2)
  ret i32 %x
}
Transformation seems to be correct!


----------------------------------------
define i32 @max_bi_na_minus_na_use(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %B = xor i32 %Bi, 4294967295
  %l0 = icmp ult i32 %B, %not
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %l1, %not
  call void @use32(i32 %l1)
  ret i32 %x
}
=>
define i32 @max_bi_na_minus_na_use(i32 %A, i32 %Bi) {
%0:
  %1 = umax i32 %Bi, %A
  %2 = xor i32 %1, 4294967295
  %x = sub i32 %A, %1
  call void @use32(i32 %2)
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @na_minus_max_bi_na_use(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %B = xor i32 %Bi, 4294967295
  %l0 = icmp ult i32 %B, %not
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %not, %l1
  call void @use32(i32 %l1)
  ret i32 %x
}
=>
define i32 @na_minus_max_bi_na_use(i32 %A, i32 %Bi) {
%0:
  %1 = umax i32 %Bi, %A
  %2 = xor i32 %1, 4294967295
  %x = sub i32 %1, %A
  call void @use32(i32 %2)
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @max_na_bi_minux_na_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, 31
  %l1 = select i1 %l0, i32 %not, i32 31
  %x = sub i32 %l1, %not
  call void @use32(i32 %l1)
  call void @use32(i32 %not)
  ret i32 %x
}
=>
define i32 @max_na_bi_minux_na_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = umin i32 %not, 31
  %x = sub i32 %1, %not
  call void @use32(i32 %1)
  call void @use32(i32 %not)
  ret i32 %x
}
Transformation seems to be correct!


----------------------------------------
define i32 @na_minus_max_na_bi_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %l0 = icmp ult i32 %not, 31
  %l1 = select i1 %l0, i32 %not, i32 31
  %x = sub i32 %not, %l1
  call void @use32(i32 %l1)
  call void @use32(i32 %not)
  ret i32 %x
}
=>
define i32 @na_minus_max_na_bi_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = umin i32 %not, 31
  %x = sub i32 %not, %1
  call void @use32(i32 %1)
  call void @use32(i32 %not)
  ret i32 %x
}
Transformation seems to be correct!


----------------------------------------
define i32 @max_bi_na_minus_na_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %B = xor i32 %Bi, 4294967295
  %l0 = icmp ult i32 %B, %not
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %l1, %not
  call void @use32(i32 %l1)
  call void @use32(i32 %not)
  ret i32 %x
}
=>
define i32 @max_bi_na_minus_na_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = umax i32 %Bi, %A
  %2 = xor i32 %1, 4294967295
  %x = sub i32 %A, %1
  call void @use32(i32 %2)
  call void @use32(i32 %not)
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @na_minus_max_bi_na_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %B = xor i32 %Bi, 4294967295
  %l0 = icmp ult i32 %B, %not
  %l1 = select i1 %l0, i32 %B, i32 %not
  %x = sub i32 %not, %l1
  call void @use32(i32 %l1)
  call void @use32(i32 %not)
  ret i32 %x
}
=>
define i32 @na_minus_max_bi_na_use2(i32 %A, i32 %Bi) {
%0:
  %not = xor i32 %A, 4294967295
  %1 = umax i32 %Bi, %A
  %2 = xor i32 %1, 4294967295
  %x = sub i32 %1, %A
  call void @use32(i32 %2)
  call void @use32(i32 %not)
  ret i32 %x
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umin_not_sub(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  %ny = xor i8 %y, 255
  %cmpxy = icmp ult i8 %nx, %ny
  %minxy = select i1 %cmpxy, i8 %nx, i8 %ny
  %subx = sub i8 %nx, %minxy
  %suby = sub i8 %ny, %minxy
  call void @use8(i8 %subx)
  call void @use8(i8 %suby)
  ret i8 %minxy
}
=>
define i8 @umin_not_sub(i8 %x, i8 %y) {
%0:
  %1 = umax i8 %x, %y
  %2 = xor i8 %1, 255
  %subx = sub i8 %1, %x
  %suby = sub i8 %1, %y
  call void @use8(i8 %subx)
  call void @use8(i8 %suby)
  ret i8 %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umin_not_sub_rev(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  %ny = xor i8 %y, 255
  %cmpxy = icmp ult i8 %nx, %ny
  %minxy = select i1 %cmpxy, i8 %nx, i8 %ny
  %subx = sub i8 %minxy, %nx
  %suby = sub i8 %minxy, %ny
  call void @use8(i8 %subx)
  call void @use8(i8 %suby)
  ret i8 %minxy
}
=>
define i8 @umin_not_sub_rev(i8 %x, i8 %y) {
%0:
  %1 = umax i8 %x, %y
  %2 = xor i8 %1, 255
  %subx = sub i8 %x, %1
  %suby = sub i8 %y, %1
  call void @use8(i8 %subx)
  call void @use8(i8 %suby)
  ret i8 %2
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define void @umin3_not_all_ops_extra_uses_invert_subs(i8 %x, i8 %y, i8 %z) {
%0:
  %xn = xor i8 %x, 255
  %yn = xor i8 %y, 255
  %zn = xor i8 %z, 255
  %cmpxz = icmp ult i8 %xn, %zn
  %minxz = select i1 %cmpxz, i8 %xn, i8 %zn
  %cmpxyz = icmp ult i8 %minxz, %yn
  %minxyz = select i1 %cmpxyz, i8 %minxz, i8 %yn
  %xmin = sub i8 %xn, %minxyz
  %ymin = sub i8 %yn, %minxyz
  %zmin = sub i8 %zn, %minxyz
  call void @use8(i8 %minxyz)
  call void @use8(i8 %xmin)
  call void @use8(i8 %ymin)
  call void @use8(i8 %zmin)
  ret void
}
=>
define void @umin3_not_all_ops_extra_uses_invert_subs(i8 %x, i8 %y, i8 %z) {
%0:
  %1 = umax i8 %x, %z
  %2 = umax i8 %y, %1
  %3 = xor i8 %2, 255
  %xmin = sub i8 %2, %x
  %ymin = sub i8 %2, %y
  %zmin = sub i8 %2, %z
  call void @use8(i8 %3)
  call void @use8(i8 %xmin)
  call void @use8(i8 %ymin)
  call void @use8(i8 %zmin)
  ret void
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umin_not_sub_intrinsic_commute0(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %m = umin i8 %nx, %ny
  call void @use8(i8 %m)
  %subx = sub i8 %nx, %m
  ret i8 %subx
}
=>
define i8 @umin_not_sub_intrinsic_commute0(i8 %x, i8 %y) {
%0:
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %1 = umax i8 %x, %y
  %m = xor i8 %1, 255
  call void @use8(i8 %m)
  %subx = sub i8 %1, %x
  ret i8 %subx
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umax_not_sub_intrinsic_commute1(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %m = umax i8 %ny, %nx
  call void @use8(i8 %m)
  %subx = sub i8 %nx, %m
  ret i8 %subx
}
=>
define i8 @umax_not_sub_intrinsic_commute1(i8 %x, i8 %y) {
%0:
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %1 = umin i8 %x, %y
  %m = xor i8 %1, 255
  call void @use8(i8 %m)
  %subx = sub i8 %1, %x
  ret i8 %subx
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @smin_not_sub_intrinsic_commute2(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %m = smin i8 %nx, %ny
  call void @use8(i8 %m)
  %subx = sub i8 %m, %nx
  ret i8 %subx
}
=>
define i8 @smin_not_sub_intrinsic_commute2(i8 %x, i8 %y) {
%0:
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %1 = smax i8 %x, %y
  %m = xor i8 %1, 255
  call void @use8(i8 %m)
  %subx = sub i8 %x, %1
  ret i8 %subx
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @smax_not_sub_intrinsic_commute3(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %m = smax i8 %ny, %nx
  call void @use8(i8 %m)
  %subx = sub i8 %m, %nx
  ret i8 %subx
}
=>
define i8 @smax_not_sub_intrinsic_commute3(i8 %x, i8 %y) {
%0:
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %1 = smin i8 %x, %y
  %m = xor i8 %1, 255
  call void @use8(i8 %m)
  %subx = sub i8 %x, %1
  ret i8 %subx
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umin_not_sub_intrinsic_uses(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  call void @use8(i8 %nx)
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %m = umin i8 %nx, %ny
  call void @use8(i8 %m)
  %subx = sub i8 %nx, %m
  ret i8 %subx
}
=>
define i8 @umin_not_sub_intrinsic_uses(i8 %x, i8 %y) {
%0:
  %nx = xor i8 %x, 255
  call void @use8(i8 %nx)
  %ny = xor i8 %y, 255
  call void @use8(i8 %ny)
  %m = umin i8 %nx, %ny
  call void @use8(i8 %m)
  %subx = sub i8 %nx, %m
  ret i8 %subx
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @umax_sub_op0(i8 %x, i8 %y) {
%0:
  %u = umax i8 %y, %x
  %r = sub i8 %u, %y
  ret i8 %r
}
=>
define i8 @umax_sub_op0(i8 %x, i8 %y) {
%0:
  %1 = usub_sat i8 %x, %y
  ret i8 %1
}
Transformation seems to be correct!


----------------------------------------
define <2 x i8> @umax_sub_op0_vec_commute(<2 x i8> %x, <2 x i8> %y) {
%0:
  %u = umax <2 x i8> %x, %y
  %r = sub <2 x i8> %u, %y
  ret <2 x i8> %r
}
=>
define <2 x i8> @umax_sub_op0_vec_commute(<2 x i8> %x, <2 x i8> %y) {
%0:
  %1 = usub_sat <2 x i8> %x, %y
  ret <2 x i8> %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umax_sub_op0_use(i8 %x, i8 %y) {
%0:
  %u = umax i8 %x, %y
  call void @use8(i8 %u)
  %r = sub i8 %u, %y
  ret i8 %r
}
=>
define i8 @umax_sub_op0_use(i8 %x, i8 %y) {
%0:
  %u = umax i8 %x, %y
  call void @use8(i8 %u)
  %r = sub i8 %u, %y
  ret i8 %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @umax_sub_op1(i8 %x, i8 %y) {
%0:
  %u = umax i8 %x, %y
  %r = sub i8 %y, %u
  ret i8 %r
}
=>
define i8 @umax_sub_op1(i8 %x, i8 %y) {
%0:
  %1 = usub_sat i8 %x, %y
  %r = sub i8 0, %1
  ret i8 %r
}
Transformation seems to be correct!


----------------------------------------
define <2 x i8> @umax_sub_op1_vec_commute(<2 x i8> %x, <2 x i8> %y) {
%0:
  %u = umax <2 x i8> %y, %x
  %r = sub <2 x i8> %y, %u
  ret <2 x i8> %r
}
=>
define <2 x i8> @umax_sub_op1_vec_commute(<2 x i8> %x, <2 x i8> %y) {
%0:
  %1 = usub_sat <2 x i8> %x, %y
  %r = sub <2 x i8> { 0, 0 }, %1
  ret <2 x i8> %r
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @umax_sub_op1_use(i8 %x, i8 %y) {
%0:
  %u = umax i8 %x, %y
  call void @use8(i8 %u)
  %r = sub i8 %y, %u
  ret i8 %r
}
=>
define i8 @umax_sub_op1_use(i8 %x, i8 %y) {
%0:
  %u = umax i8 %x, %y
  call void @use8(i8 %u)
  %r = sub i8 %y, %u
  ret i8 %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @umin_sub_op1(i8 %x, i8 %y) {
%0:
  %u = umin i8 %y, %x
  %r = sub i8 %y, %u
  ret i8 %r
}
=>
define i8 @umin_sub_op1(i8 %x, i8 %y) {
%0:
  %1 = usub_sat i8 %y, %x
  ret i8 %1
}
Transformation seems to be correct!


----------------------------------------
define i8 @umin_sub_op1_commute(i8 %x, i8 %y) {
%0:
  %u = umin i8 %x, %y
  %r = sub i8 %y, %u
  ret i8 %r
}
=>
define i8 @umin_sub_op1_commute(i8 %x, i8 %y) {
%0:
  %1 = usub_sat i8 %y, %x
  ret i8 %1
}
Transformation seems to be correct!


----------------------------------------
define i8 @umin_sub_op0(i8 %x, i8 %y) {
%0:
  %u = umin i8 %y, %x
  %r = sub i8 %u, %y
  ret i8 %r
}
=>
define i8 @umin_sub_op0(i8 %x, i8 %y) {
%0:
  %1 = usub_sat i8 %y, %x
  %r = sub i8 0, %1
  ret i8 %r
}
Transformation seems to be correct!


----------------------------------------
define i8 @umin_sub_op0_commute(i8 %x, i8 %y) {
%0:
  %u = umin i8 %x, %y
  %r = sub i8 %u, %y
  ret i8 %r
}
=>
define i8 @umin_sub_op0_commute(i8 %x, i8 %y) {
%0:
  %1 = usub_sat i8 %y, %x
  %r = sub i8 0, %1
  ret i8 %r
}
Transformation seems to be correct!


----------------------------------------
define i8 @umin_sub_op1_use(i8 %x, i8 %y) {
%0:
  %u = umin i8 %y, %x
  call void @use8(i8 %u)
  %r = sub i8 %y, %u
  ret i8 %r
}
=>
define i8 @umin_sub_op1_use(i8 %x, i8 %y) {
%0:
  %u = umin i8 %y, %x
  call void @use8(i8 %u)
  %r = sub i8 %y, %u
  ret i8 %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @umin_sub_op0_use(i8 %x, i8 %y) {
%0:
  %u = umin i8 %y, %x
  call void @use8(i8 %u)
  %r = sub i8 %u, %y
  ret i8 %r
}
=>
define i8 @umin_sub_op0_use(i8 %x, i8 %y) {
%0:
  %u = umin i8 %y, %x
  call void @use8(i8 %u)
  %r = sub i8 %u, %y
  ret i8 %r
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @diff_add_smin(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = smin i8 %x, %y
  %s = sub i8 %a, %m
  ret i8 %s
}
=>
define i8 @diff_add_smin(i8 %x, i8 %y) {
%0:
  %1 = smax i8 %x, %y
  ret i8 %1
}
Transformation seems to be correct!


----------------------------------------
define i8 @diff_add_smax(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = smax i8 %y, %x
  %s = sub i8 %a, %m
  ret i8 %s
}
=>
define i8 @diff_add_smax(i8 %x, i8 %y) {
%0:
  %1 = smin i8 %y, %x
  ret i8 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @diff_add_umin(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = umin i8 %x, %y
  %s = sub i8 %a, %m
  ret i8 %s
}
=>
define i8 @diff_add_umin(i8 %x, i8 %y) {
%0:
  %1 = umax i8 %x, %y
  ret i8 %1
}
Transformation seems to be correct!


----------------------------------------
define i8 @diff_add_umax(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = umax i8 %y, %x
  %s = sub i8 %a, %m
  ret i8 %s
}
=>
define i8 @diff_add_umax(i8 %x, i8 %y) {
%0:
  %1 = umin i8 %y, %x
  ret i8 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @diff_add_smin_use(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = smin i8 %x, %y
  %s = sub i8 %a, %m
  call void @use8(i8 %m)
  ret i8 %s
}
=>
define i8 @diff_add_smin_use(i8 %x, i8 %y) {
%0:
  %m = smin i8 %x, %y
  %1 = smax i8 %x, %y
  call void @use8(i8 %m)
  ret i8 %1
}
Transformation seems to be correct!


----------------------------------------
define i8 @diff_add_use_smax(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = smax i8 %y, %x
  %s = sub i8 %a, %m
  call void @use8(i8 %a)
  ret i8 %s
}
=>
define i8 @diff_add_use_smax(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %1 = smin i8 %y, %x
  call void @use8(i8 %a)
  ret i8 %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @diff_add_use_umin_use(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = umin i8 %x, %y
  %s = sub i8 %a, %m
  call void @use8(i8 %a)
  call void @use8(i8 %m)
  ret i8 %s
}
=>
define i8 @diff_add_use_umin_use(i8 %x, i8 %y) {
%0:
  %a = add i8 %x, %y
  %m = umin i8 %x, %y
  %s = sub i8 %a, %m
  call void @use8(i8 %a)
  call void @use8(i8 %m)
  ret i8 %s
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define i8 @sub_add_umin(i8 %x, i8 %y, i8 %z) {
%0:
  %a = add i8 %x, %y
  %m = umin i8 %y, %z
  %s = sub i8 %a, %m
  ret i8 %s
}
=>
define i8 @sub_add_umin(i8 %x, i8 %y, i8 %z) {
%0:
  %1 = usub_sat i8 %y, %z
  %s = add i8 %1, %x
  ret i8 %s
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i8 @sub_add_umin_commute_umin(i8 %x, i8 %y, i8 %z) {
%0:
  %a = add i8 %x, %y
  %m = umin i8 %z, %y
  %s = sub i8 %a, %m
  ret i8 %s
}
=>
define i8 @sub_add_umin_commute_umin(i8 %x, i8 %y, i8 %z) {
%0:
  %1 = usub_sat i8 %z, %y
  %s = add i8 %1, %x
  ret i8 %s
}
Transformation doesn't verify!
ERROR: Target's return value is more undefined

Example:
i8 %x = any
i8 %y = #x00 (0)
i8 %z = undef

Source:
i8 %a = any
i8 %m = #x00 (0)	[based on undef value]
i8 %s = any

Target:
i8 %1 = #x8b (139, -117)
i8 %s = any
Source value: any
Target value: any


------------------- SMT STATS -------------------
Num queries: 235
Num invalid: 0
Num skips:   0
Num trivial: 75 (24.2%)
Num timeout: 26 (11.1%)
Num errors:  0 (0.0%)
Num SAT:     125 (53.2%)
Num UNSAT:   84 (35.7%)
Alive2: Transform doesn't verify; aborting!

stderr:

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

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

<-- Back