Test Failure: Transforms/InstCombine/with_overflow.ll

Test source: git

Log:

Source: <stdin>

----------------------------------------
define i8 @uaddtest1(i8 %A, i8 %B) {
%0:
  %x = uadd_overflow {i8, i1} %A, %B
  %y = extractvalue {i8, i1} %x, 0
  ret i8 %y
}
=>
define i8 @uaddtest1(i8 %A, i8 %B) {
%0:
  %y = add i8 %A, %B
  ret i8 %y
}
Transformation seems to be correct!


----------------------------------------
define i8 @uaddtest2(i8 %A, i8 %B, * %overflowPtr) {
%0:
  %and.A = and i8 %A, 127
  %and.B = and i8 %B, 127
  %x = uadd_overflow {i8, i1} %and.A, %and.B
  %y = extractvalue {i8, i1} %x, 0
  %z = extractvalue {i8, i1} %x, 1
  store i1 %z, * %overflowPtr, align 1
  ret i8 %y
}
=>
define i8 @uaddtest2(i8 %A, i8 %B, * %overflowPtr) {
%0:
  %and.A = and i8 %A, 127
  %and.B = and i8 %B, 127
  %x = add nuw i8 %and.A, %and.B
  store i1 0, * %overflowPtr, align 1
  ret i8 %x
}
Transformation seems to be correct!


----------------------------------------
define i8 @uaddtest3(i8 %A, i8 %B, * %overflowPtr) {
%0:
  %or.A = or i8 %A, 128
  %or.B = or i8 %B, 128
  %x = uadd_overflow {i8, i1} %or.A, %or.B
  %y = extractvalue {i8, i1} %x, 0
  %z = extractvalue {i8, i1} %x, 1
  store i1 %z, * %overflowPtr, align 1
  ret i8 %y
}
=>
define i8 @uaddtest3(i8 %A, i8 %B, * %overflowPtr) {
%0:
  %or.A = or i8 %A, 128
  %or.B = or i8 %B, 128
  %x = add i8 %or.A, %or.B
  store i1 1, * %overflowPtr, align 1
  ret i8 %x
}
Transformation seems to be correct!


----------------------------------------
define i8 @uaddtest4(i8 %A, * %overflowPtr) {
%0:
  %x = uadd_overflow {i8, i1} undef, %A
  %y = extractvalue {i8, i1} %x, 0
  %z = extractvalue {i8, i1} %x, 1
  store i1 %z, * %overflowPtr, align 1
  ret i8 %y
}
=>
define i8 @uaddtest4(i8 %A, * %overflowPtr) {
%0:
  store i1 0, * %overflowPtr, align 1
  ret i8 undef
}
Transformation seems to be correct!


----------------------------------------
define i8 @uaddtest5(i8 %A, * %overflowPtr) {
%0:
  %x = uadd_overflow {i8, i1} 0, %A
  %y = extractvalue {i8, i1} %x, 0
  %z = extractvalue {i8, i1} %x, 1
  store i1 %z, * %overflowPtr, align 1
  ret i8 %y
}
=>
define i8 @uaddtest5(i8 %A, * %overflowPtr) {
%0:
  store i1 0, * %overflowPtr, align 1
  ret i8 %A
}
Transformation seems to be correct!


----------------------------------------
define i1 @uaddtest6(i8 %A, i8 %B) {
%0:
  %x = uadd_overflow {i8, i1} %A, 252
  %z = extractvalue {i8, i1} %x, 1
  ret i1 %z
}
=>
define i1 @uaddtest6(i8 %A, i8 %B) {
%0:
  %z = icmp ugt i8 %A, 3
  ret i1 %z
}
Transformation seems to be correct!


----------------------------------------
define i8 @uaddtest7(i8 %A, i8 %B) {
%0:
  %x = uadd_overflow {i8, i1} %A, %B
  %z = extractvalue {i8, i1} %x, 0
  ret i8 %z
}
=>
define i8 @uaddtest7(i8 %A, i8 %B) {
%0:
  %z = add i8 %A, %B
  ret i8 %z
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @saddtest_nsw(i8 %a, i8 %b) {
%0:
  %aa = sext i8 %a to i32
  %bb = sext i8 %b to i32
  %x = sadd_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @saddtest_nsw(i8 %a, i8 %b) {
%0:
  %aa = sext i8 %a to i32
  %bb = sext i8 %b to i32
  %x = add nsw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @uaddtest_nuw(i32 %a, i32 %b) {
%0:
  %aa = and i32 %a, 2147483647
  %bb = and i32 %b, 2147483647
  %x = uadd_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @uaddtest_nuw(i32 %a, i32 %b) {
%0:
  %aa = and i32 %a, 2147483647
  %bb = and i32 %b, 2147483647
  %x = add nuw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define {i32, i1, i24} @ssubtest_nsw(i8 %a, i8 %b) {
%0:
  %aa = sext i8 %a to i32
  %bb = sext i8 %b to i32
  %x = ssub_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @ssubtest_nsw(i8 %a, i8 %b) {
%0:
  %aa = sext i8 %a to i32
  %bb = sext i8 %b to i32
  %x = sub nsw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define {i32, i1, i24} @usubtest_nuw(i32 %a, i32 %b) {
%0:
  %aa = or i32 %a, 2147483648
  %bb = and i32 %b, 2147483647
  %x = usub_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @usubtest_nuw(i32 %a, i32 %b) {
%0:
  %aa = or i32 %a, 2147483648
  %bb = and i32 %b, 2147483647
  %x = sub nuw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define {i32, i1, i24} @smultest1_nsw(i32 %a, i32 %b) {
%0:
  %aa = and i32 %a, 4095
  %bb = and i32 %b, 524287
  %x = smul_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @smultest1_nsw(i32 %a, i32 %b) {
%0:
  %aa = and i32 %a, 4095
  %bb = and i32 %b, 524287
  %x = mul nsw nuw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @smultest2_nsw(i32 %a, i32 %b) {
%0:
  %aa = ashr i32 %a, 16
  %bb = ashr i32 %b, 16
  %x = smul_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @smultest2_nsw(i32 %a, i32 %b) {
%0:
  %aa = ashr i32 %a, 16
  %bb = ashr i32 %b, 16
  %x = mul nsw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define {i32, i1, i24} @smultest3_sw(i32 %a, i32 %b) {
%0:
  %aa = ashr i32 %a, 16
  %bb = ashr i32 %b, 15
  %x = smul_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @smultest3_sw(i32 %a, i32 %b) {
%0:
  %aa = ashr i32 %a, 16
  %bb = ashr i32 %b, 15
  %x = smul_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @umultest_nuw(i32 %a, i32 %b) {
%0:
  %aa = and i32 %a, 65535
  %bb = and i32 %b, 65535
  %x = umul_overflow {i32, i1, i24} %aa, %bb
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @umultest_nuw(i32 %a, i32 %b) {
%0:
  %aa = and i32 %a, 65535
  %bb = and i32 %b, 65535
  %x = mul nuw i32 %aa, %bb
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation seems to be correct!


----------------------------------------
define i8 @umultest1(i8 %A, * %overflowPtr) {
%0:
  %x = umul_overflow {i8, i1} 0, %A
  %y = extractvalue {i8, i1} %x, 0
  %z = extractvalue {i8, i1} %x, 1
  store i1 %z, * %overflowPtr, align 1
  ret i8 %y
}
=>
define i8 @umultest1(i8 %A, * %overflowPtr) {
%0:
  store i1 0, * %overflowPtr, align 1
  ret i8 0
}
Transformation seems to be correct!


----------------------------------------
define i8 @umultest2(i8 %A, * %overflowPtr) {
%0:
  %x = umul_overflow {i8, i1} 1, %A
  %y = extractvalue {i8, i1} %x, 0
  %z = extractvalue {i8, i1} %x, 1
  store i1 %z, * %overflowPtr, align 1
  ret i8 %y
}
=>
define i8 @umultest2(i8 %A, * %overflowPtr) {
%0:
  store i1 0, * %overflowPtr, align 1
  ret i8 %A
}
Transformation seems to be correct!


----------------------------------------
define i32 @umultest3(i32 %n) {
%0:
  %shr = lshr i32 %n, 2
  %mul = umul_overflow {i32, i1, i24} %shr, 3
  %ov = extractvalue {i32, i1, i24} %mul, 1
  %res = extractvalue {i32, i1, i24} %mul, 0
  %ret = select i1 %ov, i32 4294967295, i32 %res
  ret i32 %ret
}
=>
define i32 @umultest3(i32 %n) {
%0:
  %shr = lshr i32 %n, 2
  %mul = mul nuw i32 %shr, 3
  ret i32 %mul
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i32 @umultest4(i32 %n) {
%0:
  %shr = lshr i32 %n, 1
  %mul = umul_overflow {i32, i1, i24} %shr, 4
  %ov = extractvalue {i32, i1, i24} %mul, 1
  %res = extractvalue {i32, i1, i24} %mul, 0
  %ret = select i1 %ov, i32 4294967295, i32 %res
  ret i32 %ret
}
=>
define i32 @umultest4(i32 %n) {
%0:
  %shr = lshr i32 %n, 1
  %mul = umul_overflow {i32, i1, i24} %shr, 4
  %ov = extractvalue {i32, i1, i24} %mul, 1
  %res = extractvalue {i32, i1, i24} %mul, 0
  %ret = select i1 %ov, i32 4294967295, i32 %res
  ret i32 %ret
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define {i32, i1, i24} @umultest5(i32 %x, i32 %y) {
%0:
  %or_x = or i32 %x, 2147483648
  %or_y = or i32 %y, 2147483648
  %mul = umul_overflow {i32, i1, i24} %or_x, %or_y
  ret {i32, i1, i24} %mul
}
=>
define {i32, i1, i24} @umultest5(i32 %x, i32 %y) {
%0:
  %or_x = or i32 %x, 2147483648
  %or_y = or i32 %y, 2147483648
  %mul = mul i32 %or_x, %or_y
  %1 = insertvalue {i32, i1, i24} { undef, 1, poison }, i32 %mul, 0
  ret {i32, i1, i24} %1
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @overflow_div_add(i32 %v1, i32 %v2) {
%0:
  %div = sdiv i32 %v1, 2
  %t = sadd_overflow {i32, i1, i24} %div, 1
  %obit = extractvalue {i32, i1, i24} %t, 1
  ret i1 %obit
}
=>
define i1 @overflow_div_add(i32 %v1, i32 %v2) {
%0:
  ret i1 0
}
Transformation seems to be correct!


----------------------------------------
define i1 @overflow_div_sub(i32 %v1, i32 %v2) {
%0:
  %a = ashr i32 %v1, 18
  %div = sdiv i32 %a, 65536
  %t = ssub_overflow {i32, i1, i24} %div, 1
  %obit = extractvalue {i32, i1, i24} %t, 1
  ret i1 %obit
}
=>
define i1 @overflow_div_sub(i32 %v1, i32 %v2) {
%0:
  ret i1 0
}
Transformation seems to be correct!


----------------------------------------
define i1 @overflow_mod_mul(i32 %v1, i32 %v2) {
%0:
  %rem = srem i32 %v1, 1000
  %t = smul_overflow {i32, i1, i24} %rem, %rem
  %obit = extractvalue {i32, i1, i24} %t, 1
  ret i1 %obit
}
=>
define i1 @overflow_mod_mul(i32 %v1, i32 %v2) {
%0:
  ret i1 0
}
Transformation doesn't verify!
ERROR: Timeout


----------------------------------------
define i1 @overflow_mod_overflow_mul(i32 %v1, i32 %v2) {
%0:
  %rem = srem i32 %v1, 65537
  %t = smul_overflow {i32, i1, i24} %rem, %rem
  %obit = extractvalue {i32, i1, i24} %t, 1
  ret i1 %obit
}
=>
define i1 @overflow_mod_overflow_mul(i32 %v1, i32 %v2) {
%0:
  %rem = srem i32 %v1, 65537
  %t = smul_overflow {i32, i1, i24} %rem, %rem
  %obit = extractvalue {i32, i1, i24} %t, 1
  ret i1 %obit
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @ssubtest_reorder(i8 %a) {
%0:
  %aa = sext i8 %a to i32
  %x = ssub_overflow {i32, i1, i24} 0, %aa
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @ssubtest_reorder(i8 %a) {
%0:
  %aa = sext i8 %a to i32
  %x = sub nsw i32 0, %aa
  %1 = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %x, 0
  ret {i32, i1, i24} %1
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @never_overflows_ssub_test0(i32 %a) {
%0:
  %x = ssub_overflow {i32, i1, i24} %a, 0
  ret {i32, i1, i24} %x
}
=>
define {i32, i1, i24} @never_overflows_ssub_test0(i32 %a) {
%0:
  %x = insertvalue {i32, i1, i24} { undef, 0, poison }, i32 %a, 0
  ret {i32, i1, i24} %x
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ult_x(i32 %x, i32 %y, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ult i32 %c, %x
  ret i1 %d
}
=>
define i1 @uadd_res_ult_x(i32 %x, i32 %y, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ult_y(i32 %x, i32 %y, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ult i32 %c, %y
  ret i1 %d
}
=>
define i1 @uadd_res_ult_y(i32 %x, i32 %y, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ugt_x(i32 %xx, i32 %y, * %p) {
%0:
  %x = urem i32 42, %xx
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ugt i32 %x, %c
  ret i1 %d
}
=>
define i1 @uadd_res_ugt_x(i32 %xx, i32 %y, * %p) {
%0:
  %x = urem i32 42, %xx
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ugt_y(i32 %x, i32 %yy, * %p) {
%0:
  %y = urem i32 42, %yy
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ugt i32 %y, %c
  ret i1 %d
}
=>
define i1 @uadd_res_ugt_y(i32 %x, i32 %yy, * %p) {
%0:
  %y = urem i32 42, %yy
  %a = uadd_overflow {i32, i1, i24} %x, %y
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ult_const(i32 %x, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 42
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ult i32 %c, 42
  ret i1 %d
}
=>
define i1 @uadd_res_ult_const(i32 %x, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 42
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ult_const_one(i32 %x, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 1
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ult i32 %c, 1
  ret i1 %d
}
=>
define i1 @uadd_res_ult_const_one(i32 %x, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 1
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define i1 @uadd_res_ult_const_minus_one(i32 %x, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 4294967295
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %c = extractvalue {i32, i1, i24} %a, 0
  %d = icmp ult i32 %c, 4294967295
  ret i1 %d
}
=>
define i1 @uadd_res_ult_const_minus_one(i32 %x, * %p) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 4294967295
  %b = extractvalue {i32, i1, i24} %a, 1
  store i1 %b, * %p, align 1
  %d = extractvalue {i32, i1, i24} %a, 1
  ret i1 %d
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @sadd_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = sadd_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
=>
define {i32, i1, i24} @sadd_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = sadd_overflow {i32, i1, i24} %x, 42
  ret {i32, i1, i24} %a
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @uadd_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = uadd_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
=>
define {i32, i1, i24} @uadd_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = uadd_overflow {i32, i1, i24} %x, 42
  ret {i32, i1, i24} %a
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @ssub_no_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = ssub_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
=>
define {i32, i1, i24} @ssub_no_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = ssub_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @usub_no_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = usub_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
=>
define {i32, i1, i24} @usub_no_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = usub_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @smul_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = smul_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
=>
define {i32, i1, i24} @smul_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = smul_overflow {i32, i1, i24} %x, 42
  ret {i32, i1, i24} %a
}
Transformation seems to be correct!


----------------------------------------
define {i32, i1, i24} @umul_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = umul_overflow {i32, i1, i24} 42, %x
  ret {i32, i1, i24} %a
}
=>
define {i32, i1, i24} @umul_canonicalize_constant_arg0(i32 %x) {
%0:
  %a = umul_overflow {i32, i1, i24} %x, 42
  ret {i32, i1, i24} %a
}
Transformation seems to be correct!


----------------------------------------
define {i8, i1} @uadd_always_overflow(i8 %x) {
%0:
  %y = or i8 %x, 192
  %a = uadd_overflow {i8, i1} %y, 64
  ret {i8, i1} %a
}
=>
define {i8, i1} @uadd_always_overflow(i8 %x) {
%0:
  %1 = and i8 %x, 63
  %2 = insertvalue {i8, i1} { undef, 1 }, i8 %1, 0
  ret {i8, i1} %2
}
Transformation seems to be correct!


----------------------------------------
define {i8, i1} @usub_always_overflow(i8 %x) {
%0:
  %y = or i8 %x, 64
  %a = usub_overflow {i8, i1} 63, %y
  ret {i8, i1} %a
}
=>
define {i8, i1} @usub_always_overflow(i8 %x) {
%0:
  %y = or i8 %x, 64
  %a = sub nsw i8 63, %y
  %1 = insertvalue {i8, i1} { undef, 1 }, i8 %a, 0
  ret {i8, i1} %1
}
Transformation seems to be correct!


----------------------------------------
define {i8, i1} @umul_always_overflow(i8 %x) {
%0:
  %y = or i8 %x, 128
  %a = umul_overflow {i8, i1} %y, 2
  ret {i8, i1} %a
}
=>
define {i8, i1} @umul_always_overflow(i8 %x) {
%0:
  %a = shl i8 %x, 1
  %1 = insertvalue {i8, i1} { undef, 1 }, i8 %a, 0
  ret {i8, i1} %1
}
Transformation seems to be correct!


----------------------------------------
define {i8, i1} @sadd_always_overflow(i8 %x) {
%0:
  %c = icmp sgt i8 %x, 100
  %y = select i1 %c, i8 %x, i8 100
  %a = sadd_overflow {i8, i1} %y, 28
  ret {i8, i1} %a
}
=>
define {i8, i1} @sadd_always_overflow(i8 %x) {
%0:
  %c = icmp sgt i8 %x, 100
  %y = select i1 %c, i8 %x, i8 100
  %a = add nuw i8 %y, 28
  %1 = insertvalue {i8, i1} { undef, 1 }, i8 %a, 0
  ret {i8, i1} %1
}
Transformation doesn't verify!
ERROR: Target is more poisonous than source

Example:
i8 %x = undef

Source:
i1 %c = undef
i8 %y = undef
{i8, i1} %a = { undef, undef }

Target:
i1 %c = #x1 (1)
i8 %y = #xe4 (228, -28)
i8 %a = poison
{i8, i1} %1 = { poison, #x1 (1) }
Source value: { undef, undef }
Target value: { poison, #x1 (1) }


------------------- SMT STATS -------------------
Num queries: 116
Num invalid: 0
Num skips:   0
Num trivial: 137 (54.2%)
Num timeout: 8 (6.9%)
Num errors:  0 (0.0%)
Num SAT:     44 (37.9%)
Num UNSAT:   64 (55.2%)

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/with_overflow.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/with_overflow.ll

NOTE: This test would pass if undef didn't exist!

<-- Back