Skip to content

KnownBits: refine high-bits of mul in signed case #113051

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

Closed
wants to merge 4 commits into from
Closed

KnownBits: refine high-bits of mul in signed case #113051

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
9459ba9
ValueTracking/test: cover known bits of mul
artagnon Oct 19, 2024
b6b0cfd
KnownBits: refine high-bits of mul in signed case
artagnon Oct 18, 2024
901b6e5
KnownBitsTest: cover in unittests; address review
artagnon Oct 23, 2024
603ec71
KnownBits: address review; more concise
artagnon Oct 23, 2024
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
31 changes: 19 additions & 12 deletions llvm/lib/Support/KnownBits.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -796,19 +796,25 @@ KnownBits KnownBits::mul(const KnownBits &LHS, const KnownBits &RHS,
assert((!NoUndefSelfMultiply || LHS == RHS) &&
"Self multiplication knownbits mismatch");

// Compute the high known-0 bits by multiplying the unsigned max of each side.
// Conservatively, M active bits * N active bits results in M + N bits in the
// result. But if we know a value is a power-of-2 for example, then this
// computes one more leading zero.
// TODO: This could be generalized to number of sign bits (negative numbers).
APInt UMaxLHS = LHS.getMaxValue();
APInt UMaxRHS = RHS.getMaxValue();

// For leading zeros in the result to be valid, the unsigned max product must
// Compute the high known-0 or known-1 bits by multiplying the max of each
Copy link
Contributor

Choose a reason for hiding this comment

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

I think you can wrap the whole of this section in if (!LHS.isSignUnknown() && !RHS.isSignUnknown). If either sign was unknown then we would not get any useful high-zeros or high-ones info from this calculation. That would resolve my confusion about your use of isNegative below by making it clear that there is no "unknown sign" case to worry about - both operand are known negative or known positive.

// side. Conservatively, M active bits * N active bits results in M + N bits
// in the result. But if we know a value is a power-of-2 for example, then
// this computes one more leading zero or one.
APInt MaxLHS = LHS.isNegative() ? LHS.getMinValue().abs() : LHS.getMaxValue(),
MaxRHS = RHS.isNegative() ? RHS.getMinValue().abs() : RHS.getMaxValue();
Comment on lines +803 to +804
Copy link
Contributor

Choose a reason for hiding this comment

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

Can you remove the .abs() calls here and use smul_ov below instead?


// For leading zeros or ones in the result to be valid, the max product must
// fit in the bitwidth (it must not overflow).
bool HasOverflow;
APInt UMaxResult = UMaxLHS.umul_ov(UMaxRHS, HasOverflow);
unsigned LeadZ = HasOverflow ? 0 : UMaxResult.countl_zero();
APInt Result = MaxLHS.umul_ov(MaxRHS, HasOverflow);
unsigned LeadZ = 0, LeadO = 0;
if (!HasOverflow) {
if (LHS.isNegative() == RHS.isNegative())
LeadZ = Result.countLeadingZeros();
// Do not set leading ones unless the result is known to be non-zero.
else if (LHS.isNonZero() && RHS.isNonZero())
LeadO = (-Result).countLeadingOnes();
}

// The result of the bottom bits of an integer multiply can be
// inferred by looking at the bottom bits of both operands and
Expand Down Expand Up @@ -873,8 +879,9 @@ KnownBits KnownBits::mul(const KnownBits &LHS, const KnownBits &RHS,

KnownBits Res(BitWidth);
Res.Zero.setHighBits(LeadZ);
Res.One.setHighBits(LeadO);
Res.Zero |= (~BottomKnown).getLoBits(ResultBitsKnown);
Res.One = BottomKnown.getLoBits(ResultBitsKnown);
Res.One |= BottomKnown.getLoBits(ResultBitsKnown);

// If we're self-multiplying then bit[1] is guaranteed to be zero.
if (NoUndefSelfMultiply && BitWidth > 1) {
Expand Down
143 changes: 143 additions & 0 deletions llvm/test/Analysis/ValueTracking/knownbits-mul.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,143 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes=instcombine -S | FileCheck %s

define i8 @mul_low_bits_know(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_low_bits_know(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: ret i8 0
;
%x = and i8 %xx, 2
%y = and i8 %yy, 4
%mul = mul i8 %x, %y
%r = and i8 %mul, 6
ret i8 %r
}

define i8 @mul_low_bits_know2(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_low_bits_know2(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: ret i8 0
;
%x = or i8 %xx, -2
%y = and i8 %yy, 4
%mul = mul i8 %x, %y
%r = and i8 %mul, 2
ret i8 %r
}

define i8 @mul_low_bits_partially_known(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_low_bits_partially_known(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: [[Y:%.*]] = or i8 [[YY]], 2
; CHECK-NEXT: [[MUL:%.*]] = sub nsw i8 0, [[Y]]
; CHECK-NEXT: [[R:%.*]] = and i8 [[MUL]], 2
; CHECK-NEXT: ret i8 [[R]]
;
%x = or i8 %xx, -4
%x.notsmin = or i8 %x, 3
%y = or i8 %yy, -2
%mul = mul i8 %x.notsmin, %y
%r = and i8 %mul, 6
ret i8 %r
}

define i8 @mul_low_bits_unknown(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_low_bits_unknown(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: [[X:%.*]] = or i8 [[XX]], 4
; CHECK-NEXT: [[Y:%.*]] = or i8 [[YY]], 6
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X]], [[Y]]
; CHECK-NEXT: [[R:%.*]] = and i8 [[MUL]], 6
; CHECK-NEXT: ret i8 [[R]]
;
%x = or i8 %xx, -4
%y = or i8 %yy, -2
%mul = mul i8 %x, %y
%r = and i8 %mul, 6
ret i8 %r
}

define i8 @mul_high_bits_know(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_high_bits_know(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: ret i8 0
;
%x = and i8 %xx, 2
%y = and i8 %yy, 4
%mul = mul i8 %x, %y
%r = and i8 %mul, 16
ret i8 %r
}

define i8 @mul_high_bits_know2(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_high_bits_know2(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: ret i8 -16
;
%x = or i8 %xx, -2
%y = and i8 %yy, 4
%y.nonzero = or i8 %y, 1
%mul = mul i8 %x, %y.nonzero
%r = and i8 %mul, -16
ret i8 %r
}

define i8 @mul_high_bits_know3(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_high_bits_know3(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: ret i8 0
;
%x = or i8 %xx, -4
%y = or i8 %yy, -2
%mul = mul i8 %x, %y
%r = and i8 %mul, -16
ret i8 %r
}

define i8 @mul_high_bits_unknown(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_high_bits_unknown(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: [[X:%.*]] = and i8 [[XX]], 2
; CHECK-NEXT: [[Y:%.*]] = and i8 [[YY]], 4
; CHECK-NEXT: [[MUL:%.*]] = mul nuw nsw i8 [[X]], [[Y]]
; CHECK-NEXT: ret i8 [[MUL]]
;
%x = and i8 %xx, 2
%y = and i8 %yy, 4
%mul = mul i8 %x, %y
%r = and i8 %mul, 8
ret i8 %r
}

define i8 @mul_high_bits_unknown2(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_high_bits_unknown2(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: [[X:%.*]] = or i8 [[XX]], -2
; CHECK-NEXT: [[Y:%.*]] = and i8 [[YY]], 4
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[X]], [[Y]]
; CHECK-NEXT: [[R:%.*]] = and i8 [[MUL]], -16
; CHECK-NEXT: ret i8 [[R]]
;
%x = or i8 %xx, -2
%y = and i8 %yy, 4
%mul = mul i8 %x, %y
%r = and i8 %mul, -16
ret i8 %r
}

; TODO: This can be reduced to zero.
define i8 @mul_high_bits_unknown3(i8 %xx, i8 %yy) {
; CHECK-LABEL: define i8 @mul_high_bits_unknown3(
; CHECK-SAME: i8 [[XX:%.*]], i8 [[YY:%.*]]) {
; CHECK-NEXT: [[X:%.*]] = or i8 [[XX]], 28
; CHECK-NEXT: [[Y:%.*]] = or i8 [[YY]], 30
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[X]], [[Y]]
; CHECK-NEXT: [[R:%.*]] = and i8 [[MUL]], 16
; CHECK-NEXT: ret i8 [[R]]
;
%x = or i8 %xx, -4
%y = or i8 %yy, -2
%mul = mul i8 %x, %y
%r = and i8 %mul, 16
ret i8 %r
}
52 changes: 51 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 @@ -815,7 +815,7 @@ TEST(KnownBitsTest, ConcatBits) {
}
}

TEST(KnownBitsTest, MulExhaustive) {
TEST(KnownBitsTest, MulLowBitsExhaustive) {
for (unsigned Bits : {1, 4}) {
ForeachKnownBits(Bits, [&](const KnownBits &Known1) {
ForeachKnownBits(Bits, [&](const KnownBits &Known2) {
Expand Down Expand Up @@ -849,4 +849,54 @@ TEST(KnownBitsTest, MulExhaustive) {
}
}

TEST(KnownBitsTest, MulHighBits) {
unsigned Bits = 8;
SmallVector<std::pair<int, int>, 4> TestPairs = {
{2, 4}, {-2, -4}, {2, -4}, {-2, 4}};
for (auto [K1, K2] : TestPairs) {
KnownBits Known1(Bits), Known2(Bits);
if (K1 > 0) {
// If we only set the zeros of ~K1, Known1 could be zero. Avoid this case,
// as we can only set leading ones in the case where LHS and RHS have
// different signs, when the result is known non-zero.
Known1.Zero |= ~(K1 | 1);
Known1.One |= 1;
} else {
Known1.One |= K1;
}
if (K2 > 0) {
// If we only set the zeros of ~K1, Known1 could be zero. Avoid this case,
// as we can only set leading ones in the case where LHS and RHS have
// different signs, when the result is known non-zero.
Known2.Zero |= ~(K2 | 1);
Known2.One |= 1;
} else {
Known2.One |= K2;
}
KnownBits Computed = KnownBits::mul(Known1, Known2);
KnownBits Exact(Bits);
Exact.Zero.setAllBits();
Exact.One.setAllBits();

ForeachNumInKnownBits(Known1, [&](const APInt &N1) {
ForeachNumInKnownBits(Known2, [&](const APInt &N2) {
APInt Res = N1 * N2;
Exact.One &= Res;
Exact.Zero &= ~Res;
});
});

// Check that the high bits are optimal, with the caveat that mul_ov of LHS
// and RHS doesn't overflow, which is the case for our TestPairs.
APInt Mask = APInt::getHighBitsSet(
Bits, (Exact.Zero | Exact.One).countLeadingOnes());
Exact.Zero &= Mask;
Exact.One &= Mask;
Computed.Zero &= Mask;
Computed.One &= Mask;
EXPECT_TRUE(checkResult("mul", Exact, Computed, {Known1, Known2},
/*CheckOptimality=*/true));
}
}

} // end anonymous namespace
Loading