From 8fbb74b5b24183d7b2afbc36c690921d9690307e Mon Sep 17 00:00:00 2001 From: Craig Topper Date: Fri, 24 Mar 2017 22:12:10 +0000 Subject: [PATCH] Revert r298711 "[InstCombine] Provide a way to calculate KnownZero/One for Add/Sub in SimplifyDemandedUseBits without recursing into ComputeKnownBits" Tsan bot is failing. llvm-svn: 298745 --- llvm/include/llvm/Analysis/ValueTracking.h | 5 -- llvm/lib/Analysis/ValueTracking.cpp | 56 ++++++++-------------- .../InstCombine/InstCombineSimplifyDemanded.cpp | 9 ++-- 3 files changed, 25 insertions(+), 45 deletions(-) diff --git a/llvm/include/llvm/Analysis/ValueTracking.h b/llvm/include/llvm/Analysis/ValueTracking.h index 08b6f30..e3c2f3b 100644 --- a/llvm/include/llvm/Analysis/ValueTracking.h +++ b/llvm/include/llvm/Analysis/ValueTracking.h @@ -55,11 +55,6 @@ template 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 diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index eeb6d49..6f04366 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -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, diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index d10fa06..41d4a48 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -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(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: -- 2.7.4