Test source: git
Source: <stdin>
----------------------------------------
define i8 @test_scalar_uadd_canonical(i8 %a) {
%0:
%x = uadd_sat i8 10, %a
ret i8 %x
}
=>
define i8 @test_scalar_uadd_canonical(i8 %a) {
%0:
%x = uadd_sat i8 %a, 10
ret i8 %x
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_canonical(<2 x i8> %a) {
%0:
%x = uadd_sat <2 x i8> { 10, 20 }, %a
ret <2 x i8> %x
}
=>
define <2 x i8> @test_vector_uadd_canonical(<2 x i8> %a) {
%0:
%x = uadd_sat <2 x i8> %a, { 10, 20 }
ret <2 x i8> %x
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_canonical(i8 %a) {
%0:
%x = sadd_sat i8 246, %a
ret i8 %x
}
=>
define i8 @test_scalar_sadd_canonical(i8 %a) {
%0:
%x = sadd_sat i8 %a, 246
ret i8 %x
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_canonical(<2 x i8> %a) {
%0:
%x = sadd_sat <2 x i8> { 10, 236 }, %a
ret <2 x i8> %x
}
=>
define <2 x i8> @test_vector_sadd_canonical(<2 x i8> %a) {
%0:
%x = sadd_sat <2 x i8> %a, { 10, 236 }
ret <2 x i8> %x
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_combine(i8 %a) {
%0:
%x1 = uadd_sat i8 %a, 10
%x2 = uadd_sat i8 %x1, 20
ret i8 %x2
}
=>
define i8 @test_scalar_uadd_combine(i8 %a) {
%0:
%1 = uadd_sat i8 %a, 30
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_combine(<2 x i8> %a) {
%0:
%x1 = uadd_sat <2 x i8> %a, { 10, 10 }
%x2 = uadd_sat <2 x i8> %x1, { 20, 20 }
ret <2 x i8> %x2
}
=>
define <2 x i8> @test_vector_uadd_combine(<2 x i8> %a) {
%0:
%1 = uadd_sat <2 x i8> %a, { 30, 30 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_combine_non_splat(<2 x i8> %a) {
%0:
%x1 = uadd_sat <2 x i8> %a, { 10, 20 }
%x2 = uadd_sat <2 x i8> %x1, { 30, 40 }
ret <2 x i8> %x2
}
=>
define <2 x i8> @test_vector_uadd_combine_non_splat(<2 x i8> %a) {
%0:
%x1 = uadd_sat <2 x i8> %a, { 10, 20 }
%x2 = uadd_sat <2 x i8> %x1, { 30, 40 }
ret <2 x i8> %x2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_overflow(i8 %a) {
%0:
%y1 = uadd_sat i8 %a, 100
%y2 = uadd_sat i8 %y1, 200
ret i8 %y2
}
=>
define i8 @test_scalar_uadd_overflow(i8 %a) {
%0:
ret i8 255
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_overflow(<2 x i8> %a) {
%0:
%y1 = uadd_sat <2 x i8> %a, { 100, 100 }
%y2 = uadd_sat <2 x i8> %y1, { 200, 200 }
ret <2 x i8> %y2
}
=>
define <2 x i8> @test_vector_uadd_overflow(<2 x i8> %a) {
%0:
ret <2 x i8> { 255, 255 }
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_both_positive(i8 %a) {
%0:
%z1 = sadd_sat i8 %a, 10
%z2 = sadd_sat i8 %z1, 20
ret i8 %z2
}
=>
define i8 @test_scalar_sadd_both_positive(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 30
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_both_positive(<2 x i8> %a) {
%0:
%z1 = sadd_sat <2 x i8> %a, { 10, 10 }
%z2 = sadd_sat <2 x i8> %z1, { 20, 20 }
ret <2 x i8> %z2
}
=>
define <2 x i8> @test_vector_sadd_both_positive(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 30, 30 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_both_negative(i8 %a) {
%0:
%u1 = sadd_sat i8 %a, 246
%u2 = sadd_sat i8 %u1, 236
ret i8 %u2
}
=>
define i8 @test_scalar_sadd_both_negative(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 226
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_both_negative(<2 x i8> %a) {
%0:
%u1 = sadd_sat <2 x i8> %a, { 246, 246 }
%u2 = sadd_sat <2 x i8> %u1, { 236, 236 }
ret <2 x i8> %u2
}
=>
define <2 x i8> @test_vector_sadd_both_negative(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 226, 226 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_different_sign(i8 %a) {
%0:
%v1 = sadd_sat i8 %a, 10
%v2 = sadd_sat i8 %v1, 236
ret i8 %v2
}
=>
define i8 @test_scalar_sadd_different_sign(i8 %a) {
%0:
%v1 = sadd_sat i8 %a, 10
%v2 = sadd_sat i8 %v1, 236
ret i8 %v2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_overflow(i8 %a) {
%0:
%w1 = sadd_sat i8 %a, 100
%w2 = sadd_sat i8 %w1, 100
ret i8 %w2
}
=>
define i8 @test_scalar_sadd_overflow(i8 %a) {
%0:
%w1 = sadd_sat i8 %a, 100
%w2 = sadd_sat i8 %w1, 100
ret i8 %w2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_neg_neg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = uadd_sat i8 %a_neg, 246
ret i8 %r
}
=>
define i8 @test_scalar_uadd_neg_neg(i8 %a) {
%0:
ret i8 255
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_neg_neg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = uadd_sat <2 x i8> %a_neg, { 246, 236 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_uadd_neg_neg(<2 x i8> %a) {
%0:
ret <2 x i8> { 255, 255 }
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_nneg_nneg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = uadd_sat i8 %a_nneg, 10
ret i8 %r
}
=>
define i8 @test_scalar_uadd_nneg_nneg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = add nuw i8 %a_nneg, 10
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_nneg_nneg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = uadd_sat <2 x i8> %a_nneg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_uadd_nneg_nneg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = add nuw <2 x i8> %a_nneg, { 10, 20 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = uadd_sat i8 %a_neg, 10
ret i8 %r
}
=>
define i8 @test_scalar_uadd_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = uadd_sat i8 %a_neg, 10
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = uadd_sat <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_uadd_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = uadd_sat <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i8 @test_scalar_uadd_never_overflows(i8 %a) {
%0:
%a_masked = and i8 %a, 129
%r = uadd_sat i8 %a_masked, 1
ret i8 %r
}
=>
define i8 @test_scalar_uadd_never_overflows(i8 %a) {
%0:
%a_masked = and i8 %a, 129
%r = add nsw nuw i8 %a_masked, 1
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_never_overflows(<2 x i8> %a) {
%0:
%a_masked = and <2 x i8> %a, { 129, 129 }
%r = uadd_sat <2 x i8> %a_masked, { 1, 1 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_uadd_never_overflows(<2 x i8> %a) {
%0:
%a_masked = and <2 x i8> %a, { 129, 129 }
%r = add nsw nuw <2 x i8> %a_masked, { 1, 1 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_always_overflows(i8 %a) {
%0:
%a_masked = or i8 %a, 192
%r = uadd_sat i8 %a_masked, 64
ret i8 %r
}
=>
define i8 @test_scalar_uadd_always_overflows(i8 %a) {
%0:
ret i8 255
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_uadd_always_overflows(<2 x i8> %a) {
%0:
%a_masked = or <2 x i8> %a, { 192, 192 }
%r = uadd_sat <2 x i8> %a_masked, { 64, 64 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_uadd_always_overflows(<2 x i8> %a) {
%0:
ret <2 x i8> { 255, 255 }
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = sadd_sat i8 %a_neg, 10
ret i8 %r
}
=>
define i8 @test_scalar_sadd_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = add nsw i8 %a_neg, 10
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = sadd_sat <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_sadd_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = add nsw <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i8 @test_scalar_sadd_nneg_neg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = sadd_sat i8 %a_nneg, 246
ret i8 %r
}
=>
define i8 @test_scalar_sadd_nneg_neg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = add nsw i8 %a_nneg, 246
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_nneg_neg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = sadd_sat <2 x i8> %a_nneg, { 246, 236 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_sadd_nneg_neg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = add nsw <2 x i8> %a_nneg, { 246, 236 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_neg_neg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = sadd_sat i8 %a_neg, 246
ret i8 %r
}
=>
define i8 @test_scalar_sadd_neg_neg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = sadd_sat i8 %a_neg, 246
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_neg_neg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = sadd_sat <2 x i8> %a_neg, { 246, 236 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_sadd_neg_neg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = sadd_sat <2 x i8> %a_neg, { 246, 236 }
ret <2 x i8> %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i8 @test_scalar_sadd_always_overflows_low(i8 %a) {
%0:
%cmp = icmp slt i8 %a, 136
%min = select i1 %cmp, i8 %a, i8 136
%r = sadd_sat i8 %min, 246
ret i8 %r
}
=>
define i8 @test_scalar_sadd_always_overflows_low(i8 %a) {
%0:
ret i8 128
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_always_overflows_high(i8 %a) {
%0:
%cmp = icmp sgt i8 %a, 120
%max = select i1 %cmp, i8 %a, i8 120
%r = sadd_sat i8 %max, 10
ret i8 %r
}
=>
define i8 @test_scalar_sadd_always_overflows_high(i8 %a) {
%0:
ret i8 127
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_sub_nuw_lost_no_ov(i8 %a) {
%0:
%b = sub nuw i8 %a, 10
%r = uadd_sat i8 %b, 9
ret i8 %r
}
=>
define i8 @test_scalar_uadd_sub_nuw_lost_no_ov(i8 %a) {
%0:
%b = add i8 %a, 246
%r = uadd_sat i8 %b, 9
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_urem_no_ov(i8 %a) {
%0:
%b = urem i8 %a, 100
%r = uadd_sat i8 %b, 156
ret i8 %r
}
=>
define i8 @test_scalar_uadd_urem_no_ov(i8 %a) {
%0:
%b = urem i8 %a, 100
%r = add nsw nuw i8 %b, 156
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_urem_may_ov(i8 %a) {
%0:
%b = urem i8 %a, 100
%r = uadd_sat i8 %b, 157
ret i8 %r
}
=>
define i8 @test_scalar_uadd_urem_may_ov(i8 %a) {
%0:
%b = urem i8 %a, 100
%r = uadd_sat i8 %b, 157
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_udiv_known_bits(i8 %a, i8 %b) {
%0:
%aa = udiv i8 190, %a
%bb = and i8 %b, 63
%r = uadd_sat i8 %aa, %bb
ret i8 %r
}
=>
define i8 @test_scalar_uadd_udiv_known_bits(i8 %a, i8 %b) {
%0:
%aa = udiv i8 190, %a
%bb = and i8 %b, 63
%r = add nuw i8 %aa, %bb
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_srem_no_ov(i8 %a) {
%0:
%b = srem i8 %a, 100
%r = sadd_sat i8 %b, 28
ret i8 %r
}
=>
define i8 @test_scalar_sadd_srem_no_ov(i8 %a) {
%0:
%b = srem i8 %a, 100
%r = add nsw i8 %b, 28
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_srem_may_ov(i8 %a) {
%0:
%b = srem i8 %a, 100
%r = sadd_sat i8 %b, 29
ret i8 %r
}
=>
define i8 @test_scalar_sadd_srem_may_ov(i8 %a) {
%0:
%b = srem i8 %a, 100
%r = sadd_sat i8 %b, 29
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_srem_and_no_ov(i8 %a, i8 %b) {
%0:
%aa = srem i8 %a, 100
%bb = and i8 %b, 15
%r = sadd_sat i8 %aa, %bb
ret i8 %r
}
=>
define i8 @test_scalar_sadd_srem_and_no_ov(i8 %a, i8 %b) {
%0:
%aa = srem i8 %a, 100
%bb = and i8 %b, 15
%r = add nsw i8 %aa, %bb
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_canonical(i8 %a) {
%0:
%r = usub_sat i8 %a, 10
ret i8 %r
}
=>
define i8 @test_scalar_usub_canonical(i8 %a) {
%0:
%r = usub_sat i8 %a, 10
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_canonical(i8 %a) {
%0:
%r = ssub_sat i8 %a, 10
ret i8 %r
}
=>
define i8 @test_scalar_ssub_canonical(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 246
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_canonical(<2 x i8> %a) {
%0:
%r = ssub_sat <2 x i8> %a, { 10, 10 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_canonical(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 246, 246 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_canonical_min_non_splat(<2 x i8> %a) {
%0:
%r = ssub_sat <2 x i8> %a, { 10, 246 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_canonical_min_non_splat(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 246, 10 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_canonical_min(i8 %a) {
%0:
%r = ssub_sat i8 %a, 128
ret i8 %r
}
=>
define i8 @test_scalar_ssub_canonical_min(i8 %a) {
%0:
%r = ssub_sat i8 %a, 128
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_canonical_min(<2 x i8> %a) {
%0:
%r = ssub_sat <2 x i8> %a, { 128, 246 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_canonical_min(<2 x i8> %a) {
%0:
%r = ssub_sat <2 x i8> %a, { 128, 246 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_combine(i8 %a) {
%0:
%x1 = usub_sat i8 %a, 10
%x2 = usub_sat i8 %x1, 20
ret i8 %x2
}
=>
define i8 @test_scalar_usub_combine(i8 %a) {
%0:
%1 = usub_sat i8 %a, 30
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_combine(<2 x i8> %a) {
%0:
%x1 = usub_sat <2 x i8> %a, { 10, 10 }
%x2 = usub_sat <2 x i8> %x1, { 20, 20 }
ret <2 x i8> %x2
}
=>
define <2 x i8> @test_vector_usub_combine(<2 x i8> %a) {
%0:
%1 = usub_sat <2 x i8> %a, { 30, 30 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_combine_non_splat(<2 x i8> %a) {
%0:
%x1 = usub_sat <2 x i8> %a, { 10, 20 }
%x2 = usub_sat <2 x i8> %x1, { 30, 40 }
ret <2 x i8> %x2
}
=>
define <2 x i8> @test_vector_usub_combine_non_splat(<2 x i8> %a) {
%0:
%x1 = usub_sat <2 x i8> %a, { 10, 20 }
%x2 = usub_sat <2 x i8> %x1, { 30, 40 }
ret <2 x i8> %x2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_overflow(i8 %a) {
%0:
%y1 = usub_sat i8 %a, 100
%y2 = usub_sat i8 %y1, 200
ret i8 %y2
}
=>
define i8 @test_scalar_usub_overflow(i8 %a) {
%0:
ret i8 0
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_overflow(<2 x i8> %a) {
%0:
%y1 = usub_sat <2 x i8> %a, { 100, 100 }
%y2 = usub_sat <2 x i8> %y1, { 200, 200 }
ret <2 x i8> %y2
}
=>
define <2 x i8> @test_vector_usub_overflow(<2 x i8> %a) {
%0:
ret <2 x i8> { 0, 0 }
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_both_positive(i8 %a) {
%0:
%z1 = ssub_sat i8 %a, 10
%z2 = ssub_sat i8 %z1, 20
ret i8 %z2
}
=>
define i8 @test_scalar_ssub_both_positive(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 226
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_both_positive(<2 x i8> %a) {
%0:
%z1 = ssub_sat <2 x i8> %a, { 10, 10 }
%z2 = ssub_sat <2 x i8> %z1, { 20, 20 }
ret <2 x i8> %z2
}
=>
define <2 x i8> @test_vector_ssub_both_positive(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 226, 226 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_both_negative(i8 %a) {
%0:
%u1 = ssub_sat i8 %a, 246
%u2 = ssub_sat i8 %u1, 236
ret i8 %u2
}
=>
define i8 @test_scalar_ssub_both_negative(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 30
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_both_negative(<2 x i8> %a) {
%0:
%u1 = ssub_sat <2 x i8> %a, { 246, 246 }
%u2 = ssub_sat <2 x i8> %u1, { 236, 236 }
ret <2 x i8> %u2
}
=>
define <2 x i8> @test_vector_ssub_both_negative(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 30, 30 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_different_sign(i8 %a) {
%0:
%v1 = ssub_sat i8 %a, 10
%v2 = ssub_sat i8 %v1, 236
ret i8 %v2
}
=>
define i8 @test_scalar_ssub_different_sign(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 246
%2 = sadd_sat i8 %1, 20
ret i8 %2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_sadd_ssub(i8 %a) {
%0:
%v1 = sadd_sat i8 10, %a
%v2 = ssub_sat i8 %v1, 236
ret i8 %v2
}
=>
define i8 @test_scalar_sadd_ssub(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 30
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_sadd_ssub(<2 x i8> %a) {
%0:
%v1 = sadd_sat <2 x i8> { 246, 246 }, %a
%v2 = ssub_sat <2 x i8> %v1, { 20, 20 }
ret <2 x i8> %v2
}
=>
define <2 x i8> @test_vector_sadd_ssub(<2 x i8> %a) {
%0:
%1 = sadd_sat <2 x i8> %a, { 226, 226 }
ret <2 x i8> %1
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_overflow(i8 %a) {
%0:
%w1 = ssub_sat i8 %a, 100
%w2 = ssub_sat i8 %w1, 100
ret i8 %w2
}
=>
define i8 @test_scalar_ssub_overflow(i8 %a) {
%0:
%1 = sadd_sat i8 %a, 156
%2 = sadd_sat i8 %1, 156
ret i8 %2
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_nneg_neg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = usub_sat i8 %a_nneg, 246
ret i8 %r
}
=>
define i8 @test_scalar_usub_nneg_neg(i8 %a) {
%0:
ret i8 0
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_nneg_neg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = usub_sat <2 x i8> %a_nneg, { 246, 236 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_nneg_neg(<2 x i8> %a) {
%0:
ret <2 x i8> { 0, 0 }
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = usub_sat i8 %a_neg, 10
ret i8 %r
}
=>
define i8 @test_scalar_usub_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = add i8 %a_neg, 246
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = usub_sat <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = add <2 x i8> %a_neg, { 246, 236 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_nneg_nneg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = usub_sat i8 %a_nneg, 10
ret i8 %r
}
=>
define i8 @test_scalar_usub_nneg_nneg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = usub_sat i8 %a_nneg, 10
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_nneg_nneg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = usub_sat <2 x i8> %a_nneg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_nneg_nneg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = usub_sat <2 x i8> %a_nneg, { 10, 20 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_never_overflows(i8 %a) {
%0:
%a_masked = or i8 %a, 64
%r = usub_sat i8 %a_masked, 10
ret i8 %r
}
=>
define i8 @test_scalar_usub_never_overflows(i8 %a) {
%0:
%a_masked = or i8 %a, 64
%r = add nsw i8 %a_masked, 246
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_never_overflows(<2 x i8> %a) {
%0:
%a_masked = or <2 x i8> %a, { 64, 64 }
%r = usub_sat <2 x i8> %a_masked, { 10, 10 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_never_overflows(<2 x i8> %a) {
%0:
%a_masked = or <2 x i8> %a, { 64, 64 }
%r = add nsw <2 x i8> %a_masked, { 246, 246 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_always_overflows(i8 %a) {
%0:
%a_masked = and i8 %a, 64
%r = usub_sat i8 %a_masked, 100
ret i8 %r
}
=>
define i8 @test_scalar_usub_always_overflows(i8 %a) {
%0:
ret i8 0
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_always_overflows(<2 x i8> %a) {
%0:
%a_masked = and <2 x i8> %a, { 64, 64 }
%r = usub_sat <2 x i8> %a_masked, { 100, 100 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_always_overflows(<2 x i8> %a) {
%0:
ret <2 x i8> { 0, 0 }
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_neg_neg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = ssub_sat i8 %a_neg, 246
ret i8 %r
}
=>
define i8 @test_scalar_ssub_neg_neg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = add nsw i8 %a_neg, 10
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_neg_neg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = ssub_sat <2 x i8> %a_neg, { 246, 236 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_neg_neg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = add nsw <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i8 @test_scalar_ssub_nneg_nneg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = ssub_sat i8 %a_nneg, 10
ret i8 %r
}
=>
define i8 @test_scalar_ssub_nneg_nneg(i8 %a) {
%0:
%a_nneg = and i8 %a, 127
%r = add nsw i8 %a_nneg, 246
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_nneg_nneg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = ssub_sat <2 x i8> %a_nneg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_nneg_nneg(<2 x i8> %a) {
%0:
%a_nneg = and <2 x i8> %a, { 127, 127 }
%r = add nsw <2 x i8> %a_nneg, { 246, 236 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%r = ssub_sat i8 %a_neg, 10
ret i8 %r
}
=>
define i8 @test_scalar_ssub_neg_nneg(i8 %a) {
%0:
%a_neg = or i8 %a, 128
%1 = sadd_sat i8 %a_neg, 246
ret i8 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%r = ssub_sat <2 x i8> %a_neg, { 10, 20 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_neg_nneg(<2 x i8> %a) {
%0:
%a_neg = or <2 x i8> %a, { 128, 128 }
%1 = sadd_sat <2 x i8> %a_neg, { 246, 236 }
ret <2 x i8> %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i8 @test_scalar_ssub_always_overflows_low(i8 %a) {
%0:
%cmp = icmp sgt i8 %a, 120
%max = select i1 %cmp, i8 %a, i8 120
%r = ssub_sat i8 246, %max
ret i8 %r
}
=>
define i8 @test_scalar_ssub_always_overflows_low(i8 %a) {
%0:
ret i8 128
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_always_overflows_high(i8 %a) {
%0:
%cmp = icmp slt i8 %a, 136
%min = select i1 %cmp, i8 %a, i8 136
%r = ssub_sat i8 10, %min
ret i8 %r
}
=>
define i8 @test_scalar_ssub_always_overflows_high(i8 %a) {
%0:
ret i8 127
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_nuw_no_ov(i8 %a) {
%0:
%b = add nuw i8 %a, 10
%r = usub_sat i8 %b, 9
ret i8 %r
}
=>
define i8 @test_scalar_usub_add_nuw_no_ov(i8 %a) {
%0:
%r = add i8 %a, 1
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_nuw_eq(i8 %a) {
%0:
%b = add nuw i8 %a, 10
%r = usub_sat i8 %b, 10
ret i8 %r
}
=>
define i8 @test_scalar_usub_add_nuw_eq(i8 %a) {
%0:
ret i8 %a
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_nuw_may_ov(i8 %a) {
%0:
%b = add nuw i8 %a, 10
%r = usub_sat i8 %b, 11
ret i8 %r
}
=>
define i8 @test_scalar_usub_add_nuw_may_ov(i8 %a) {
%0:
%b = add nuw i8 %a, 10
%r = usub_sat i8 %b, 11
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_urem_must_ov(i8 %a) {
%0:
%b = urem i8 %a, 10
%r = usub_sat i8 %b, 10
ret i8 %r
}
=>
define i8 @test_scalar_usub_urem_must_ov(i8 %a) {
%0:
ret i8 0
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_urem_must_zero(i8 %a) {
%0:
%b = urem i8 %a, 10
%r = usub_sat i8 %b, 9
ret i8 %r
}
=>
define i8 @test_scalar_usub_urem_must_zero(i8 %a) {
%0:
%b = urem i8 %a, 10
%r = usub_sat i8 %b, 9
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_nuw_known_bits(i8 %a, i8 %b) {
%0:
%aa = add nuw i8 %a, 10
%bb = and i8 %b, 7
%r = usub_sat i8 %aa, %bb
ret i8 %r
}
=>
define i8 @test_scalar_usub_add_nuw_known_bits(i8 %a, i8 %b) {
%0:
%aa = add nuw i8 %a, 10
%bb = and i8 %b, 7
%r = sub nuw i8 %aa, %bb
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_nuw_inferred(i8 %a) {
%0:
%b = usub_sat i8 %a, 10
%r = add i8 %b, 9
ret i8 %r
}
=>
define i8 @test_scalar_usub_add_nuw_inferred(i8 %a) {
%0:
%b = usub_sat i8 %a, 10
%r = add nuw i8 %b, 9
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_add_nuw_no_ov(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 10 }
%r = usub_sat <2 x i8> %b, { 9, 9 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_add_nuw_no_ov(<2 x i8> %a) {
%0:
%r = add <2 x i8> %a, { 1, 1 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat1(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 10 }
%r = usub_sat <2 x i8> %b, { 10, 9 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat1(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 10 }
%r = usub_sat <2 x i8> %b, { 10, 9 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat2(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 9 }
%r = usub_sat <2 x i8> %b, { 9, 9 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat2(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 9 }
%r = usub_sat <2 x i8> %b, { 9, 9 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat3(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 9 }
%r = usub_sat <2 x i8> %b, { 10, 9 }
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_usub_add_nuw_no_ov_nonsplat3(<2 x i8> %a) {
%0:
%b = add nuw <2 x i8> %a, { 10, 9 }
%r = usub_sat <2 x i8> %b, { 10, 9 }
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_add_nsw_no_ov(i8 %a, i8 %b) {
%0:
%aa = add nsw i8 %a, 7
%bb = and i8 %b, 7
%r = ssub_sat i8 %aa, %bb
ret i8 %r
}
=>
define i8 @test_scalar_ssub_add_nsw_no_ov(i8 %a, i8 %b) {
%0:
%aa = add nsw i8 %a, 7
%bb = and i8 %b, 7
%r = sub nsw i8 %aa, %bb
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_ssub_add_nsw_may_ov(i8 %a, i8 %b) {
%0:
%aa = add nsw i8 %a, 6
%bb = and i8 %b, 7
%r = ssub_sat i8 %aa, %bb
ret i8 %r
}
=>
define i8 @test_scalar_ssub_add_nsw_may_ov(i8 %a, i8 %b) {
%0:
%aa = add nsw i8 %a, 6
%bb = and i8 %b, 7
%r = ssub_sat i8 %aa, %bb
ret i8 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_splat(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 7 }
%bb = and <2 x i8> %b, { 7, 7 }
%r = ssub_sat <2 x i8> %aa, %bb
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_splat(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 7 }
%bb = and <2 x i8> %b, { 7, 7 }
%r = sub nsw <2 x i8> %aa, %bb
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat1(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 7 }
%bb = and <2 x i8> %b, { 7, 6 }
%r = ssub_sat <2 x i8> %aa, %bb
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat1(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 7 }
%bb = and <2 x i8> %b, { 7, 6 }
%r = sub nsw <2 x i8> %aa, %bb
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat2(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 8 }
%bb = and <2 x i8> %b, { 7, 7 }
%r = ssub_sat <2 x i8> %aa, %bb
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat2(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 8 }
%bb = and <2 x i8> %b, { 7, 7 }
%r = ssub_sat <2 x i8> %aa, %bb
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat3(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 6 }
%bb = and <2 x i8> %b, { 7, 6 }
%r = ssub_sat <2 x i8> %aa, %bb
ret <2 x i8> %r
}
=>
define <2 x i8> @test_vector_ssub_add_nsw_no_ov_nonsplat3(<2 x i8> %a, <2 x i8> %b) {
%0:
%aa = add nsw <2 x i8> %a, { 7, 6 }
%bb = and <2 x i8> %b, { 7, 6 }
%r = ssub_sat <2 x i8> %aa, %bb
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %a, %b
%res = add i8 %sat, %b
ret i8 %res
}
=>
define i8 @test_scalar_usub_add(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %a, %b
%res = add i8 %sat, %b
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_extra_use(i8 %a, i8 %b, * %p) {
%0:
%sat = usub_sat i8 %a, %b
store i8 %sat, * %p, align 1
%res = add i8 %sat, %b
ret i8 %res
}
=>
define i8 @test_scalar_usub_add_extra_use(i8 %a, i8 %b, * %p) {
%0:
%sat = usub_sat i8 %a, %b
store i8 %sat, * %p, align 1
%res = add i8 %sat, %b
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_commuted(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %a, %b
%res = add i8 %b, %sat
ret i8 %res
}
=>
define i8 @test_scalar_usub_add_commuted(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %a, %b
%res = add i8 %sat, %b
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_commuted_wrong(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %b, %a
%res = add i8 %sat, %b
ret i8 %res
}
=>
define i8 @test_scalar_usub_add_commuted_wrong(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %b, %a
%res = add i8 %sat, %b
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_usub_add_const(i8 %a) {
%0:
%sat = usub_sat i8 %a, 42
%res = add i8 %sat, 42
ret i8 %res
}
=>
define i8 @test_scalar_usub_add_const(i8 %a) {
%0:
%sat = usub_sat i8 %a, 42
%res = add nuw i8 %sat, 42
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_sub(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %a, %b
%res = sub i8 %sat, %b
ret i8 %res
}
=>
define i8 @test_scalar_uadd_sub(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %a, %b
%res = sub i8 %sat, %b
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_sub_extra_use(i8 %a, i8 %b, * %p) {
%0:
%sat = uadd_sat i8 %a, %b
store i8 %sat, * %p, align 1
%res = sub i8 %sat, %b
ret i8 %res
}
=>
define i8 @test_scalar_uadd_sub_extra_use(i8 %a, i8 %b, * %p) {
%0:
%sat = uadd_sat i8 %a, %b
store i8 %sat, * %p, align 1
%res = sub i8 %sat, %b
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_sub_commuted(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %b, %a
%res = sub i8 %sat, %b
ret i8 %res
}
=>
define i8 @test_scalar_uadd_sub_commuted(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %b, %a
%res = sub i8 %sat, %b
ret i8 %res
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i8 @test_scalar_uadd_sub_commuted_wrong(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %a, %b
%res = sub i8 %b, %sat
ret i8 %res
}
=>
define i8 @test_scalar_uadd_sub_commuted_wrong(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %a, %b
%res = sub i8 %b, %sat
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i8 @test_scalar_uadd_sub_const(i8 %a) {
%0:
%sat = uadd_sat i8 %a, 42
%res = sub i8 %sat, 42
ret i8 %res
}
=>
define i8 @test_scalar_uadd_sub_const(i8 %a) {
%0:
%sat = uadd_sat i8 %a, 42
%res = add i8 %sat, 214
ret i8 %res
}
Transformation seems to be correct!
----------------------------------------
define i1 @scalar_uadd_eq_zero(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %a, %b
%cmp = icmp eq i8 %sat, 0
ret i1 %cmp
}
=>
define i1 @scalar_uadd_eq_zero(i8 %a, i8 %b) {
%0:
%1 = or i8 %a, %b
%cmp = icmp eq i8 %1, 0
ret i1 %cmp
}
Transformation seems to be correct!
----------------------------------------
define i1 @scalar_uadd_ne_zero(i8 %a, i8 %b) {
%0:
%sat = uadd_sat i8 %a, %b
%cmp = icmp ne i8 %sat, 0
ret i1 %cmp
}
=>
define i1 @scalar_uadd_ne_zero(i8 %a, i8 %b) {
%0:
%1 = or i8 %a, %b
%cmp = icmp ne i8 %1, 0
ret i1 %cmp
}
Transformation seems to be correct!
----------------------------------------
define i1 @scalar_usub_eq_zero(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %a, %b
%cmp = icmp eq i8 %sat, 0
ret i1 %cmp
}
=>
define i1 @scalar_usub_eq_zero(i8 %a, i8 %b) {
%0:
%cmp = icmp ule i8 %a, %b
ret i1 %cmp
}
Transformation seems to be correct!
----------------------------------------
define i1 @scalar_usub_ne_zero(i8 %a, i8 %b) {
%0:
%sat = usub_sat i8 %a, %b
%cmp = icmp ne i8 %sat, 0
ret i1 %cmp
}
=>
define i1 @scalar_usub_ne_zero(i8 %a, i8 %b) {
%0:
%cmp = icmp ugt i8 %a, %b
ret i1 %cmp
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%a = add i32 %y, %x
%c = icmp ult i32 %notx, %y
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat(i32 %x, i32 %y) {
%0:
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_commute_add(i32 %xp, i32 %y) {
%0:
%x = urem i32 42, %xp
%notx = xor i32 %x, 4294967295
%a = add i32 %x, %y
%c = icmp ult i32 %notx, %y
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_commute_add(i32 %xp, i32 %y) {
%0:
%x = urem i32 42, %xp
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_ugt(i32 %x, i32 %yp) {
%0:
%y = sdiv i32 %yp, 2442
%notx = xor i32 %x, 4294967295
%a = add i32 %y, %x
%c = icmp ugt i32 %y, %notx
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_ugt(i32 %x, i32 %yp) {
%0:
%y = sdiv i32 %yp, 2442
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i32> @uadd_sat_ugt_commute_add(<2 x i32> %xp, <2 x i32> %yp) {
%0:
%y = sdiv <2 x i32> %yp, { 2442, 4242 }
%x = srem <2 x i32> { 42, 43 }, %xp
%notx = xor <2 x i32> %x, { 4294967295, 4294967295 }
%a = add <2 x i32> %x, %y
%c = icmp ugt <2 x i32> %y, %notx
%r = select <2 x i1> %c, <2 x i32> { 4294967295, 4294967295 }, <2 x i32> %a
ret <2 x i32> %r
}
=>
define <2 x i32> @uadd_sat_ugt_commute_add(<2 x i32> %xp, <2 x i32> %yp) {
%0:
%y = sdiv <2 x i32> %yp, { 2442, 4242 }
%x = srem <2 x i32> { 42, 43 }, %xp
%1 = uadd_sat <2 x i32> %x, %y
ret <2 x i32> %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @uadd_sat_commute_select(i32 %x, i32 %yp) {
%0:
%y = sdiv i32 %yp, 2442
%notx = xor i32 %x, 4294967295
%a = add i32 %y, %x
%c = icmp ult i32 %y, %notx
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_commute_select(i32 %x, i32 %yp) {
%0:
%y = sdiv i32 %yp, 2442
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_commute_select_commute_add(i32 %xp, i32 %yp) {
%0:
%x = urem i32 42, %xp
%y = sdiv i32 %yp, 2442
%notx = xor i32 %x, 4294967295
%a = add i32 %x, %y
%c = icmp ult i32 %y, %notx
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_commute_select_commute_add(i32 %xp, i32 %yp) {
%0:
%x = urem i32 42, %xp
%y = sdiv i32 %yp, 2442
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define <2 x i32> @uadd_sat_commute_select_ugt(<2 x i32> %x, <2 x i32> %y) {
%0:
%notx = xor <2 x i32> %x, { 4294967295, 4294967295 }
%a = add <2 x i32> %y, %x
%c = icmp ugt <2 x i32> %notx, %y
%r = select <2 x i1> %c, <2 x i32> %a, <2 x i32> { 4294967295, 4294967295 }
ret <2 x i32> %r
}
=>
define <2 x i32> @uadd_sat_commute_select_ugt(<2 x i32> %x, <2 x i32> %y) {
%0:
%1 = uadd_sat <2 x i32> %x, %y
ret <2 x i32> %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @uadd_sat_commute_select_ugt_commute_add(i32 %xp, i32 %y) {
%0:
%x = srem i32 42, %xp
%notx = xor i32 %x, 4294967295
%a = add i32 %x, %y
%c = icmp ugt i32 %notx, %y
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_commute_select_ugt_commute_add(i32 %xp, i32 %y) {
%0:
%x = srem i32 42, %xp
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @not_uadd_sat(i32 %x, i32 %y) {
%0:
%a = add i32 %x, 4294967294
%c = icmp ugt i32 %x, 1
%r = select i1 %c, i32 %a, i32 %y
ret i32 %r
}
=>
define i32 @not_uadd_sat(i32 %x, i32 %y) {
%0:
%a = add i32 %x, 4294967294
%c = icmp ugt i32 %x, 1
%r = select i1 %c, i32 %a, i32 %y
ret i32 %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @not_uadd_sat2(i32 %x, i32 %y) {
%0:
%a = add i32 %x, 4294967294
%c = icmp ugt i32 %x, 1
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @not_uadd_sat2(i32 %x, i32 %y) {
%0:
%a = add i32 %x, 4294967294
%c = icmp ugt i32 %x, 1
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_not(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%a = add i32 %notx, %y
%c = icmp ult i32 %x, %y
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_not(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%1 = uadd_sat i32 %notx, %y
ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @uadd_sat_not_commute_add(i32 %xp, i32 %yp) {
%0:
%x = srem i32 42, %xp
%y = urem i32 42, %yp
%notx = xor i32 %x, 4294967295
%a = add i32 %y, %notx
%c = icmp ult i32 %x, %y
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_not_commute_add(i32 %xp, i32 %yp) {
%0:
%x = srem i32 42, %xp
%y = urem i32 42, %yp
%notx = xor i32 %x, 4294967295
%1 = uadd_sat i32 %y, %notx
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_not_ugt(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%a = add i32 %notx, %y
%c = icmp ugt i32 %y, %x
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_not_ugt(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%1 = uadd_sat i32 %notx, %y
ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define <2 x i32> @uadd_sat_not_ugt_commute_add(<2 x i32> %x, <2 x i32> %yp) {
%0:
%y = sdiv <2 x i32> %yp, { 2442, 4242 }
%notx = xor <2 x i32> %x, { 4294967295, 4294967295 }
%a = add <2 x i32> %y, %notx
%c = icmp ugt <2 x i32> %y, %x
%r = select <2 x i1> %c, <2 x i32> { 4294967295, 4294967295 }, <2 x i32> %a
ret <2 x i32> %r
}
=>
define <2 x i32> @uadd_sat_not_ugt_commute_add(<2 x i32> %x, <2 x i32> %yp) {
%0:
%y = sdiv <2 x i32> %yp, { 2442, 4242 }
%notx = xor <2 x i32> %x, { 4294967295, 4294967295 }
%1 = uadd_sat <2 x i32> %y, %notx
ret <2 x i32> %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @uadd_sat_not_commute_select(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%a = add i32 %notx, %y
%c = icmp ult i32 %y, %x
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_not_commute_select(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%1 = uadd_sat i32 %notx, %y
ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @uadd_sat_not_commute_select_commute_add(i32 %x, i32 %yp) {
%0:
%y = sdiv i32 42, %yp
%notx = xor i32 %x, 4294967295
%a = add i32 %y, %notx
%c = icmp ult i32 %y, %x
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_not_commute_select_commute_add(i32 %x, i32 %yp) {
%0:
%y = sdiv i32 42, %yp
%notx = xor i32 %x, 4294967295
%1 = uadd_sat i32 %y, %notx
ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define <2 x i32> @uadd_sat_not_commute_select_ugt(<2 x i32> %xp, <2 x i32> %yp) {
%0:
%x = urem <2 x i32> { 42, 4294967254 }, %xp
%y = srem <2 x i32> { 12, 412 }, %yp
%notx = xor <2 x i32> %x, { 4294967295, 4294967295 }
%a = add <2 x i32> %y, %notx
%c = icmp ugt <2 x i32> %x, %y
%r = select <2 x i1> %c, <2 x i32> %a, <2 x i32> { 4294967295, 4294967295 }
ret <2 x i32> %r
}
=>
define <2 x i32> @uadd_sat_not_commute_select_ugt(<2 x i32> %xp, <2 x i32> %yp) {
%0:
%x = urem <2 x i32> { 42, 4294967254 }, %xp
%y = srem <2 x i32> { 12, 412 }, %yp
%notx = xor <2 x i32> %x, { 4294967295, 4294967295 }
%1 = uadd_sat <2 x i32> %y, %notx
ret <2 x i32> %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_not_commute_select_ugt_commute_add(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%a = add i32 %notx, %y
%c = icmp ugt i32 %x, %y
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_not_commute_select_ugt_commute_add(i32 %x, i32 %y) {
%0:
%notx = xor i32 %x, 4294967295
%1 = uadd_sat i32 %notx, %y
ret i32 %1
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @uadd_sat_constant(i32 %x) {
%0:
%a = add i32 %x, 42
%c = icmp ugt i32 %x, 4294967253
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_constant(i32 %x) {
%0:
%a = add i32 %x, 42
%c = icmp ugt i32 %x, 4294967253
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_constant_commute(i32 %x) {
%0:
%a = add i32 %x, 42
%c = icmp ult i32 %x, 4294967253
%r = select i1 %c, i32 %a, i32 4294967295
ret i32 %r
}
=>
define i32 @uadd_sat_constant_commute(i32 %x) {
%0:
%1 = uadd_sat i32 %x, 42
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_canon(i32 %x, i32 %y) {
%0:
%a = add i32 %x, %y
%c = icmp ult i32 %a, %x
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_canon(i32 %x, i32 %y) {
%0:
%1 = uadd_sat i32 %x, %y
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_canon_y(i32 %x, i32 %y) {
%0:
%a = add i32 %x, %y
%c = icmp ult i32 %a, %y
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_canon_y(i32 %x, i32 %y) {
%0:
%1 = uadd_sat i32 %y, %x
ret i32 %1
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_canon_nuw(i32 %x, i32 %y) {
%0:
%a = add nuw i32 %x, %y
%c = icmp ult i32 %a, %x
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_canon_nuw(i32 %x, i32 %y) {
%0:
%a = add nuw i32 %x, %y
ret i32 %a
}
Transformation seems to be correct!
----------------------------------------
define i32 @uadd_sat_canon_y_nuw(i32 %x, i32 %y) {
%0:
%a = add nuw i32 %x, %y
%c = icmp ult i32 %a, %y
%r = select i1 %c, i32 4294967295, i32 %a
ret i32 %r
}
=>
define i32 @uadd_sat_canon_y_nuw(i32 %x, i32 %y) {
%0:
%a = add nuw i32 %x, %y
ret i32 %a
}
Transformation seems to be correct!
----------------------------------------
define <4 x i32> @uadd_sat_constant_vec(<4 x i32> %x) {
%0:
%a = add <4 x i32> %x, { 42, 42, 42, 42 }
%c = icmp ugt <4 x i32> %x, { 4294967253, 4294967253, 4294967253, 4294967253 }
%r = select <4 x i1> %c, <4 x i32> { 4294967295, 4294967295, 4294967295, 4294967295 }, <4 x i32> %a
ret <4 x i32> %r
}
=>
define <4 x i32> @uadd_sat_constant_vec(<4 x i32> %x) {
%0:
%a = add <4 x i32> %x, { 42, 42, 42, 42 }
%c = icmp ugt <4 x i32> %x, { 4294967253, 4294967253, 4294967253, 4294967253 }
%r = select <4 x i1> %c, <4 x i32> { 4294967295, 4294967295, 4294967295, 4294967295 }, <4 x i32> %a
ret <4 x i32> %r
}
Transformation seems to be correct!
----------------------------------------
define <4 x i32> @uadd_sat_constant_vec_commute(<4 x i32> %x) {
%0:
%a = add <4 x i32> %x, { 42, 42, 42, 42 }
%c = icmp ult <4 x i32> %x, { 4294967253, 4294967253, 4294967253, 4294967253 }
%r = select <4 x i1> %c, <4 x i32> %a, <4 x i32> { 4294967295, 4294967295, 4294967295, 4294967295 }
ret <4 x i32> %r
}
=>
define <4 x i32> @uadd_sat_constant_vec_commute(<4 x i32> %x) {
%0:
%1 = uadd_sat <4 x i32> %x, { 42, 42, 42, 42 }
ret <4 x i32> %1
}
Transformation seems to be correct!
----------------------------------------
define <4 x i32> @uadd_sat_constant_vec_commute_undefs(<4 x i32> %x) {
%0:
%a = add <4 x i32> %x, { 42, 42, 42, undef }
%c = icmp ult <4 x i32> %x, { 4294967253, 4294967253, undef, 4294967253 }
%r = select <4 x i1> %c, <4 x i32> %a, <4 x i32> { 4294967295, undef, 4294967295, 4294967295 }
ret <4 x i32> %r
}
=>
define <4 x i32> @uadd_sat_constant_vec_commute_undefs(<4 x i32> %x) {
%0:
%a = add <4 x i32> %x, { 42, 42, 42, undef }
%c = icmp ult <4 x i32> %x, { 4294967253, 4294967253, undef, 4294967253 }
%r = select <4 x i1> %c, <4 x i32> %a, <4 x i32> { 4294967295, undef, 4294967295, 4294967295 }
ret <4 x i32> %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @unsigned_sat_variable_using_min_add(i32 %x) {
%0:
%y = call i32 @get_i32()
%noty = xor i32 %y, 4294967295
%c = icmp ult i32 %x, %noty
%s = select i1 %c, i32 %x, i32 %noty
%r = add i32 %s, %y
ret i32 %r
}
=>
define i32 @unsigned_sat_variable_using_min_add(i32 %x) {
%0:
%y = call i32 @get_i32()
%r = uadd_sat i32 %x, %y
ret i32 %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define i32 @unsigned_sat_variable_using_min_commute_add(i32 %x) {
%0:
%y = call i32 @get_i32()
%noty = xor i32 %y, 4294967295
%c = icmp ult i32 %x, %noty
%s = select i1 %c, i32 %x, i32 %noty
%r = add i32 %y, %s
ret i32 %r
}
=>
define i32 @unsigned_sat_variable_using_min_commute_add(i32 %x) {
%0:
%y = call i32 @get_i32()
%r = uadd_sat i32 %x, %y
ret i32 %r
}
Transformation doesn't verify!
ERROR: Timeout
----------------------------------------
define <2 x i8> @unsigned_sat_variable_using_min_commute_select(<2 x i8> %x) {
%0:
%y = call <2 x i8> @get_v2i8()
%noty = xor <2 x i8> %y, { 255, 255 }
%c = icmp ult <2 x i8> %noty, %x
%s = select <2 x i1> %c, <2 x i8> %noty, <2 x i8> %x
%r = add <2 x i8> %s, %y
ret <2 x i8> %r
}
=>
define <2 x i8> @unsigned_sat_variable_using_min_commute_select(<2 x i8> %x) {
%0:
%y = call <2 x i8> @get_v2i8()
%r = uadd_sat <2 x i8> %x, %y
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i8> @unsigned_sat_variable_using_min_commute_add_select(<2 x i8> %x) {
%0:
%y = call <2 x i8> @get_v2i8()
%noty = xor <2 x i8> %y, { 255, 255 }
%c = icmp ult <2 x i8> %noty, %x
%s = select <2 x i1> %c, <2 x i8> %noty, <2 x i8> %x
%r = add <2 x i8> %y, %s
ret <2 x i8> %r
}
=>
define <2 x i8> @unsigned_sat_variable_using_min_commute_add_select(<2 x i8> %x) {
%0:
%y = call <2 x i8> @get_v2i8()
%r = uadd_sat <2 x i8> %x, %y
ret <2 x i8> %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @unsigned_sat_variable_using_wrong_min(i32 %x) {
%0:
%y = call i32 @get_i32()
%noty = xor i32 %y, 4294967295
%c = icmp slt i32 %x, %noty
%s = select i1 %c, i32 %x, i32 %noty
%r = add i32 %y, %s
ret i32 %r
}
=>
define i32 @unsigned_sat_variable_using_wrong_min(i32 %x) {
%0:
%y = call i32 @get_i32()
%noty = xor i32 %y, 4294967295
%c = icmp sgt i32 %noty, %x
%s = select i1 %c, i32 %x, i32 %noty
%r = add i32 %y, %s
ret i32 %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @unsigned_sat_variable_using_wrong_value(i32 %x, i32 %z) {
%0:
%y = call i32 @get_i32()
%noty = xor i32 %y, 4294967295
%c = icmp ult i32 %x, %noty
%s = select i1 %c, i32 %x, i32 %noty
%r = add i32 %z, %s
ret i32 %r
}
=>
define i32 @unsigned_sat_variable_using_wrong_value(i32 %x, i32 %z) {
%0:
%y = call i32 @get_i32()
%noty = xor i32 %y, 4294967295
%c = icmp ugt i32 %noty, %x
%s = select i1 %c, i32 %x, i32 %noty
%r = add i32 %s, %z
ret i32 %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @unsigned_sat_constant_using_min(i32 %x) {
%0:
%c = icmp ult i32 %x, 42
%s = select i1 %c, i32 %x, i32 42
%r = add i32 %s, 4294967253
ret i32 %r
}
=>
define i32 @unsigned_sat_constant_using_min(i32 %x) {
%0:
%r = uadd_sat i32 %x, 4294967253
ret i32 %r
}
Transformation seems to be correct!
----------------------------------------
define <2 x i32> @unsigned_sat_constant_using_min_splat(<2 x i32> %x) {
%0:
%c = icmp ult <2 x i32> %x, { 14, 14 }
%s = select <2 x i1> %c, <2 x i32> %x, <2 x i32> { 14, 14 }
%r = add <2 x i32> %s, { 4294967281, 4294967281 }
ret <2 x i32> %r
}
=>
define <2 x i32> @unsigned_sat_constant_using_min_splat(<2 x i32> %x) {
%0:
%r = uadd_sat <2 x i32> %x, { 4294967281, 4294967281 }
ret <2 x i32> %r
}
Transformation seems to be correct!
----------------------------------------
define i32 @unsigned_sat_constant_using_min_wrong_constant(i32 %x) {
%0:
%c = icmp ult i32 %x, 42
%s = select i1 %c, i32 %x, i32 42
%r = add i32 %s, 4294967254
ret i32 %r
}
=>
define i32 @unsigned_sat_constant_using_min_wrong_constant(i32 %x) {
%0:
%c = icmp ult i32 %x, 42
%s = select i1 %c, i32 %x, i32 42
%r = add nsw i32 %s, 4294967254
ret i32 %r
}
Transformation doesn't verify!
ERROR: Target is more poisonous than source
Example:
i32 %x = undef
Source:
i1 %c = undef
i32 %s = undef
i32 %r = undef
Target:
i1 %c = #x1 (1)
i32 %s = #x80000000 (2147483648, -2147483648)
i32 %r = poison
Source value: undef
Target value: poison
------------------- SMT STATS -------------------
Num queries: 340
Num invalid: 0
Num skips: 0
Num trivial: 365 (51.8%)
Num timeout: 17 (5.0%)
Num errors: 0 (0.0%)
Num SAT: 145 (42.6%)
Num UNSAT: 178 (52.4%)
+ : 'RUN: at line 2' + /home/nlopes/alive2/scripts/opt-alive.sh -instcombine -instcombine-infinite-loop-threshold=2 -S + /home/nlopes/llvm/build/bin/FileCheck /home/nlopes/llvm/llvm/test/Transforms/InstCombine/saturating-add-sub.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/saturating-add-sub.ll
NOTE: This test would pass if undef didn't exist!