forked from OSchip/llvm-project
190 lines
6.7 KiB
C++
190 lines
6.7 KiB
C++
//===-- KnownBits.cpp - Stores known zeros/ones ---------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains a class for representing known zeros and ones used by
|
|
// computeKnownBits.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/KnownBits.h"
|
|
#include <cassert>
|
|
|
|
using namespace llvm;
|
|
|
|
static KnownBits computeForAddCarry(
|
|
const KnownBits &LHS, const KnownBits &RHS,
|
|
bool CarryZero, bool CarryOne) {
|
|
assert(!(CarryZero && CarryOne) &&
|
|
"Carry can't be zero and one at the same time");
|
|
|
|
APInt PossibleSumZero = LHS.getMaxValue() + RHS.getMaxValue() + !CarryZero;
|
|
APInt PossibleSumOne = LHS.getMinValue() + RHS.getMinValue() + CarryOne;
|
|
|
|
// Compute known bits of the carry.
|
|
APInt CarryKnownZero = ~(PossibleSumZero ^ LHS.Zero ^ RHS.Zero);
|
|
APInt CarryKnownOne = PossibleSumOne ^ LHS.One ^ RHS.One;
|
|
|
|
// Compute set of known bits (where all three relevant bits are known).
|
|
APInt LHSKnownUnion = LHS.Zero | LHS.One;
|
|
APInt RHSKnownUnion = RHS.Zero | RHS.One;
|
|
APInt CarryKnownUnion = std::move(CarryKnownZero) | CarryKnownOne;
|
|
APInt Known = std::move(LHSKnownUnion) & RHSKnownUnion & CarryKnownUnion;
|
|
|
|
assert((PossibleSumZero & Known) == (PossibleSumOne & Known) &&
|
|
"known bits of sum differ");
|
|
|
|
// Compute known bits of the result.
|
|
KnownBits KnownOut;
|
|
KnownOut.Zero = ~std::move(PossibleSumZero) & Known;
|
|
KnownOut.One = std::move(PossibleSumOne) & Known;
|
|
return KnownOut;
|
|
}
|
|
|
|
KnownBits KnownBits::computeForAddCarry(
|
|
const KnownBits &LHS, const KnownBits &RHS, const KnownBits &Carry) {
|
|
assert(Carry.getBitWidth() == 1 && "Carry must be 1-bit");
|
|
return ::computeForAddCarry(
|
|
LHS, RHS, Carry.Zero.getBoolValue(), Carry.One.getBoolValue());
|
|
}
|
|
|
|
KnownBits KnownBits::computeForAddSub(bool Add, bool NSW,
|
|
const KnownBits &LHS, KnownBits RHS) {
|
|
KnownBits KnownOut;
|
|
if (Add) {
|
|
// Sum = LHS + RHS + 0
|
|
KnownOut = ::computeForAddCarry(
|
|
LHS, RHS, /*CarryZero*/true, /*CarryOne*/false);
|
|
} else {
|
|
// Sum = LHS + ~RHS + 1
|
|
std::swap(RHS.Zero, RHS.One);
|
|
KnownOut = ::computeForAddCarry(
|
|
LHS, RHS, /*CarryZero*/false, /*CarryOne*/true);
|
|
}
|
|
|
|
// Are we still trying to solve for the sign bit?
|
|
if (!KnownOut.isNegative() && !KnownOut.isNonNegative()) {
|
|
if (NSW) {
|
|
// Adding two non-negative numbers, or subtracting a negative number from
|
|
// a non-negative one, can't wrap into negative.
|
|
if (LHS.isNonNegative() && RHS.isNonNegative())
|
|
KnownOut.makeNonNegative();
|
|
// Adding two negative numbers, or subtracting a non-negative number from
|
|
// a negative one, can't wrap into non-negative.
|
|
else if (LHS.isNegative() && RHS.isNegative())
|
|
KnownOut.makeNegative();
|
|
}
|
|
}
|
|
|
|
return KnownOut;
|
|
}
|
|
|
|
KnownBits KnownBits::makeGE(const APInt &Val) const {
|
|
// Count the number of leading bit positions where our underlying value is
|
|
// known to be less than or equal to Val.
|
|
unsigned N = (Zero | Val).countLeadingOnes();
|
|
|
|
// For each of those bit positions, if Val has a 1 in that bit then our
|
|
// underlying value must also have a 1.
|
|
APInt MaskedVal(Val);
|
|
MaskedVal.clearLowBits(getBitWidth() - N);
|
|
return KnownBits(Zero, One | MaskedVal);
|
|
}
|
|
|
|
KnownBits KnownBits::umax(const KnownBits &LHS, const KnownBits &RHS) {
|
|
// If we can prove that LHS >= RHS then use LHS as the result. Likewise for
|
|
// RHS. Ideally our caller would already have spotted these cases and
|
|
// optimized away the umax operation, but we handle them here for
|
|
// completeness.
|
|
if (LHS.getMinValue().uge(RHS.getMaxValue()))
|
|
return LHS;
|
|
if (RHS.getMinValue().uge(LHS.getMaxValue()))
|
|
return RHS;
|
|
|
|
// If the result of the umax is LHS then it must be greater than or equal to
|
|
// the minimum possible value of RHS. Likewise for RHS. Any known bits that
|
|
// are common to these two values are also known in the result.
|
|
KnownBits L = LHS.makeGE(RHS.getMinValue());
|
|
KnownBits R = RHS.makeGE(LHS.getMinValue());
|
|
return KnownBits(L.Zero & R.Zero, L.One & R.One);
|
|
}
|
|
|
|
KnownBits KnownBits::umin(const KnownBits &LHS, const KnownBits &RHS) {
|
|
// Flip the range of values: [0, 0xFFFFFFFF] <-> [0xFFFFFFFF, 0]
|
|
auto Flip = [](const KnownBits &Val) { return KnownBits(Val.One, Val.Zero); };
|
|
return Flip(umax(Flip(LHS), Flip(RHS)));
|
|
}
|
|
|
|
KnownBits KnownBits::smax(const KnownBits &LHS, const KnownBits &RHS) {
|
|
// Flip the range of values: [-0x80000000, 0x7FFFFFFF] <-> [0, 0xFFFFFFFF]
|
|
auto Flip = [](const KnownBits &Val) {
|
|
unsigned SignBitPosition = Val.getBitWidth() - 1;
|
|
APInt Zero = Val.Zero;
|
|
APInt One = Val.One;
|
|
Zero.setBitVal(SignBitPosition, Val.One[SignBitPosition]);
|
|
One.setBitVal(SignBitPosition, Val.Zero[SignBitPosition]);
|
|
return KnownBits(Zero, One);
|
|
};
|
|
return Flip(umax(Flip(LHS), Flip(RHS)));
|
|
}
|
|
|
|
KnownBits KnownBits::smin(const KnownBits &LHS, const KnownBits &RHS) {
|
|
// Flip the range of values: [-0x80000000, 0x7FFFFFFF] <-> [0xFFFFFFFF, 0]
|
|
auto Flip = [](const KnownBits &Val) {
|
|
unsigned SignBitPosition = Val.getBitWidth() - 1;
|
|
APInt Zero = Val.One;
|
|
APInt One = Val.Zero;
|
|
Zero.setBitVal(SignBitPosition, Val.Zero[SignBitPosition]);
|
|
One.setBitVal(SignBitPosition, Val.One[SignBitPosition]);
|
|
return KnownBits(Zero, One);
|
|
};
|
|
return Flip(umax(Flip(LHS), Flip(RHS)));
|
|
}
|
|
|
|
KnownBits KnownBits::abs() const {
|
|
// If the source's MSB is zero then we know the rest of the bits already.
|
|
if (isNonNegative())
|
|
return *this;
|
|
|
|
// Assume we know nothing.
|
|
KnownBits KnownAbs(getBitWidth());
|
|
|
|
// We only know that the absolute values's MSB will be zero iff there is
|
|
// a set bit that isn't the sign bit (otherwise it could be INT_MIN).
|
|
APInt Val = One;
|
|
Val.clearSignBit();
|
|
if (!Val.isNullValue())
|
|
KnownAbs.Zero.setSignBit();
|
|
|
|
return KnownAbs;
|
|
}
|
|
|
|
KnownBits &KnownBits::operator&=(const KnownBits &RHS) {
|
|
// Result bit is 0 if either operand bit is 0.
|
|
Zero |= RHS.Zero;
|
|
// Result bit is 1 if both operand bits are 1.
|
|
One &= RHS.One;
|
|
return *this;
|
|
}
|
|
|
|
KnownBits &KnownBits::operator|=(const KnownBits &RHS) {
|
|
// Result bit is 0 if both operand bits are 0.
|
|
Zero &= RHS.Zero;
|
|
// Result bit is 1 if either operand bit is 1.
|
|
One |= RHS.One;
|
|
return *this;
|
|
}
|
|
|
|
KnownBits &KnownBits::operator^=(const KnownBits &RHS) {
|
|
// Result bit is 0 if both operand bits are 0 or both are 1.
|
|
APInt Z = (Zero & RHS.Zero) | (One & RHS.One);
|
|
// Result bit is 1 if one operand bit is 0 and the other is 1.
|
|
One = (Zero & RHS.One) | (One & RHS.Zero);
|
|
Zero = std::move(Z);
|
|
return *this;
|
|
}
|