[llvm] d8a26ca - [KnownBits] Make abdu and abds optimal (#89081)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 18 08:27:06 PDT 2024
Author: Jay Foad
Date: 2024-04-18T16:27:02+01:00
New Revision: d8a26ca323977035969813b0e1e9fb54fd334620
URL: https://github.com/llvm/llvm-project/commit/d8a26ca323977035969813b0e1e9fb54fd334620
DIFF: https://github.com/llvm/llvm-project/commit/d8a26ca323977035969813b0e1e9fb54fd334620.diff
LOG: [KnownBits] Make abdu and abds optimal (#89081)
Fixes #84212
Added:
Modified:
llvm/include/llvm/Support/KnownBits.h
llvm/lib/Support/KnownBits.cpp
llvm/unittests/Support/KnownBitsTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Support/KnownBits.h b/llvm/include/llvm/Support/KnownBits.h
index 73cb01e0644a8d..9b7f405b625642 100644
--- a/llvm/include/llvm/Support/KnownBits.h
+++ b/llvm/include/llvm/Support/KnownBits.h
@@ -394,7 +394,7 @@ struct KnownBits {
static KnownBits abdu(const KnownBits &LHS, const KnownBits &RHS);
/// Compute known bits for abds(LHS, RHS).
- static KnownBits abds(const KnownBits &LHS, const KnownBits &RHS);
+ static KnownBits abds(KnownBits LHS, KnownBits RHS);
/// Compute known bits for shl(LHS, RHS).
/// NOTE: RHS (shift amount) bitwidth doesn't need to be the same as LHS.
diff --git a/llvm/lib/Support/KnownBits.cpp b/llvm/lib/Support/KnownBits.cpp
index d72355dab6f1d3..fe47884f3e55ac 100644
--- a/llvm/lib/Support/KnownBits.cpp
+++ b/llvm/lib/Support/KnownBits.cpp
@@ -232,41 +232,53 @@ KnownBits KnownBits::smin(const KnownBits &LHS, const KnownBits &RHS) {
}
KnownBits KnownBits::abdu(const KnownBits &LHS, const KnownBits &RHS) {
- // abdu(LHS,RHS) = sub(umax(LHS,RHS), umin(LHS,RHS)).
- KnownBits UMaxValue = umax(LHS, RHS);
- KnownBits UMinValue = umin(LHS, RHS);
- KnownBits MinMaxDiff = computeForAddSub(/*Add=*/false, /*NSW=*/false,
- /*NUW=*/true, UMaxValue, UMinValue);
+ // If we know which argument is larger, return (sub LHS, RHS) or
+ // (sub RHS, LHS) directly.
+ if (LHS.getMinValue().uge(RHS.getMaxValue()))
+ return computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, LHS,
+ RHS);
+ if (RHS.getMinValue().uge(LHS.getMaxValue()))
+ return computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, RHS,
+ LHS);
- // find the common bits between sub(LHS,RHS) and sub(RHS,LHS).
+ // By construction, the subtraction in abdu never has unsigned overflow.
+ // Find the common bits between (sub nuw LHS, RHS) and (sub nuw RHS, LHS).
KnownBits Diff0 =
- computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, LHS, RHS);
+ computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/true, LHS, RHS);
KnownBits Diff1 =
- computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, RHS, LHS);
- KnownBits SubDiff = Diff0.intersectWith(Diff1);
-
- KnownBits KnownAbsDiff = MinMaxDiff.unionWith(SubDiff);
- assert(!KnownAbsDiff.hasConflict() && "Bad Output");
- return KnownAbsDiff;
+ computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/true, RHS, LHS);
+ return Diff0.intersectWith(Diff1);
}
-KnownBits KnownBits::abds(const KnownBits &LHS, const KnownBits &RHS) {
- // abds(LHS,RHS) = sub(smax(LHS,RHS), smin(LHS,RHS)).
- KnownBits SMaxValue = smax(LHS, RHS);
- KnownBits SMinValue = smin(LHS, RHS);
- KnownBits MinMaxDiff = computeForAddSub(/*Add=*/false, /*NSW=*/false,
- /*NUW=*/false, SMaxValue, SMinValue);
+KnownBits KnownBits::abds(KnownBits LHS, KnownBits RHS) {
+ // If we know which argument is larger, return (sub LHS, RHS) or
+ // (sub RHS, LHS) directly.
+ if (LHS.getSignedMinValue().sge(RHS.getSignedMaxValue()))
+ return computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, LHS,
+ RHS);
+ if (RHS.getSignedMinValue().sge(LHS.getSignedMaxValue()))
+ return computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, RHS,
+ LHS);
+
+ // Shift both arguments from the signed range to the unsigned range, e.g. from
+ // [-0x80, 0x7F] to [0, 0xFF]. This allows us to use "sub nuw" below just like
+ // abdu does.
+ // Note that we can't just use "sub nsw" instead because abds has signed
+ // inputs but an unsigned result, which makes the overflow conditions
+ //
diff erent.
+ unsigned SignBitPosition = LHS.getBitWidth() - 1;
+ for (auto Arg : {&LHS, &RHS}) {
+ bool Tmp = Arg->Zero[SignBitPosition];
+ Arg->Zero.setBitVal(SignBitPosition, Arg->One[SignBitPosition]);
+ Arg->One.setBitVal(SignBitPosition, Tmp);
+ }
- // find the common bits between sub(LHS,RHS) and sub(RHS,LHS).
+ // Find the common bits between (sub nuw LHS, RHS) and (sub nuw RHS, LHS).
KnownBits Diff0 =
- computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, LHS, RHS);
+ computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/true, LHS, RHS);
KnownBits Diff1 =
- computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/false, RHS, LHS);
- KnownBits SubDiff = Diff0.intersectWith(Diff1);
-
- KnownBits KnownAbsDiff = MinMaxDiff.unionWith(SubDiff);
- assert(!KnownAbsDiff.hasConflict() && "Bad Output");
- return KnownAbsDiff;
+ computeForAddSub(/*Add=*/false, /*NSW=*/false, /*NUW=*/true, RHS, LHS);
+ return Diff0.intersectWith(Diff1);
}
static unsigned getMaxShiftAmount(const APInt &MaxValue, unsigned BitWidth) {
diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp
index 027d6379af26b0..8049517acc9fa0 100644
--- a/llvm/unittests/Support/KnownBitsTest.cpp
+++ b/llvm/unittests/Support/KnownBitsTest.cpp
@@ -294,58 +294,6 @@ TEST(KnownBitsTest, SignBitUnknown) {
EXPECT_TRUE(Known.isSignUnknown());
}
-TEST(KnownBitsTest, ABDUSpecialCase) {
- // There are 2 implementations of abdu - both are currently needed to cover
- // extra cases.
- KnownBits LHS, RHS, Res;
-
- // abdu(LHS,RHS) = sub(umax(LHS,RHS), umin(LHS,RHS)).
- // Actual: false (Inputs = 1011, 101?, Computed = 000?, Exact = 000?)
- LHS.One = APInt(4, 0b1011);
- RHS.One = APInt(4, 0b1010);
- LHS.Zero = APInt(4, 0b0100);
- RHS.Zero = APInt(4, 0b0100);
- Res = KnownBits::abdu(LHS, RHS);
- EXPECT_EQ(0b0000ul, Res.One.getZExtValue());
- EXPECT_EQ(0b1110ul, Res.Zero.getZExtValue());
-
- // find the common bits between sub(LHS,RHS) and sub(RHS,LHS).
- // Actual: false (Inputs = ???1, 1000, Computed = ???1, Exact = 0??1)
- LHS.One = APInt(4, 0b0001);
- RHS.One = APInt(4, 0b1000);
- LHS.Zero = APInt(4, 0b0000);
- RHS.Zero = APInt(4, 0b0111);
- Res = KnownBits::abdu(LHS, RHS);
- EXPECT_EQ(0b0001ul, Res.One.getZExtValue());
- EXPECT_EQ(0b0000ul, Res.Zero.getZExtValue());
-}
-
-TEST(KnownBitsTest, ABDSSpecialCase) {
- // There are 2 implementations of abds - both are currently needed to cover
- // extra cases.
- KnownBits LHS, RHS, Res;
-
- // abds(LHS,RHS) = sub(smax(LHS,RHS), smin(LHS,RHS)).
- // Actual: false (Inputs = 1011, 10??, Computed = ????, Exact = 00??)
- LHS.One = APInt(4, 0b1011);
- RHS.One = APInt(4, 0b1000);
- LHS.Zero = APInt(4, 0b0100);
- RHS.Zero = APInt(4, 0b0100);
- Res = KnownBits::abds(LHS, RHS);
- EXPECT_EQ(0, Res.One.getSExtValue());
- EXPECT_EQ(-4, Res.Zero.getSExtValue());
-
- // find the common bits between sub(LHS,RHS) and sub(RHS,LHS).
- // Actual: false (Inputs = ???1, 1000, Computed = ???1, Exact = 0??1)
- LHS.One = APInt(4, 0b0001);
- RHS.One = APInt(4, 0b1000);
- LHS.Zero = APInt(4, 0b0000);
- RHS.Zero = APInt(4, 0b0111);
- Res = KnownBits::abds(LHS, RHS);
- EXPECT_EQ(1, Res.One.getSExtValue());
- EXPECT_EQ(0, Res.Zero.getSExtValue());
-}
-
TEST(KnownBitsTest, BinaryExhaustive) {
testBinaryOpExhaustive(
[](const KnownBits &Known1, const KnownBits &Known2) {
@@ -366,10 +314,8 @@ TEST(KnownBitsTest, BinaryExhaustive) {
testBinaryOpExhaustive(KnownBits::umin, APIntOps::umin);
testBinaryOpExhaustive(KnownBits::smax, APIntOps::smax);
testBinaryOpExhaustive(KnownBits::smin, APIntOps::smin);
- testBinaryOpExhaustive(KnownBits::abdu, APIntOps::abdu,
- checkCorrectnessOnlyBinary);
- testBinaryOpExhaustive(KnownBits::abds, APIntOps::abds,
- checkCorrectnessOnlyBinary);
+ testBinaryOpExhaustive(KnownBits::abdu, APIntOps::abdu);
+ testBinaryOpExhaustive(KnownBits::abds, APIntOps::abds);
testBinaryOpExhaustive(
[](const KnownBits &Known1, const KnownBits &Known2) {
return KnownBits::udiv(Known1, Known2);
More information about the llvm-commits
mailing list