[KnownBits] Add KnownBits::absdiff to compute the absolute difference of 2 unsigned values

[RKSimon]

Equivalent to "umax(A, B) - umin(A, B)"

This is just an initial correctness implementation, hopefully we can make this optimal in the future.

[llvmbot]

@llvm/pr-subscribers-llvm-support

Author: Simon Pilgrim (RKSimon)

Changes

Equivalent to "umax(A, B) - umin(A, B)"

This is just an initial correctness implementation, hopefully we can make this optimal in the future.

---

Full diff: https://github.com/llvm/llvm-project/pull/82354.diff

3 Files Affected:

• (modified) llvm/include/llvm/Support/KnownBits.h (+3)
• (modified) llvm/lib/Support/KnownBits.cpp (+17)
• (modified) llvm/unittests/Support/KnownBitsTest.cpp (+8-1)

diff --git a/llvm/include/llvm/Support/KnownBits.h b/llvm/include/llvm/Support/KnownBits.h
index fb034e0b9e3baf..69c569b97ccae1 100644
--- a/llvm/include/llvm/Support/KnownBits.h
+++ b/llvm/include/llvm/Support/KnownBits.h
@@ -385,6 +385,9 @@ struct KnownBits {
   /// Compute known bits for smin(LHS, RHS).
   static KnownBits smin(const KnownBits &LHS, const KnownBits &RHS);
 
+  /// Compute known bits for absdiff(LHS, RHS).
+  static KnownBits absdiff(const KnownBits &LHS, const KnownBits &RHS);
+
   /// Compute known bits for shl(LHS, RHS).
   /// NOTE: RHS (shift amount) bitwidth doesn't need to be the same as LHS.
   static KnownBits shl(const KnownBits &LHS, const KnownBits &RHS,
diff --git a/llvm/lib/Support/KnownBits.cpp b/llvm/lib/Support/KnownBits.cpp
index 770e4051ca3ffa..e0ecdd56711959 100644
--- a/llvm/lib/Support/KnownBits.cpp
+++ b/llvm/lib/Support/KnownBits.cpp
@@ -176,6 +176,23 @@ KnownBits KnownBits::smin(const KnownBits &LHS, const KnownBits &RHS) {
   return Flip(umax(Flip(LHS), Flip(RHS)));
 }
 
+KnownBits KnownBits::absdiff(const KnownBits &LHS, const KnownBits &RHS) {
+  // absdiff(LHS,RHS) = sub(umax(LHS,RHS), umin(LHS,RHS)).
+  KnownBits UMaxValue = umax(LHS, RHS);
+  KnownBits UMinValue = umin(LHS, RHS);
+  KnownBits KnownAbsDiff = computeForAddSub(false, false, UMaxValue, UMinValue);
+
+  // fallback - find the common bits between sub(LHS,RHS) and sub(RHS,LHS).
+  if (KnownAbsDiff.isUnknown()) {
+    KnownBits Diff0 = computeForAddSub(false, false, LHS, RHS);
+    KnownBits Diff1 = computeForAddSub(false, false, RHS, LHS);
+    KnownAbsDiff = Diff0.intersectWith(Diff1);
+  }
+
+  assert(!KnownAbsDiff.hasConflict() && "Bad Output");
+  return KnownAbsDiff;
+}
+
 static unsigned getMaxShiftAmount(const APInt &MaxValue, unsigned BitWidth) {
   if (isPowerOf2_32(BitWidth))
     return MaxValue.extractBitsAsZExtValue(Log2_32(BitWidth), 0);
diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp
index c0377d45c303a1..dfa3fe06a32647 100644
--- a/llvm/unittests/Support/KnownBitsTest.cpp
+++ b/llvm/unittests/Support/KnownBitsTest.cpp
@@ -281,7 +281,14 @@ TEST(KnownBitsTest, BinaryExhaustive) {
         return KnownBits::smin(Known1, Known2);
       },
       [](const APInt &N1, const APInt &N2) { return APIntOps::smin(N1, N2); });
-
+  testBinaryOpExhaustive(
+      [](const KnownBits &Known1, const KnownBits &Known2) {
+        return KnownBits::absdiff(Known1, Known2);
+      },
+      [](const APInt &N1, const APInt &N2) {
+        return APIntOps::absdiff(N1, N2);
+      },
+      checkCorrectnessOnlyBinary);
   testBinaryOpExhaustive(
       [](const KnownBits &Known1, const KnownBits &Known2) {
         return KnownBits::udiv(Known1, Known2);

[goldsteinn]

Think you can get away with special casing high bits. Basically all high bits min(LHS.numSignBits(), RHS.numSignBits()) will always be zero.

edit: thats not right! The 1s/0s need to match. So a bit more complicate but like:

KnownBits Common = commonBits(LHS, RHS);
unsigned NumZerodHiBits = Common.countMinSignBits();
...

[RKSimon]

I'd prefer to work on "checkOptimalityBinary" cases in a future patch - the handling of leading bits still needs a bit of work - I think adding NUW handling to KnownBits::computeForAddSub might be the way to go.

[goldsteinn]

Okay, please leave it as a todo then. I agree it makes sense to add nuw flag in computeForAddSub

[goldsteinn]

Im working on a patch to support NUW for add/sub

[goldsteinn]

See: PR #83382

[RKSimon]

ping?

[goldsteinn]

Does this test provide anything that the exhaustive test doing already cover?

[RKSimon]

It was requested by @nikic - if you disable either of the computations then one of the tests will fail

[goldsteinn]

LGTM.