RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-01 05:01:59 +01:00
Code Issues Projects Releases Wiki Activity

Revert r298711 "[InstCombine] Provide a way to calculate KnownZero/One for Add/Sub in SimplifyDemandedUseBits without recursing into ComputeKnownBits"

Browse Source 
Tsan bot is failing.

llvm-svn: 298745
This commit is contained in:
Craig Topper 2017-03-24 22:12:10 +00:00
parent 96aa4b5eca
commit 25553e107d
3 changed files with 25 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Analysis/ValueTracking.h
View File

@ -55,11 +55,6 @@ template <typename T> class ArrayRef;
const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr,
OptimizationRemarkEmitter *ORE = nullptr);
/// Compute known bits for add/sub using LHS/RHS known bits.
void computeKnownBitsForAddSub(bool Add, bool NSW,
APInt &KnownZero, APInt &KnownOne,
APInt &LHSKnownZero, APInt &LHSKnownOne,
APInt &RHSKnownZero, APInt &RHSKnownOne);
/// Compute known bits from the range metadata.
/// \p KnownZero the set of bits that are known to be zero
/// \p KnownOne the set of bits that are known to be one

56
lib/Analysis/ValueTracking.cpp
View File

@ -250,29 +250,37 @@ unsigned llvm::ComputeNumSignBits(const Value *V, const DataLayout &DL,
return ::ComputeNumSignBits(V, Depth, Query(DL, AC, safeCxtI(V, CxtI), DT));
}
/// Compute known bits for add/sub using LHS/RHS known bits.
void llvm::computeKnownBitsForAddSub(bool Add, bool NSW,
APInt &KnownZero, APInt &KnownOne,
APInt &LHSKnownZero, APInt &LHSKnownOne,
APInt &RHSKnownZero, APInt &RHSKnownOne) {
static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1,
bool NSW,
APInt &KnownZero, APInt &KnownOne,
APInt &KnownZero2, APInt &KnownOne2,
unsigned Depth, const Query &Q) {
unsigned BitWidth = KnownZero.getBitWidth();
// If an initial sequence of bits in the result is not needed, the
// corresponding bits in the operands are not needed.
APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
computeKnownBits(Op0, LHSKnownZero, LHSKnownOne, Depth + 1, Q);
computeKnownBits(Op1, KnownZero2, KnownOne2, Depth + 1, Q);
// Carry in a 1 for a subtract, rather than a 0.
uint64_t CarryIn = 0;
if (!Add) {
// Sum = LHS + ~RHS + 1
std::swap(RHSKnownZero, RHSKnownOne);
std::swap(KnownZero2, KnownOne2);
CarryIn = 1;
}
APInt PossibleSumZero = ~LHSKnownZero + ~RHSKnownZero + CarryIn;
APInt PossibleSumOne = LHSKnownOne + RHSKnownOne + CarryIn;
APInt PossibleSumZero = ~LHSKnownZero + ~KnownZero2 + CarryIn;
APInt PossibleSumOne = LHSKnownOne + KnownOne2 + CarryIn;
// Compute known bits of the carry.
APInt CarryKnownZero = ~(PossibleSumZero ^ LHSKnownZero ^ RHSKnownZero);
APInt CarryKnownOne = PossibleSumOne ^ LHSKnownOne ^ RHSKnownOne;
APInt CarryKnownZero = ~(PossibleSumZero ^ LHSKnownZero ^ KnownZero2);
APInt CarryKnownOne = PossibleSumOne ^ LHSKnownOne ^ KnownOne2;
// Compute set of known bits (where all three relevant bits are known).
APInt LHSKnown = LHSKnownZero | LHSKnownOne;
APInt RHSKnown = RHSKnownZero | RHSKnownOne;
APInt RHSKnown = KnownZero2 | KnownOne2;
APInt CarryKnown = CarryKnownZero | CarryKnownOne;
APInt Known = LHSKnown & RHSKnown & CarryKnown;
@ -288,36 +296,14 @@ void llvm::computeKnownBitsForAddSub(bool Add, bool NSW,
if (NSW) {
// Adding two non-negative numbers, or subtracting a negative number from
// a non-negative one, can't wrap into negative.
if (LHSKnownZero.isNegative() && RHSKnownZero.isNegative())
if (LHSKnownZero.isNegative() && KnownZero2.isNegative())
KnownZero.setSignBit();
// Adding two negative numbers, or subtracting a non-negative number from
// a negative one, can't wrap into non-negative.
else if (LHSKnownOne.isNegative() && RHSKnownOne.isNegative())
else if (LHSKnownOne.isNegative() && KnownOne2.isNegative())
KnownOne.setSignBit();
}
}
// Put the RHS/LHS back how we found them.
if (!Add) {
std::swap(RHSKnownZero, RHSKnownOne);
}
}
static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1,
bool NSW,
APInt &KnownZero, APInt &KnownOne,
APInt &KnownZero2, APInt &KnownOne2,
unsigned Depth, const Query &Q) {
unsigned BitWidth = KnownZero.getBitWidth();
// If an initial sequence of bits in the result is not needed, the
// corresponding bits in the operands are not needed.
APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
computeKnownBits(Op0, LHSKnownZero, LHSKnownOne, Depth + 1, Q);
computeKnownBits(Op1, KnownZero2, KnownOne2, Depth + 1, Q);
computeKnownBitsForAddSub(Add, NSW, KnownZero, KnownOne, LHSKnownZero,
LHSKnownOne, KnownZero2, KnownOne2);
}
static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW,

9
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
View File

@ -538,7 +538,7 @@ Value *InstCombiner::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
LHSKnownZero, LHSKnownOne, Depth + 1) ||
ShrinkDemandedConstant(I, 1, DemandedFromOps) ||
SimplifyDemandedBits(I->getOperandUse(1), DemandedFromOps,
RHSKnownZero, RHSKnownOne, Depth + 1)) {
LHSKnownZero, LHSKnownOne, Depth + 1)) {
// Disable the nsw and nuw flags here: We can no longer guarantee that
// we won't wrap after simplification. Removing the nsw/nuw flags is
// legal here because the top bit is not demanded.
@ -549,10 +549,9 @@ Value *InstCombiner::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
}
}
// Otherwise compute the known bits using the RHS/LHS known bits.
bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
computeKnownBitsForAddSub(V, NSW, KnownZero, KnownOne, LHSKnownZero,
LHSKnownOne, RHSKnownZero, RHSKnownOne);
// Otherwise just hand the add/sub off to computeKnownBits to fill in
// the known zeros and ones.
computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
break;
}
case Instruction::Shl: