Skip to content
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

Jump to bottom

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

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
+163 −12
Open

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
786df0c
ValueTracking/test: cover known bits of mul
artagnon Oct 19, 2024
a9edba0
KnownBits: refine high-bits of mul in signed case
artagnon Oct 18, 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
32 changes: 20 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,26 @@ 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
// 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();

// 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);
bool NegResult = LHS.isNegative() ^ RHS.isNegative();
unsigned LeadZ = 0, LeadO = 0;
if (!HasOverflow) {
// Do not set leading ones unless the result is known to be non-zero.
if (NegResult && LHS.isNonZero() && RHS.isNonZero())
LeadO = (-Result).countLeadingOnes();
else if (!NegResult)
LeadZ = Result.countLeadingZeros();
}

// 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 +880,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
}
Loading