From 80a8a857583a413566f0c7b0726081d54dc7e620 Mon Sep 17 00:00:00 2001 From: Roman Lebedev Date: Thu, 12 Sep 2019 14:12:31 +0000 Subject: [PATCH] [InstCombine][InstSimplify] Move constant-folding tests in result-of-usub-is-non-zero-and-no-overflow.ll llvm-svn: 371737 --- .../result-of-usub-is-non-zero-and-no-overflow.ll | 158 ++------------------- .../result-of-usub-is-non-zero-and-no-overflow.ll | 140 ++++++++++++++++++ 2 files changed, 149 insertions(+), 149 deletions(-) create mode 100644 llvm/test/Transforms/InstSimplify/result-of-usub-is-non-zero-and-no-overflow.ll diff --git a/llvm/test/Transforms/InstCombine/result-of-usub-is-non-zero-and-no-overflow.ll b/llvm/test/Transforms/InstCombine/result-of-usub-is-non-zero-and-no-overflow.ll index f5d0f60..1cf669a 100644 --- a/llvm/test/Transforms/InstCombine/result-of-usub-is-non-zero-and-no-overflow.ll +++ b/llvm/test/Transforms/InstCombine/result-of-usub-is-non-zero-and-no-overflow.ll @@ -287,148 +287,8 @@ define i1 @t9_commutative(i8 %base, i8 %offset) { ;------------------------------------------------------------------------------- -; If we are checking that we either did not get null or got no overflow, -; this is tautological and is always true. - -define i1 @t10(i8 %base, i8 %offset) { +define i1 @t10(i64 %base, i64* nonnull %offsetptr) { ; CHECK-LABEL: @t10( -; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] -; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) -; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp uge i8 [[BASE]], [[OFFSET]] -; CHECK-NEXT: call void @use1(i1 [[NO_UNDERFLOW]]) -; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[ADJUSTED]], 0 -; CHECK-NEXT: call void @use1(i1 [[NOT_NULL]]) -; CHECK-NEXT: [[R:%.*]] = or i1 [[NOT_NULL]], [[NO_UNDERFLOW]] -; CHECK-NEXT: ret i1 [[R]] -; - %adjusted = sub i8 %base, %offset - call void @use8(i8 %adjusted) - %no_underflow = icmp uge i8 %base, %offset - call void @use1(i1 %no_underflow) - %not_null = icmp ne i8 %adjusted, 0 - call void @use1(i1 %not_null) - %r = or i1 %not_null, %no_underflow - ret i1 %r -} -define i1 @t10_strict_bad(i8 %base, i8 %offset) { -; CHECK-LABEL: @t10_strict_bad( -; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] -; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) -; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp ugt i8 [[BASE]], [[OFFSET]] -; CHECK-NEXT: call void @use1(i1 [[NO_UNDERFLOW]]) -; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[ADJUSTED]], 0 -; CHECK-NEXT: call void @use1(i1 [[NOT_NULL]]) -; CHECK-NEXT: [[R:%.*]] = or i1 [[NOT_NULL]], [[NO_UNDERFLOW]] -; CHECK-NEXT: ret i1 [[R]] -; - %adjusted = sub i8 %base, %offset - call void @use8(i8 %adjusted) - %no_underflow = icmp ugt i8 %base, %offset ; but not for non-strict predicate - call void @use1(i1 %no_underflow) - %not_null = icmp ne i8 %adjusted, 0 - call void @use1(i1 %not_null) - %r = or i1 %not_null, %no_underflow - ret i1 %r -} - -define i1 @t11(i8 %base, i8 %offset) { -; CHECK-LABEL: @t11( -; CHECK-NEXT: [[AGG:%.*]] = call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[BASE:%.*]], i8 [[OFFSET:%.*]]) -; CHECK-NEXT: call void @useagg({ i8, i1 } [[AGG]]) -; CHECK-NEXT: [[ADJUSTED:%.*]] = extractvalue { i8, i1 } [[AGG]], 0 -; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) -; CHECK-NEXT: [[UNDERFLOW:%.*]] = extractvalue { i8, i1 } [[AGG]], 1 -; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) -; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = xor i1 [[UNDERFLOW]], true -; CHECK-NEXT: call void @use1(i1 [[NO_UNDERFLOW]]) -; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[ADJUSTED]], 0 -; CHECK-NEXT: [[R:%.*]] = or i1 [[NOT_NULL]], [[NO_UNDERFLOW]] -; CHECK-NEXT: ret i1 [[R]] -; - %agg = call {i8, i1} @llvm.usub.with.overflow(i8 %base, i8 %offset) - call void @useagg({i8, i1} %agg) - %adjusted = extractvalue {i8, i1} %agg, 0 - call void @use8(i8 %adjusted) - %underflow = extractvalue {i8, i1} %agg, 1 - call void @use1(i1 %underflow) - %no_underflow = xor i1 %underflow, -1 - call void @use1(i1 %no_underflow) - %not_null = icmp ne i8 %adjusted, 0 - %r = or i1 %not_null, %no_underflow - ret i1 %r -} - -; Likewise, if we are checking that we both got null and overflow happened, -; it makes no sense and is always false. - -define i1 @t12(i8 %base, i8 %offset) { -; CHECK-LABEL: @t12( -; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] -; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) -; CHECK-NEXT: [[UNDERFLOW:%.*]] = icmp ult i8 [[BASE]], [[OFFSET]] -; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) -; CHECK-NEXT: [[NULL:%.*]] = icmp eq i8 [[ADJUSTED]], 0 -; CHECK-NEXT: call void @use1(i1 [[NULL]]) -; CHECK-NEXT: [[R:%.*]] = and i1 [[NULL]], [[UNDERFLOW]] -; CHECK-NEXT: ret i1 [[R]] -; - %adjusted = sub i8 %base, %offset - call void @use8(i8 %adjusted) - %underflow = icmp ult i8 %base, %offset - call void @use1(i1 %underflow) - %null = icmp eq i8 %adjusted, 0 - call void @use1(i1 %null) - %r = and i1 %null, %underflow - ret i1 %r -} -define i1 @t12_nonstrict_bad(i8 %base, i8 %offset) { -; CHECK-LABEL: @t12_nonstrict_bad( -; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] -; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) -; CHECK-NEXT: [[UNDERFLOW:%.*]] = icmp uge i8 [[ADJUSTED]], [[BASE]] -; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) -; CHECK-NEXT: [[NULL:%.*]] = icmp eq i8 [[ADJUSTED]], 0 -; CHECK-NEXT: call void @use1(i1 [[NULL]]) -; CHECK-NEXT: [[R:%.*]] = and i1 [[NULL]], [[UNDERFLOW]] -; CHECK-NEXT: ret i1 [[R]] -; - %adjusted = sub i8 %base, %offset - call void @use8(i8 %adjusted) - %underflow = icmp uge i8 %adjusted, %base ; but not for non-strict predicate - call void @use1(i1 %underflow) - %null = icmp eq i8 %adjusted, 0 - call void @use1(i1 %null) - %r = and i1 %null, %underflow - ret i1 %r -} - -define i1 @t13(i8 %base, i8 %offset) { -; CHECK-LABEL: @t13( -; CHECK-NEXT: [[AGG:%.*]] = call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[BASE:%.*]], i8 [[OFFSET:%.*]]) -; CHECK-NEXT: call void @useagg({ i8, i1 } [[AGG]]) -; CHECK-NEXT: [[ADJUSTED:%.*]] = extractvalue { i8, i1 } [[AGG]], 0 -; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) -; CHECK-NEXT: [[UNDERFLOW:%.*]] = extractvalue { i8, i1 } [[AGG]], 1 -; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) -; CHECK-NEXT: [[NULL:%.*]] = icmp eq i8 [[ADJUSTED]], 0 -; CHECK-NEXT: [[R:%.*]] = and i1 [[NULL]], [[UNDERFLOW]] -; CHECK-NEXT: ret i1 [[R]] -; - %agg = call {i8, i1} @llvm.usub.with.overflow(i8 %base, i8 %offset) - call void @useagg({i8, i1} %agg) - %adjusted = extractvalue {i8, i1} %agg, 0 - call void @use8(i8 %adjusted) - %underflow = extractvalue {i8, i1} %agg, 1 - call void @use1(i1 %underflow) - %null = icmp eq i8 %adjusted, 0 - %r = and i1 %null, %underflow - ret i1 %r -} - -;------------------------------------------------------------------------------- - -define i1 @t15(i64 %base, i64* nonnull %offsetptr) { -; CHECK-LABEL: @t15( ; CHECK-NEXT: [[OFFSET:%.*]] = ptrtoint i64* [[OFFSETPTR:%.*]] to i64 ; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i64 [[BASE:%.*]], [[OFFSET]] ; CHECK-NEXT: call void @use64(i64 [[ADJUSTED]]) @@ -450,8 +310,8 @@ define i1 @t15(i64 %base, i64* nonnull %offsetptr) { %r = and i1 %not_null, %no_underflow ret i1 %r } -define i1 @t16_commutative(i64 %base, i64* nonnull %offsetptr) { -; CHECK-LABEL: @t16_commutative( +define i1 @t11_commutative(i64 %base, i64* nonnull %offsetptr) { +; CHECK-LABEL: @t11_commutative( ; CHECK-NEXT: [[OFFSET:%.*]] = ptrtoint i64* [[OFFSETPTR:%.*]] to i64 ; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i64 [[BASE:%.*]], [[OFFSET]] ; CHECK-NEXT: call void @use64(i64 [[ADJUSTED]]) @@ -474,8 +334,8 @@ define i1 @t16_commutative(i64 %base, i64* nonnull %offsetptr) { ret i1 %r } -define i1 @t17(i64 %base, i64* nonnull %offsetptr) { -; CHECK-LABEL: @t17( +define i1 @t12(i64 %base, i64* nonnull %offsetptr) { +; CHECK-LABEL: @t12( ; CHECK-NEXT: [[OFFSET:%.*]] = ptrtoint i64* [[OFFSETPTR:%.*]] to i64 ; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i64 [[BASE:%.*]], [[OFFSET]] ; CHECK-NEXT: call void @use64(i64 [[ADJUSTED]]) @@ -497,8 +357,8 @@ define i1 @t17(i64 %base, i64* nonnull %offsetptr) { %r = or i1 %not_null, %no_underflow ret i1 %r } -define i1 @t18(i64 %base, i64* nonnull %offsetptr) { -; CHECK-LABEL: @t18( +define i1 @t13(i64 %base, i64* nonnull %offsetptr) { +; CHECK-LABEL: @t13( ; CHECK-NEXT: [[OFFSET:%.*]] = ptrtoint i64* [[OFFSETPTR:%.*]] to i64 ; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i64 [[BASE:%.*]], [[OFFSET]] ; CHECK-NEXT: call void @use64(i64 [[ADJUSTED]]) @@ -521,8 +381,8 @@ define i1 @t18(i64 %base, i64* nonnull %offsetptr) { ret i1 %r } -define i1 @t19_bad(i64 %base, i64 %offset) { -; CHECK-LABEL: @t19_bad( +define i1 @t14_bad(i64 %base, i64 %offset) { +; CHECK-LABEL: @t14_bad( ; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i64 [[BASE:%.*]], [[OFFSET:%.*]] ; CHECK-NEXT: call void @use64(i64 [[ADJUSTED]]) ; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp ult i64 [[ADJUSTED]], [[BASE]] diff --git a/llvm/test/Transforms/InstSimplify/result-of-usub-is-non-zero-and-no-overflow.ll b/llvm/test/Transforms/InstSimplify/result-of-usub-is-non-zero-and-no-overflow.ll new file mode 100644 index 0000000..66ff797 --- /dev/null +++ b/llvm/test/Transforms/InstSimplify/result-of-usub-is-non-zero-and-no-overflow.ll @@ -0,0 +1,140 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt %s -instsimplify -S | FileCheck %s + +; Here we subtract two values, check that subtraction did not overflow AND +; that the result is non-zero. This can be simplified just to a comparison +; between the base and offset. + +declare void @use8(i8) +declare void @use64(i64) +declare void @use1(i1) + +declare void @llvm.assume(i1) + +; If we are checking that we either did not get null or got no overflow, +; this is tautological and is always true. + +define i1 @t1(i8 %base, i8 %offset) { +; CHECK-LABEL: @t1( +; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] +; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) +; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp uge i8 [[BASE]], [[OFFSET]] +; CHECK-NEXT: call void @use1(i1 [[NO_UNDERFLOW]]) +; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[ADJUSTED]], 0 +; CHECK-NEXT: call void @use1(i1 [[NOT_NULL]]) +; CHECK-NEXT: [[R:%.*]] = or i1 [[NOT_NULL]], [[NO_UNDERFLOW]] +; CHECK-NEXT: ret i1 [[R]] +; + %adjusted = sub i8 %base, %offset + call void @use8(i8 %adjusted) + %no_underflow = icmp uge i8 %base, %offset + call void @use1(i1 %no_underflow) + %not_null = icmp ne i8 %adjusted, 0 + call void @use1(i1 %not_null) + %r = or i1 %not_null, %no_underflow + ret i1 %r +} +define i1 @t1_strict_bad(i8 %base, i8 %offset) { +; CHECK-LABEL: @t1_strict_bad( +; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] +; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) +; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp ugt i8 [[BASE]], [[OFFSET]] +; CHECK-NEXT: call void @use1(i1 [[NO_UNDERFLOW]]) +; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[ADJUSTED]], 0 +; CHECK-NEXT: call void @use1(i1 [[NOT_NULL]]) +; CHECK-NEXT: [[R:%.*]] = or i1 [[NOT_NULL]], [[NO_UNDERFLOW]] +; CHECK-NEXT: ret i1 [[R]] +; + %adjusted = sub i8 %base, %offset + call void @use8(i8 %adjusted) + %no_underflow = icmp ugt i8 %base, %offset ; but not for non-strict predicate + call void @use1(i1 %no_underflow) + %not_null = icmp ne i8 %adjusted, 0 + call void @use1(i1 %not_null) + %r = or i1 %not_null, %no_underflow + ret i1 %r +} +define i1 @t1_commutativity(i8 %base, i8 %offset) { +; CHECK-LABEL: @t1_commutativity( +; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] +; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) +; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp ule i8 [[OFFSET]], [[BASE]] +; CHECK-NEXT: call void @use1(i1 [[NO_UNDERFLOW]]) +; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[ADJUSTED]], 0 +; CHECK-NEXT: call void @use1(i1 [[NOT_NULL]]) +; CHECK-NEXT: [[R:%.*]] = or i1 [[NOT_NULL]], [[NO_UNDERFLOW]] +; CHECK-NEXT: ret i1 [[R]] +; + %adjusted = sub i8 %base, %offset + call void @use8(i8 %adjusted) + %no_underflow = icmp ule i8 %offset, %base + call void @use1(i1 %no_underflow) + %not_null = icmp ne i8 %adjusted, 0 + call void @use1(i1 %not_null) + %r = or i1 %not_null, %no_underflow + ret i1 %r +} + +; Likewise, if we are checking that we both got null and overflow happened, +; it makes no sense and is always false. + +define i1 @t2(i8 %base, i8 %offset) { +; CHECK-LABEL: @t2( +; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] +; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) +; CHECK-NEXT: [[UNDERFLOW:%.*]] = icmp ult i8 [[BASE]], [[OFFSET]] +; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) +; CHECK-NEXT: [[NULL:%.*]] = icmp eq i8 [[ADJUSTED]], 0 +; CHECK-NEXT: call void @use1(i1 [[NULL]]) +; CHECK-NEXT: [[R:%.*]] = and i1 [[NULL]], [[UNDERFLOW]] +; CHECK-NEXT: ret i1 [[R]] +; + %adjusted = sub i8 %base, %offset + call void @use8(i8 %adjusted) + %underflow = icmp ult i8 %base, %offset + call void @use1(i1 %underflow) + %null = icmp eq i8 %adjusted, 0 + call void @use1(i1 %null) + %r = and i1 %null, %underflow + ret i1 %r +} +define i1 @t2_nonstrict_bad(i8 %base, i8 %offset) { +; CHECK-LABEL: @t2_nonstrict_bad( +; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] +; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) +; CHECK-NEXT: [[UNDERFLOW:%.*]] = icmp uge i8 [[ADJUSTED]], [[BASE]] +; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) +; CHECK-NEXT: [[NULL:%.*]] = icmp eq i8 [[ADJUSTED]], 0 +; CHECK-NEXT: call void @use1(i1 [[NULL]]) +; CHECK-NEXT: [[R:%.*]] = and i1 [[NULL]], [[UNDERFLOW]] +; CHECK-NEXT: ret i1 [[R]] +; + %adjusted = sub i8 %base, %offset + call void @use8(i8 %adjusted) + %underflow = icmp uge i8 %adjusted, %base ; but not for non-strict predicate + call void @use1(i1 %underflow) + %null = icmp eq i8 %adjusted, 0 + call void @use1(i1 %null) + %r = and i1 %null, %underflow + ret i1 %r +} +define i1 @t2_commutativity(i8 %base, i8 %offset) { +; CHECK-LABEL: @t2_commutativity( +; CHECK-NEXT: [[ADJUSTED:%.*]] = sub i8 [[BASE:%.*]], [[OFFSET:%.*]] +; CHECK-NEXT: call void @use8(i8 [[ADJUSTED]]) +; CHECK-NEXT: [[UNDERFLOW:%.*]] = icmp ugt i8 [[OFFSET]], [[BASE]] +; CHECK-NEXT: call void @use1(i1 [[UNDERFLOW]]) +; CHECK-NEXT: [[NULL:%.*]] = icmp eq i8 [[ADJUSTED]], 0 +; CHECK-NEXT: call void @use1(i1 [[NULL]]) +; CHECK-NEXT: [[R:%.*]] = and i1 [[NULL]], [[UNDERFLOW]] +; CHECK-NEXT: ret i1 [[R]] +; + %adjusted = sub i8 %base, %offset + call void @use8(i8 %adjusted) + %underflow = icmp ugt i8 %offset, %base + call void @use1(i1 %underflow) + %null = icmp eq i8 %adjusted, 0 + call void @use1(i1 %null) + %r = and i1 %null, %underflow + ret i1 %r +} -- 2.7.4