Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 1, 2024
Merged

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions llvm/include/llvm/Support/KnownBits.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down
16 changes: 16 additions & 0 deletions llvm/lib/Support/KnownBits.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -176,6 +176,22 @@ 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 MinMaxDiff = computeForAddSub(false, false, UMaxValue, UMinValue);

// find the common bits between sub(LHS,RHS) and sub(RHS,LHS).
KnownBits Diff0 = computeForAddSub(false, false, LHS, RHS);
KnownBits Diff1 = computeForAddSub(false, false, RHS, LHS);
KnownBits SubDiff = Diff0.intersectWith(Diff1);

KnownBits KnownAbsDiff = MinMaxDiff.unionWith(SubDiff);
assert(!KnownAbsDiff.hasConflict() && "Bad Output");
Copy link
Contributor

@goldsteinn goldsteinn Feb 26, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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();
...

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

See: PR #83382

return KnownAbsDiff;
}

static unsigned getMaxShiftAmount(const APInt &MaxValue, unsigned BitWidth) {
if (isPowerOf2_32(BitWidth))
return MaxValue.extractBitsAsZExtValue(Log2_32(BitWidth), 0);
Expand Down
35 changes: 34 additions & 1 deletion llvm/unittests/Support/KnownBitsTest.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -244,6 +244,32 @@ TEST(KnownBitsTest, SubBorrowExhaustive) {
});
}

TEST(KnownBitsTest, AbsDiffSpecialCase) {
// There are 2 implementation of absdiff - both are currently needed to cover
// extra cases.
KnownBits LHS, RHS, Res;

// absdiff(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::absdiff(LHS, RHS);
EXPECT_EQ(0b0000, Res.One.getZExtValue());
EXPECT_EQ(0b1110, 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::absdiff(LHS, RHS);
EXPECT_EQ(0b0001, Res.One.getZExtValue());
EXPECT_EQ(0b0000, Res.Zero.getZExtValue());
}
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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


TEST(KnownBitsTest, BinaryExhaustive) {
testBinaryOpExhaustive(
[](const KnownBits &Known1, const KnownBits &Known2) {
Expand Down Expand Up @@ -281,7 +307,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);
Expand Down