[llvm] r301432 - [ValueTracking] Introduce a KnownBits struct to wrap the two APInts for computeKnownBits
Philip Reames via llvm-commits
llvm-commits at lists.llvm.org
Wed Apr 26 16:49:47 PDT 2017
I just want to point out that ConstantRange also has a pair of APInts
which are often initialized together and must have the same bitwidth.
If you make representation changes to support such pairs space
efficiently, extending them to ConstantRange would really help LVI.
Philip
On 04/26/2017 09:39 AM, Craig Topper via llvm-commits wrote:
> Author: ctopper
> Date: Wed Apr 26 11:39:58 2017
> New Revision: 301432
>
> URL: http://llvm.org/viewvc/llvm-project?rev=301432&view=rev
> Log:
> [ValueTracking] Introduce a KnownBits struct to wrap the two APInts for computeKnownBits
>
> This patch introduces a new KnownBits struct that wraps the two APInt used by computeKnownBits. This allows us to treat them as more of a unit.
>
> Initially I've just altered the signatures of computeKnownBits and InstCombine's simplifyDemandedBits to pass a KnownBits reference instead of two separate APInt references. I'll do similar to the SelectionDAG version of computeKnownBits/simplifyDemandedBits as a separate patch.
>
> I've added a constructor that allows initializing both APInts to the same bit width with a starting value of 0. This reduces the repeated pattern of initializing both APInts. Once place default constructed the APInts so I added a default constructor for those cases.
>
> Going forward I would like to add more methods that will work on the pairs. For example trunc, zext, and sext occur on both APInts together in several places. We should probably add a clear method that can be used to clear both pieces. Maybe a method to check for conflicting information. A method to return (Zero|One) so we don't write it out everywhere. Maybe a method for (Zero|One).isAllOnesValue() to determine if all bits are known. I'm sure there are many other methods we can come up with.
>
> Differential Revision: https://reviews.llvm.org/D32376
>
> Added:
> llvm/trunk/include/llvm/Support/KnownBits.h (with props)
> Modified:
> llvm/trunk/include/llvm/Analysis/DemandedBits.h
> llvm/trunk/include/llvm/Analysis/ValueTracking.h
> llvm/trunk/lib/Analysis/ConstantFolding.cpp
> llvm/trunk/lib/Analysis/DemandedBits.cpp
> llvm/trunk/lib/Analysis/InstructionSimplify.cpp
> llvm/trunk/lib/Analysis/Lint.cpp
> llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> llvm/trunk/lib/Analysis/ValueTracking.cpp
> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
> llvm/trunk/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCasts.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineInternal.h
> llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
> llvm/trunk/lib/Transforms/Scalar/GuardWidening.cpp
> llvm/trunk/lib/Transforms/Utils/BypassSlowDivision.cpp
> llvm/trunk/lib/Transforms/Utils/Local.cpp
> llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
> llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp
> llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp
>
> Modified: llvm/trunk/include/llvm/Analysis/DemandedBits.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/DemandedBits.h?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/DemandedBits.h (original)
> +++ llvm/trunk/include/llvm/Analysis/DemandedBits.h Wed Apr 26 11:39:58 2017
> @@ -35,6 +35,7 @@ class Function;
> class Instruction;
> class DominatorTree;
> class AssumptionCache;
> +struct KnownBits;
>
> class DemandedBits {
> public:
> @@ -58,8 +59,7 @@ private:
> void determineLiveOperandBits(const Instruction *UserI,
> const Instruction *I, unsigned OperandNo,
> const APInt &AOut, APInt &AB,
> - APInt &KnownZero, APInt &KnownOne,
> - APInt &KnownZero2, APInt &KnownOne2);
> + KnownBits &Known, KnownBits &Known2);
>
> bool Analyzed;
>
>
> Modified: llvm/trunk/include/llvm/Analysis/ValueTracking.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ValueTracking.h?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/ValueTracking.h (original)
> +++ llvm/trunk/include/llvm/Analysis/ValueTracking.h Wed Apr 26 11:39:58 2017
> @@ -29,6 +29,7 @@ template <typename T> class ArrayRef;
> class DominatorTree;
> class GEPOperator;
> class Instruction;
> + struct KnownBits;
> class Loop;
> class LoopInfo;
> class OptimizationRemarkEmitter;
> @@ -49,7 +50,7 @@ template <typename T> class ArrayRef;
> /// where V is a vector, the known zero and known one values are the
> /// same width as the vector element, and the bit is set only if it is true
> /// for all of the elements in the vector.
> - void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
> + void computeKnownBits(const Value *V, KnownBits &Known,
> const DataLayout &DL, unsigned Depth = 0,
> AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
>
> Added: llvm/trunk/include/llvm/Support/KnownBits.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/KnownBits.h?rev=301432&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/KnownBits.h (added)
> +++ llvm/trunk/include/llvm/Support/KnownBits.h Wed Apr 26 11:39:58 2017
> @@ -0,0 +1,43 @@
> +//===- llvm/Support/KnownBits.h - Stores known zeros/ones -------*- C++ -*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file contains a class for representing known zeros and ones used by
> +// computeKnownBits.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_SUPPORT_KNOWNBITS_H
> +#define LLVM_SUPPORT_KNOWNBITS_H
> +
> +#include "llvm/ADT/APInt.h"
> +
> +namespace llvm {
> +
> +// For now this is a simple wrapper around two APInts.
> +struct KnownBits {
> + APInt Zero;
> + APInt One;
> +
> + // Default construct Zero and One.
> + KnownBits() {}
> +
> + /// Create a known bits object of BitWidth bits initialized to unknown.
> + KnownBits(unsigned BitWidth) : Zero(BitWidth, 0), One(BitWidth, 0) {}
> +
> + /// Get the bit width of this value.
> + unsigned getBitWidth() const {
> + assert(Zero.getBitWidth() == One.getBitWidth() &&
> + "Zero and One should have the same width!");
> + return Zero.getBitWidth();
> + }
> +};
> +
> +} // end namespace llvm
> +
> +#endif
>
> Propchange: llvm/trunk/include/llvm/Support/KnownBits.h
> ------------------------------------------------------------------------------
> svn:eol-style = native
>
> Propchange: llvm/trunk/include/llvm/Support/KnownBits.h
> ------------------------------------------------------------------------------
> svn:keywords = "Author Date Id Rev URL"
>
> Propchange: llvm/trunk/include/llvm/Support/KnownBits.h
> ------------------------------------------------------------------------------
> svn:mime-type = text/plain
>
> Modified: llvm/trunk/lib/Analysis/ConstantFolding.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ConstantFolding.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ConstantFolding.cpp (original)
> +++ llvm/trunk/lib/Analysis/ConstantFolding.cpp Wed Apr 26 11:39:58 2017
> @@ -42,6 +42,7 @@
> #include "llvm/IR/Value.h"
> #include "llvm/Support/Casting.h"
> #include "llvm/Support/ErrorHandling.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include <cassert>
> #include <cerrno>
> @@ -687,21 +688,21 @@ Constant *SymbolicallyEvaluateBinop(unsi
>
> if (Opc == Instruction::And) {
> unsigned BitWidth = DL.getTypeSizeInBits(Op0->getType()->getScalarType());
> - APInt KnownZero0(BitWidth, 0), KnownOne0(BitWidth, 0);
> - APInt KnownZero1(BitWidth, 0), KnownOne1(BitWidth, 0);
> - computeKnownBits(Op0, KnownZero0, KnownOne0, DL);
> - computeKnownBits(Op1, KnownZero1, KnownOne1, DL);
> - if ((KnownOne1 | KnownZero0).isAllOnesValue()) {
> + KnownBits Known0(BitWidth);
> + KnownBits Known1(BitWidth);
> + computeKnownBits(Op0, Known0, DL);
> + computeKnownBits(Op1, Known1, DL);
> + if ((Known1.One | Known0.Zero).isAllOnesValue()) {
> // All the bits of Op0 that the 'and' could be masking are already zero.
> return Op0;
> }
> - if ((KnownOne0 | KnownZero1).isAllOnesValue()) {
> + if ((Known0.One | Known1.Zero).isAllOnesValue()) {
> // All the bits of Op1 that the 'and' could be masking are already zero.
> return Op1;
> }
>
> - APInt KnownZero = KnownZero0 | KnownZero1;
> - APInt KnownOne = KnownOne0 & KnownOne1;
> + APInt KnownZero = Known0.Zero | Known1.Zero;
> + APInt KnownOne = Known0.One & Known1.One;
> if ((KnownZero | KnownOne).isAllOnesValue()) {
> return ConstantInt::get(Op0->getType(), KnownOne);
> }
>
> Modified: llvm/trunk/lib/Analysis/DemandedBits.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/DemandedBits.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/DemandedBits.cpp (original)
> +++ llvm/trunk/lib/Analysis/DemandedBits.cpp Wed Apr 26 11:39:58 2017
> @@ -37,6 +37,7 @@
> #include "llvm/IR/Operator.h"
> #include "llvm/Pass.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/raw_ostream.h"
> using namespace llvm;
>
> @@ -72,8 +73,7 @@ static bool isAlwaysLive(Instruction *I)
>
> void DemandedBits::determineLiveOperandBits(
> const Instruction *UserI, const Instruction *I, unsigned OperandNo,
> - const APInt &AOut, APInt &AB, APInt &KnownZero, APInt &KnownOne,
> - APInt &KnownZero2, APInt &KnownOne2) {
> + const APInt &AOut, APInt &AB, KnownBits &Known, KnownBits &Known2) {
> unsigned BitWidth = AB.getBitWidth();
>
> // We're called once per operand, but for some instructions, we need to
> @@ -85,15 +85,13 @@ void DemandedBits::determineLiveOperandB
> auto ComputeKnownBits =
> [&](unsigned BitWidth, const Value *V1, const Value *V2) {
> const DataLayout &DL = I->getModule()->getDataLayout();
> - KnownZero = APInt(BitWidth, 0);
> - KnownOne = APInt(BitWidth, 0);
> - computeKnownBits(const_cast<Value *>(V1), KnownZero, KnownOne, DL, 0,
> + Known = KnownBits(BitWidth);
> + computeKnownBits(const_cast<Value *>(V1), Known, DL, 0,
> &AC, UserI, &DT);
>
> if (V2) {
> - KnownZero2 = APInt(BitWidth, 0);
> - KnownOne2 = APInt(BitWidth, 0);
> - computeKnownBits(const_cast<Value *>(V2), KnownZero2, KnownOne2, DL,
> + Known2 = KnownBits(BitWidth);
> + computeKnownBits(const_cast<Value *>(V2), Known2, DL,
> 0, &AC, UserI, &DT);
> }
> };
> @@ -120,7 +118,7 @@ void DemandedBits::determineLiveOperandB
> // known to be one.
> ComputeKnownBits(BitWidth, I, nullptr);
> AB = APInt::getHighBitsSet(BitWidth,
> - std::min(BitWidth, KnownOne.countLeadingZeros()+1));
> + std::min(BitWidth, Known.One.countLeadingZeros()+1));
> }
> break;
> case Intrinsic::cttz:
> @@ -130,7 +128,7 @@ void DemandedBits::determineLiveOperandB
> // known to be one.
> ComputeKnownBits(BitWidth, I, nullptr);
> AB = APInt::getLowBitsSet(BitWidth,
> - std::min(BitWidth, KnownOne.countTrailingZeros()+1));
> + std::min(BitWidth, Known.One.countTrailingZeros()+1));
> }
> break;
> }
> @@ -200,11 +198,11 @@ void DemandedBits::determineLiveOperandB
> // dead).
> if (OperandNo == 0) {
> ComputeKnownBits(BitWidth, I, UserI->getOperand(1));
> - AB &= ~KnownZero2;
> + AB &= ~Known2.Zero;
> } else {
> if (!isa<Instruction>(UserI->getOperand(0)))
> ComputeKnownBits(BitWidth, UserI->getOperand(0), I);
> - AB &= ~(KnownZero & ~KnownZero2);
> + AB &= ~(Known.Zero & ~Known2.Zero);
> }
> break;
> case Instruction::Or:
> @@ -216,11 +214,11 @@ void DemandedBits::determineLiveOperandB
> // dead).
> if (OperandNo == 0) {
> ComputeKnownBits(BitWidth, I, UserI->getOperand(1));
> - AB &= ~KnownOne2;
> + AB &= ~Known2.One;
> } else {
> if (!isa<Instruction>(UserI->getOperand(0)))
> ComputeKnownBits(BitWidth, UserI->getOperand(0), I);
> - AB &= ~(KnownOne & ~KnownOne2);
> + AB &= ~(Known.One & ~Known2.One);
> }
> break;
> case Instruction::Xor:
> @@ -318,7 +316,7 @@ void DemandedBits::performAnalysis() {
> if (!UserI->getType()->isIntegerTy())
> Visited.insert(UserI);
>
> - APInt KnownZero, KnownOne, KnownZero2, KnownOne2;
> + KnownBits Known, Known2;
> // Compute the set of alive bits for each operand. These are anded into the
> // existing set, if any, and if that changes the set of alive bits, the
> // operand is added to the work-list.
> @@ -335,8 +333,7 @@ void DemandedBits::performAnalysis() {
> // Bits of each operand that are used to compute alive bits of the
> // output are alive, all others are dead.
> determineLiveOperandBits(UserI, I, OI.getOperandNo(), AOut, AB,
> - KnownZero, KnownOne,
> - KnownZero2, KnownOne2);
> + Known, Known2);
> }
>
> // If we've added to the set of alive bits (or the operand has not
>
> Modified: llvm/trunk/lib/Analysis/InstructionSimplify.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/InstructionSimplify.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/InstructionSimplify.cpp (original)
> +++ llvm/trunk/lib/Analysis/InstructionSimplify.cpp Wed Apr 26 11:39:58 2017
> @@ -35,6 +35,7 @@
> #include "llvm/IR/Operator.h"
> #include "llvm/IR/PatternMatch.h"
> #include "llvm/IR/ValueHandle.h"
> +#include "llvm/Support/KnownBits.h"
> #include <algorithm>
> using namespace llvm;
> using namespace llvm::PatternMatch;
> @@ -693,10 +694,9 @@ static Value *SimplifySubInst(Value *Op0
> return Op0;
>
> unsigned BitWidth = Op1->getType()->getScalarSizeInBits();
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(Op1, KnownZero, KnownOne, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
> - if (KnownZero.isMaxSignedValue()) {
> + KnownBits Known(BitWidth);
> + computeKnownBits(Op1, Known, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
> + if (Known.Zero.isMaxSignedValue()) {
> // Op1 is either 0 or the minimum signed value. If the sub is NSW, then
> // Op1 must be 0 because negating the minimum signed value is undefined.
> if (isNSW)
> @@ -1402,16 +1402,15 @@ static Value *SimplifyShift(Instruction:
> // If any bits in the shift amount make that value greater than or equal to
> // the number of bits in the type, the shift is undefined.
> unsigned BitWidth = Op1->getType()->getScalarSizeInBits();
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(Op1, KnownZero, KnownOne, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
> - if (KnownOne.getLimitedValue() >= BitWidth)
> + KnownBits Known(BitWidth);
> + computeKnownBits(Op1, Known, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
> + if (Known.One.getLimitedValue() >= BitWidth)
> return UndefValue::get(Op0->getType());
>
> // If all valid bits in the shift amount are known zero, the first operand is
> // unchanged.
> unsigned NumValidShiftBits = Log2_32_Ceil(BitWidth);
> - if (KnownZero.countTrailingOnes() >= NumValidShiftBits)
> + if (Known.Zero.countTrailingOnes() >= NumValidShiftBits)
> return Op0;
>
> return nullptr;
> @@ -1437,11 +1436,9 @@ static Value *SimplifyRightShift(Instruc
> // The low bit cannot be shifted out of an exact shift if it is set.
> if (isExact) {
> unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
> - APInt Op0KnownZero(BitWidth, 0);
> - APInt Op0KnownOne(BitWidth, 0);
> - computeKnownBits(Op0, Op0KnownZero, Op0KnownOne, Q.DL, /*Depth=*/0, Q.AC,
> - Q.CxtI, Q.DT);
> - if (Op0KnownOne[0])
> + KnownBits Op0Known(BitWidth);
> + computeKnownBits(Op0, Op0Known, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT);
> + if (Op0Known.One[0])
> return Op0;
> }
>
> @@ -3427,11 +3424,10 @@ static Value *SimplifyICmpInst(unsigned
> const APInt *RHSVal;
> if (match(RHS, m_APInt(RHSVal))) {
> unsigned BitWidth = RHSVal->getBitWidth();
> - APInt LHSKnownZero(BitWidth, 0);
> - APInt LHSKnownOne(BitWidth, 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, Q.DL, /*Depth=*/0, Q.AC,
> - Q.CxtI, Q.DT);
> - if (LHSKnownZero.intersects(*RHSVal) || !LHSKnownOne.isSubsetOf(*RHSVal))
> + KnownBits LHSKnown(BitWidth);
> + computeKnownBits(LHS, LHSKnown, Q.DL, /*Depth=*/0, Q.AC, Q.CxtI, Q.DT);
> + if (LHSKnown.Zero.intersects(*RHSVal) ||
> + !LHSKnown.One.isSubsetOf(*RHSVal))
> return Pred == ICmpInst::ICMP_EQ ? ConstantInt::getFalse(ITy)
> : ConstantInt::getTrue(ITy);
> }
> @@ -4854,12 +4850,10 @@ Value *llvm::SimplifyInstruction(Instruc
> // value even when the operands are not all constants.
> if (!Result && I->getType()->isIntOrIntVectorTy()) {
> unsigned BitWidth = I->getType()->getScalarSizeInBits();
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(I, KnownZero, KnownOne, Q.DL, /*Depth*/ 0, Q.AC, I, Q.DT,
> - ORE);
> - if ((KnownZero | KnownOne).isAllOnesValue())
> - Result = ConstantInt::get(I->getType(), KnownOne);
> + KnownBits Known(BitWidth);
> + computeKnownBits(I, Known, Q.DL, /*Depth*/ 0, Q.AC, I, Q.DT, ORE);
> + if ((Known.Zero | Known.One).isAllOnesValue())
> + Result = ConstantInt::get(I->getType(), Known.One);
> }
>
> /// If called on unreachable code, the above logic may report that the
>
> Modified: llvm/trunk/lib/Analysis/Lint.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/Lint.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/Lint.cpp (original)
> +++ llvm/trunk/lib/Analysis/Lint.cpp Wed Apr 26 11:39:58 2017
> @@ -70,6 +70,7 @@
> #include "llvm/Pass.h"
> #include "llvm/Support/Casting.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include "llvm/Support/raw_ostream.h"
> #include <cassert>
> @@ -534,10 +535,9 @@ static bool isZero(Value *V, const DataL
> VectorType *VecTy = dyn_cast<VectorType>(V->getType());
> if (!VecTy) {
> unsigned BitWidth = V->getType()->getIntegerBitWidth();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC,
> - dyn_cast<Instruction>(V), DT);
> - return KnownZero.isAllOnesValue();
> + KnownBits Known(BitWidth);
> + computeKnownBits(V, Known, DL, 0, AC, dyn_cast<Instruction>(V), DT);
> + return Known.Zero.isAllOnesValue();
> }
>
> // Per-component check doesn't work with zeroinitializer
> @@ -556,9 +556,9 @@ static bool isZero(Value *V, const DataL
> if (isa<UndefValue>(Elem))
> return true;
>
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(Elem, KnownZero, KnownOne, DL);
> - if (KnownZero.isAllOnesValue())
> + KnownBits Known(BitWidth);
> + computeKnownBits(Elem, Known, DL);
> + if (Known.Zero.isAllOnesValue())
> return true;
> }
>
>
> Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
> +++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Wed Apr 26 11:39:58 2017
> @@ -89,6 +89,7 @@
> #include "llvm/Support/CommandLine.h"
> #include "llvm/Support/Debug.h"
> #include "llvm/Support/ErrorHandling.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include "llvm/Support/raw_ostream.h"
> #include "llvm/Support/SaveAndRestore.h"
> @@ -4575,10 +4576,10 @@ uint32_t ScalarEvolution::GetMinTrailing
> if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
> // For a SCEVUnknown, ask ValueTracking.
> unsigned BitWidth = getTypeSizeInBits(U->getType());
> - APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
> - computeKnownBits(U->getValue(), Zeros, Ones, getDataLayout(), 0, &AC,
> + KnownBits Known(BitWidth);
> + computeKnownBits(U->getValue(), Known, getDataLayout(), 0, &AC,
> nullptr, &DT);
> - return Zeros.countTrailingOnes();
> + return Known.Zero.countTrailingOnes();
> }
>
> // SCEVUDivExpr
> @@ -4757,11 +4758,12 @@ ScalarEvolution::getRange(const SCEV *S,
> const DataLayout &DL = getDataLayout();
> if (SignHint == ScalarEvolution::HINT_RANGE_UNSIGNED) {
> // For a SCEVUnknown, ask ValueTracking.
> - APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
> - computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, &AC, nullptr, &DT);
> - if (Ones != ~Zeros + 1)
> + KnownBits Known(BitWidth);
> + computeKnownBits(U->getValue(), Known, DL, 0, &AC, nullptr, &DT);
> + if (Known.One != ~Known.Zero + 1)
> ConservativeResult =
> - ConservativeResult.intersectWith(ConstantRange(Ones, ~Zeros + 1));
> + ConservativeResult.intersectWith(ConstantRange(Known.One,
> + ~Known.Zero + 1));
> } else {
> assert(SignHint == ScalarEvolution::HINT_RANGE_SIGNED &&
> "generalize as needed!");
> @@ -5292,13 +5294,13 @@ const SCEV *ScalarEvolution::createSCEV(
> unsigned LZ = A.countLeadingZeros();
> unsigned TZ = A.countTrailingZeros();
> unsigned BitWidth = A.getBitWidth();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(BO->LHS, KnownZero, KnownOne, getDataLayout(),
> + KnownBits Known(BitWidth);
> + computeKnownBits(BO->LHS, Known, getDataLayout(),
> 0, &AC, nullptr, &DT);
>
> APInt EffectiveMask =
> APInt::getLowBitsSet(BitWidth, BitWidth - LZ - TZ).shl(TZ);
> - if ((LZ != 0 || TZ != 0) && !((~A & ~KnownZero) & EffectiveMask)) {
> + if ((LZ != 0 || TZ != 0) && !((~A & ~Known.Zero) & EffectiveMask)) {
> const SCEV *MulCount = getConstant(APInt::getOneBitSet(BitWidth, TZ));
> const SCEV *LHS = getSCEV(BO->LHS);
> const SCEV *ShiftedLHS = nullptr;
>
> Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
> +++ llvm/trunk/lib/Analysis/ValueTracking.cpp Wed Apr 26 11:39:58 2017
> @@ -38,6 +38,7 @@
> #include "llvm/IR/PatternMatch.h"
> #include "llvm/IR/Statepoint.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include <algorithm>
> #include <array>
> @@ -130,15 +131,15 @@ static const Instruction *safeCxtI(const
> return nullptr;
> }
>
> -static void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
> +static void computeKnownBits(const Value *V, KnownBits &Known,
> unsigned Depth, const Query &Q);
>
> -void llvm::computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
> +void llvm::computeKnownBits(const Value *V, KnownBits &Known,
> const DataLayout &DL, unsigned Depth,
> AssumptionCache *AC, const Instruction *CxtI,
> const DominatorTree *DT,
> OptimizationRemarkEmitter *ORE) {
> - ::computeKnownBits(V, KnownZero, KnownOne, Depth,
> + ::computeKnownBits(V, Known, Depth,
> Query(DL, AC, safeCxtI(V, CxtI), DT, ORE));
> }
>
> @@ -151,11 +152,11 @@ bool llvm::haveNoCommonBitsSet(const Val
> assert(LHS->getType()->isIntOrIntVectorTy() &&
> "LHS and RHS should be integers");
> IntegerType *IT = cast<IntegerType>(LHS->getType()->getScalarType());
> - APInt LHSKnownZero(IT->getBitWidth(), 0), LHSKnownOne(IT->getBitWidth(), 0);
> - APInt RHSKnownZero(IT->getBitWidth(), 0), RHSKnownOne(IT->getBitWidth(), 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, DL, 0, AC, CxtI, DT);
> - computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, DL, 0, AC, CxtI, DT);
> - return (LHSKnownZero | RHSKnownZero).isAllOnesValue();
> + KnownBits LHSKnown(IT->getBitWidth());
> + KnownBits RHSKnown(IT->getBitWidth());
> + computeKnownBits(LHS, LHSKnown, DL, 0, AC, CxtI, DT);
> + computeKnownBits(RHS, RHSKnown, DL, 0, AC, CxtI, DT);
> + return (LHSKnown.Zero | RHSKnown.Zero).isAllOnesValue();
> }
>
> static void ComputeSignBit(const Value *V, bool &KnownZero, bool &KnownOne,
> @@ -252,67 +253,65 @@ unsigned llvm::ComputeNumSignBits(const
>
> static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1,
> bool NSW,
> - APInt &KnownZero, APInt &KnownOne,
> - APInt &KnownZero2, APInt &KnownOne2,
> + KnownBits &KnownOut, KnownBits &Known2,
> unsigned Depth, const Query &Q) {
> - unsigned BitWidth = KnownZero.getBitWidth();
> + unsigned BitWidth = KnownOut.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);
> + KnownBits LHSKnown(BitWidth);
> + computeKnownBits(Op0, LHSKnown, Depth + 1, Q);
> + computeKnownBits(Op1, Known2, 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(KnownZero2, KnownOne2);
> + std::swap(Known2.Zero, Known2.One);
> CarryIn = 1;
> }
>
> - APInt PossibleSumZero = ~LHSKnownZero + ~KnownZero2 + CarryIn;
> - APInt PossibleSumOne = LHSKnownOne + KnownOne2 + CarryIn;
> + APInt PossibleSumZero = ~LHSKnown.Zero + ~Known2.Zero + CarryIn;
> + APInt PossibleSumOne = LHSKnown.One + Known2.One + CarryIn;
>
> // Compute known bits of the carry.
> - APInt CarryKnownZero = ~(PossibleSumZero ^ LHSKnownZero ^ KnownZero2);
> - APInt CarryKnownOne = PossibleSumOne ^ LHSKnownOne ^ KnownOne2;
> + APInt CarryKnownZero = ~(PossibleSumZero ^ LHSKnown.Zero ^ Known2.Zero);
> + APInt CarryKnownOne = PossibleSumOne ^ LHSKnown.One ^ Known2.One;
>
> // Compute set of known bits (where all three relevant bits are known).
> - APInt LHSKnown = LHSKnownZero | LHSKnownOne;
> - APInt RHSKnown = KnownZero2 | KnownOne2;
> - APInt CarryKnown = CarryKnownZero | CarryKnownOne;
> - APInt Known = LHSKnown & RHSKnown & CarryKnown;
> + APInt LHSKnownUnion = LHSKnown.Zero | LHSKnown.One;
> + APInt RHSKnownUnion = Known2.Zero | Known2.One;
> + APInt CarryKnownUnion = CarryKnownZero | CarryKnownOne;
> + APInt Known = LHSKnownUnion & RHSKnownUnion & CarryKnownUnion;
>
> assert((PossibleSumZero & Known) == (PossibleSumOne & Known) &&
> "known bits of sum differ");
>
> // Compute known bits of the result.
> - KnownZero = ~PossibleSumOne & Known;
> - KnownOne = PossibleSumOne & Known;
> + KnownOut.Zero = ~PossibleSumOne & Known;
> + KnownOut.One = PossibleSumOne & Known;
>
> // Are we still trying to solve for the sign bit?
> if (!Known.isSignBitSet()) {
> if (NSW) {
> // Adding two non-negative numbers, or subtracting a negative number from
> // a non-negative one, can't wrap into negative.
> - if (LHSKnownZero.isSignBitSet() && KnownZero2.isSignBitSet())
> - KnownZero.setSignBit();
> + if (LHSKnown.Zero.isSignBitSet() && Known2.Zero.isSignBitSet())
> + KnownOut.Zero.setSignBit();
> // Adding two negative numbers, or subtracting a non-negative number from
> // a negative one, can't wrap into non-negative.
> - else if (LHSKnownOne.isSignBitSet() && KnownOne2.isSignBitSet())
> - KnownOne.setSignBit();
> + else if (LHSKnown.One.isSignBitSet() && Known2.One.isSignBitSet())
> + KnownOut.One.setSignBit();
> }
> }
> }
>
> static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW,
> - APInt &KnownZero, APInt &KnownOne,
> - APInt &KnownZero2, APInt &KnownOne2,
> + KnownBits &Known, KnownBits &Known2,
> unsigned Depth, const Query &Q) {
> - unsigned BitWidth = KnownZero.getBitWidth();
> - computeKnownBits(Op1, KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(Op0, KnownZero2, KnownOne2, Depth + 1, Q);
> + unsigned BitWidth = Known.getBitWidth();
> + computeKnownBits(Op1, Known, Depth + 1, Q);
> + computeKnownBits(Op0, Known2, Depth + 1, Q);
>
> bool isKnownNegative = false;
> bool isKnownNonNegative = false;
> @@ -322,10 +321,10 @@ static void computeKnownBitsMul(const Va
> // The product of a number with itself is non-negative.
> isKnownNonNegative = true;
> } else {
> - bool isKnownNonNegativeOp1 = KnownZero.isSignBitSet();
> - bool isKnownNonNegativeOp0 = KnownZero2.isSignBitSet();
> - bool isKnownNegativeOp1 = KnownOne.isSignBitSet();
> - bool isKnownNegativeOp0 = KnownOne2.isSignBitSet();
> + bool isKnownNonNegativeOp1 = Known.Zero.isSignBitSet();
> + bool isKnownNonNegativeOp0 = Known2.Zero.isSignBitSet();
> + bool isKnownNegativeOp1 = Known.One.isSignBitSet();
> + bool isKnownNegativeOp0 = Known2.One.isSignBitSet();
> // The product of two numbers with the same sign is non-negative.
> isKnownNonNegative = (isKnownNegativeOp1 && isKnownNegativeOp0) ||
> (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
> @@ -343,28 +342,28 @@ static void computeKnownBitsMul(const Va
> // Also compute a conservative estimate for high known-0 bits.
> // More trickiness is possible, but this is sufficient for the
> // interesting case of alignment computation.
> - KnownOne.clearAllBits();
> - unsigned TrailZ = KnownZero.countTrailingOnes() +
> - KnownZero2.countTrailingOnes();
> - unsigned LeadZ = std::max(KnownZero.countLeadingOnes() +
> - KnownZero2.countLeadingOnes(),
> + Known.One.clearAllBits();
> + unsigned TrailZ = Known.Zero.countTrailingOnes() +
> + Known2.Zero.countTrailingOnes();
> + unsigned LeadZ = std::max(Known.Zero.countLeadingOnes() +
> + Known2.Zero.countLeadingOnes(),
> BitWidth) - BitWidth;
>
> TrailZ = std::min(TrailZ, BitWidth);
> LeadZ = std::min(LeadZ, BitWidth);
> - KnownZero.clearAllBits();
> - KnownZero.setLowBits(TrailZ);
> - KnownZero.setHighBits(LeadZ);
> + Known.Zero.clearAllBits();
> + Known.Zero.setLowBits(TrailZ);
> + Known.Zero.setHighBits(LeadZ);
>
> // Only make use of no-wrap flags if we failed to compute the sign bit
> // directly. This matters if the multiplication always overflows, in
> // which case we prefer to follow the result of the direct computation,
> // though as the program is invoking undefined behaviour we can choose
> // whatever we like here.
> - if (isKnownNonNegative && !KnownOne.isSignBitSet())
> - KnownZero.setSignBit();
> - else if (isKnownNegative && !KnownZero.isSignBitSet())
> - KnownOne.setSignBit();
> + if (isKnownNonNegative && !Known.One.isSignBitSet())
> + Known.Zero.setSignBit();
> + else if (isKnownNegative && !Known.Zero.isSignBitSet())
> + Known.One.setSignBit();
> }
>
> void llvm::computeKnownBitsFromRangeMetadata(const MDNode &Ranges,
> @@ -499,15 +498,14 @@ bool llvm::isValidAssumeForContext(const
> return !isEphemeralValueOf(Inv, CxtI);
> }
>
> -static void computeKnownBitsFromAssume(const Value *V, APInt &KnownZero,
> - APInt &KnownOne, unsigned Depth,
> - const Query &Q) {
> +static void computeKnownBitsFromAssume(const Value *V, KnownBits &Known,
> + unsigned Depth, const Query &Q) {
> // Use of assumptions is context-sensitive. If we don't have a context, we
> // cannot use them!
> if (!Q.AC || !Q.CxtI)
> return;
>
> - unsigned BitWidth = KnownZero.getBitWidth();
> + unsigned BitWidth = Known.getBitWidth();
>
> // Note that the patterns below need to be kept in sync with the code
> // in AssumptionCache::updateAffectedValues.
> @@ -532,15 +530,15 @@ static void computeKnownBitsFromAssume(c
>
> if (Arg == V && isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> assert(BitWidth == 1 && "assume operand is not i1?");
> - KnownZero.clearAllBits();
> - KnownOne.setAllBits();
> + Known.Zero.clearAllBits();
> + Known.One.setAllBits();
> return;
> }
> if (match(Arg, m_Not(m_Specific(V))) &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> assert(BitWidth == 1 && "assume operand is not i1?");
> - KnownZero.setAllBits();
> - KnownOne.clearAllBits();
> + Known.Zero.setAllBits();
> + Known.One.clearAllBits();
> return;
> }
>
> @@ -558,126 +556,126 @@ static void computeKnownBitsFromAssume(c
> // assume(v = a)
> if (match(Arg, m_c_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - KnownZero |= RHSKnownZero;
> - KnownOne |= RHSKnownOne;
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + Known.Zero |= RHSKnown.Zero;
> + Known.One |= RHSKnown.One;
> // assume(v & b = a)
> } else if (match(Arg,
> m_c_ICmp(Pred, m_c_And(m_V, m_Value(B)), m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
> - computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + KnownBits MaskKnown(BitWidth);
> + computeKnownBits(B, MaskKnown, Depth+1, Query(Q, I));
>
> // For those bits in the mask that are known to be one, we can propagate
> // known bits from the RHS to V.
> - KnownZero |= RHSKnownZero & MaskKnownOne;
> - KnownOne |= RHSKnownOne & MaskKnownOne;
> + Known.Zero |= RHSKnown.Zero & MaskKnown.One;
> + Known.One |= RHSKnown.One & MaskKnown.One;
> // assume(~(v & b) = a)
> } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_And(m_V, m_Value(B))),
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
> - computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + KnownBits MaskKnown(BitWidth);
> + computeKnownBits(B, MaskKnown, Depth+1, Query(Q, I));
>
> // For those bits in the mask that are known to be one, we can propagate
> // inverted known bits from the RHS to V.
> - KnownZero |= RHSKnownOne & MaskKnownOne;
> - KnownOne |= RHSKnownZero & MaskKnownOne;
> + Known.Zero |= RHSKnown.One & MaskKnown.One;
> + Known.One |= RHSKnown.Zero & MaskKnown.One;
> // assume(v | b = a)
> } else if (match(Arg,
> m_c_ICmp(Pred, m_c_Or(m_V, m_Value(B)), m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + KnownBits BKnown(BitWidth);
> + computeKnownBits(B, BKnown, Depth+1, Query(Q, I));
>
> // For those bits in B that are known to be zero, we can propagate known
> // bits from the RHS to V.
> - KnownZero |= RHSKnownZero & BKnownZero;
> - KnownOne |= RHSKnownOne & BKnownZero;
> + Known.Zero |= RHSKnown.Zero & BKnown.Zero;
> + Known.One |= RHSKnown.One & BKnown.Zero;
> // assume(~(v | b) = a)
> } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Or(m_V, m_Value(B))),
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + KnownBits BKnown(BitWidth);
> + computeKnownBits(B, BKnown, Depth+1, Query(Q, I));
>
> // For those bits in B that are known to be zero, we can propagate
> // inverted known bits from the RHS to V.
> - KnownZero |= RHSKnownOne & BKnownZero;
> - KnownOne |= RHSKnownZero & BKnownZero;
> + Known.Zero |= RHSKnown.One & BKnown.Zero;
> + Known.One |= RHSKnown.Zero & BKnown.Zero;
> // assume(v ^ b = a)
> } else if (match(Arg,
> m_c_ICmp(Pred, m_c_Xor(m_V, m_Value(B)), m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + KnownBits BKnown(BitWidth);
> + computeKnownBits(B, BKnown, Depth+1, Query(Q, I));
>
> // For those bits in B that are known to be zero, we can propagate known
> // bits from the RHS to V. For those bits in B that are known to be one,
> // we can propagate inverted known bits from the RHS to V.
> - KnownZero |= RHSKnownZero & BKnownZero;
> - KnownOne |= RHSKnownOne & BKnownZero;
> - KnownZero |= RHSKnownOne & BKnownOne;
> - KnownOne |= RHSKnownZero & BKnownOne;
> + Known.Zero |= RHSKnown.Zero & BKnown.Zero;
> + Known.One |= RHSKnown.One & BKnown.Zero;
> + Known.Zero |= RHSKnown.One & BKnown.One;
> + Known.One |= RHSKnown.Zero & BKnown.One;
> // assume(~(v ^ b) = a)
> } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Xor(m_V, m_Value(B))),
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> - APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> + KnownBits BKnown(BitWidth);
> + computeKnownBits(B, BKnown, Depth+1, Query(Q, I));
>
> // For those bits in B that are known to be zero, we can propagate
> // inverted known bits from the RHS to V. For those bits in B that are
> // known to be one, we can propagate known bits from the RHS to V.
> - KnownZero |= RHSKnownOne & BKnownZero;
> - KnownOne |= RHSKnownZero & BKnownZero;
> - KnownZero |= RHSKnownZero & BKnownOne;
> - KnownOne |= RHSKnownOne & BKnownOne;
> + Known.Zero |= RHSKnown.One & BKnown.Zero;
> + Known.One |= RHSKnown.Zero & BKnown.Zero;
> + Known.Zero |= RHSKnown.Zero & BKnown.One;
> + Known.One |= RHSKnown.One & BKnown.One;
> // assume(v << c = a)
> } else if (match(Arg, m_c_ICmp(Pred, m_Shl(m_V, m_ConstantInt(C)),
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> // For those bits in RHS that are known, we can propagate them to known
> // bits in V shifted to the right by C.
> - RHSKnownZero.lshrInPlace(C->getZExtValue());
> - KnownZero |= RHSKnownZero;
> - RHSKnownOne.lshrInPlace(C->getZExtValue());
> - KnownOne |= RHSKnownOne;
> + RHSKnown.Zero.lshrInPlace(C->getZExtValue());
> + Known.Zero |= RHSKnown.Zero;
> + RHSKnown.One.lshrInPlace(C->getZExtValue());
> + Known.One |= RHSKnown.One;
> // assume(~(v << c) = a)
> } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_Shl(m_V, m_ConstantInt(C))),
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> // For those bits in RHS that are known, we can propagate them inverted
> // to known bits in V shifted to the right by C.
> - RHSKnownOne.lshrInPlace(C->getZExtValue());
> - KnownZero |= RHSKnownOne;
> - RHSKnownZero.lshrInPlace(C->getZExtValue());
> - KnownOne |= RHSKnownZero;
> + RHSKnown.One.lshrInPlace(C->getZExtValue());
> + Known.Zero |= RHSKnown.One;
> + RHSKnown.Zero.lshrInPlace(C->getZExtValue());
> + Known.One |= RHSKnown.Zero;
> // assume(v >> c = a)
> } else if (match(Arg,
> m_c_ICmp(Pred, m_CombineOr(m_LShr(m_V, m_ConstantInt(C)),
> @@ -685,12 +683,12 @@ static void computeKnownBitsFromAssume(c
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> // For those bits in RHS that are known, we can propagate them to known
> // bits in V shifted to the right by C.
> - KnownZero |= RHSKnownZero << C->getZExtValue();
> - KnownOne |= RHSKnownOne << C->getZExtValue();
> + Known.Zero |= RHSKnown.Zero << C->getZExtValue();
> + Known.One |= RHSKnown.One << C->getZExtValue();
> // assume(~(v >> c) = a)
> } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_CombineOr(
> m_LShr(m_V, m_ConstantInt(C)),
> @@ -698,78 +696,78 @@ static void computeKnownBitsFromAssume(c
> m_Value(A))) &&
> Pred == ICmpInst::ICMP_EQ &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
> // For those bits in RHS that are known, we can propagate them inverted
> // to known bits in V shifted to the right by C.
> - KnownZero |= RHSKnownOne << C->getZExtValue();
> - KnownOne |= RHSKnownZero << C->getZExtValue();
> + Known.Zero |= RHSKnown.One << C->getZExtValue();
> + Known.One |= RHSKnown.Zero << C->getZExtValue();
> // assume(v >=_s c) where c is non-negative
> } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_SGE &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
>
> - if (RHSKnownZero.isSignBitSet()) {
> + if (RHSKnown.Zero.isSignBitSet()) {
> // We know that the sign bit is zero.
> - KnownZero.setSignBit();
> + Known.Zero.setSignBit();
> }
> // assume(v >_s c) where c is at least -1.
> } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_SGT &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
>
> - if (RHSKnownOne.isAllOnesValue() || RHSKnownZero.isSignBitSet()) {
> + if (RHSKnown.One.isAllOnesValue() || RHSKnown.Zero.isSignBitSet()) {
> // We know that the sign bit is zero.
> - KnownZero.setSignBit();
> + Known.Zero.setSignBit();
> }
> // assume(v <=_s c) where c is negative
> } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_SLE &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
>
> - if (RHSKnownOne.isSignBitSet()) {
> + if (RHSKnown.One.isSignBitSet()) {
> // We know that the sign bit is one.
> - KnownOne.setSignBit();
> + Known.One.setSignBit();
> }
> // assume(v <_s c) where c is non-positive
> } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_SLT &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
>
> - if (RHSKnownZero.isAllOnesValue() || RHSKnownOne.isSignBitSet()) {
> + if (RHSKnown.Zero.isAllOnesValue() || RHSKnown.One.isSignBitSet()) {
> // We know that the sign bit is one.
> - KnownOne.setSignBit();
> + Known.One.setSignBit();
> }
> // assume(v <=_u c)
> } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_ULE &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
>
> // Whatever high bits in c are zero are known to be zero.
> - KnownZero.setHighBits(RHSKnownZero.countLeadingOnes());
> + Known.Zero.setHighBits(RHSKnown.Zero.countLeadingOnes());
> // assume(v <_u c)
> } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> Pred == ICmpInst::ICMP_ULT &&
> isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(A, RHSKnown, Depth+1, Query(Q, I));
>
> // Whatever high bits in c are zero are known to be zero (if c is a power
> // of 2, then one more).
> if (isKnownToBeAPowerOfTwo(A, false, Depth + 1, Query(Q, I)))
> - KnownZero.setHighBits(RHSKnownZero.countLeadingOnes()+1);
> + Known.Zero.setHighBits(RHSKnown.Zero.countLeadingOnes()+1);
> else
> - KnownZero.setHighBits(RHSKnownZero.countLeadingOnes());
> + Known.Zero.setHighBits(RHSKnown.Zero.countLeadingOnes());
> }
> }
>
> @@ -778,9 +776,9 @@ static void computeKnownBitsFromAssume(c
> // so this isn't a real bug. On the other hand, the program may have undefined
> // behavior, or we might have a bug in the compiler. We can't assert/crash, so
> // clear out the known bits, try to warn the user, and hope for the best.
> - if (KnownZero.intersects(KnownOne)) {
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + if (Known.Zero.intersects(Known.One)) {
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
>
> if (Q.ORE) {
> auto *CxtI = const_cast<Instruction *>(Q.CxtI);
> @@ -793,57 +791,57 @@ static void computeKnownBitsFromAssume(c
> }
>
> // Compute known bits from a shift operator, including those with a
> -// non-constant shift amount. KnownZero and KnownOne are the outputs of this
> -// function. KnownZero2 and KnownOne2 are pre-allocated temporaries with the
> -// same bit width as KnownZero and KnownOne. KZF and KOF are operator-specific
> -// functors that, given the known-zero or known-one bits respectively, and a
> -// shift amount, compute the implied known-zero or known-one bits of the shift
> -// operator's result respectively for that shift amount. The results from calling
> -// KZF and KOF are conservatively combined for all permitted shift amounts.
> +// non-constant shift amount. Known is the outputs of this function. Known2 is a
> +// pre-allocated temporary with the/ same bit width as Known. KZF and KOF are
> +// operator-specific functors that, given the known-zero or known-one bits
> +// respectively, and a shift amount, compute the implied known-zero or known-one
> +// bits of the shift operator's result respectively for that shift amount. The
> +// results from calling KZF and KOF are conservatively combined for all
> +// permitted shift amounts.
> static void computeKnownBitsFromShiftOperator(
> - const Operator *I, APInt &KnownZero, APInt &KnownOne, APInt &KnownZero2,
> - APInt &KnownOne2, unsigned Depth, const Query &Q,
> + const Operator *I, KnownBits &Known, KnownBits &Known2,
> + unsigned Depth, const Query &Q,
> function_ref<APInt(const APInt &, unsigned)> KZF,
> function_ref<APInt(const APInt &, unsigned)> KOF) {
> - unsigned BitWidth = KnownZero.getBitWidth();
> + unsigned BitWidth = Known.getBitWidth();
>
> if (auto *SA = dyn_cast<ConstantInt>(I->getOperand(1))) {
> unsigned ShiftAmt = SA->getLimitedValue(BitWidth-1);
>
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> - KnownZero = KZF(KnownZero, ShiftAmt);
> - KnownOne = KOF(KnownOne, ShiftAmt);
> - // If there is conflict between KnownZero and KnownOne, this must be an
> - // overflowing left shift, so the shift result is undefined. Clear KnownZero
> - // and KnownOne bits so that other code could propagate this undef.
> - if ((KnownZero & KnownOne) != 0) {
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> + Known.Zero = KZF(Known.Zero, ShiftAmt);
> + Known.One = KOF(Known.One, ShiftAmt);
> + // If there is conflict between Known.Zero and Known.One, this must be an
> + // overflowing left shift, so the shift result is undefined. Clear Known
> + // bits so that other code could propagate this undef.
> + if ((Known.Zero & Known.One) != 0) {
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
> }
>
> return;
> }
>
> - computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
> + computeKnownBits(I->getOperand(1), Known, Depth + 1, Q);
>
> // If the shift amount could be greater than or equal to the bit-width of the LHS, the
> // value could be undef, so we don't know anything about it.
> - if ((~KnownZero).uge(BitWidth)) {
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + if ((~Known.Zero).uge(BitWidth)) {
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
> return;
> }
>
> - // Note: We cannot use KnownZero.getLimitedValue() here, because if
> + // Note: We cannot use Known.Zero.getLimitedValue() here, because if
> // BitWidth > 64 and any upper bits are known, we'll end up returning the
> // limit value (which implies all bits are known).
> - uint64_t ShiftAmtKZ = KnownZero.zextOrTrunc(64).getZExtValue();
> - uint64_t ShiftAmtKO = KnownOne.zextOrTrunc(64).getZExtValue();
> + uint64_t ShiftAmtKZ = Known.Zero.zextOrTrunc(64).getZExtValue();
> + uint64_t ShiftAmtKO = Known.One.zextOrTrunc(64).getZExtValue();
>
> // It would be more-clearly correct to use the two temporaries for this
> // calculation. Reusing the APInts here to prevent unnecessary allocations.
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
>
> // If we know the shifter operand is nonzero, we can sometimes infer more
> // known bits. However this is expensive to compute, so be lazy about it and
> @@ -858,10 +856,10 @@ static void computeKnownBitsFromShiftOpe
> return;
> }
>
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
>
> - KnownZero.setAllBits();
> - KnownOne.setAllBits();
> + Known.Zero.setAllBits();
> + Known.One.setAllBits();
> for (unsigned ShiftAmt = 0; ShiftAmt < BitWidth; ++ShiftAmt) {
> // Combine the shifted known input bits only for those shift amounts
> // compatible with its known constraints.
> @@ -880,8 +878,8 @@ static void computeKnownBitsFromShiftOpe
> continue;
> }
>
> - KnownZero &= KZF(KnownZero2, ShiftAmt);
> - KnownOne &= KOF(KnownOne2, ShiftAmt);
> + Known.Zero &= KZF(Known2.Zero, ShiftAmt);
> + Known.One &= KOF(Known2.One, ShiftAmt);
> }
>
> // If there are no compatible shift amounts, then we've proven that the shift
> @@ -889,33 +887,32 @@ static void computeKnownBitsFromShiftOpe
> // return anything we'd like, but we need to make sure the sets of known bits
> // stay disjoint (it should be better for some other code to actually
> // propagate the undef than to pick a value here using known bits).
> - if (KnownZero.intersects(KnownOne)) {
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + if (Known.Zero.intersects(Known.One)) {
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
> }
> }
>
> -static void computeKnownBitsFromOperator(const Operator *I, APInt &KnownZero,
> - APInt &KnownOne, unsigned Depth,
> - const Query &Q) {
> - unsigned BitWidth = KnownZero.getBitWidth();
> +static void computeKnownBitsFromOperator(const Operator *I, KnownBits &Known,
> + unsigned Depth, const Query &Q) {
> + unsigned BitWidth = Known.getBitWidth();
>
> - APInt KnownZero2(KnownZero), KnownOne2(KnownOne);
> + KnownBits Known2(Known);
> switch (I->getOpcode()) {
> default: break;
> case Instruction::Load:
> if (MDNode *MD = cast<LoadInst>(I)->getMetadata(LLVMContext::MD_range))
> - computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
> + computeKnownBitsFromRangeMetadata(*MD, Known.Zero, Known.One);
> break;
> case Instruction::And: {
> // If either the LHS or the RHS are Zero, the result is zero.
> - computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(1), Known, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
>
> // Output known-1 bits are only known if set in both the LHS & RHS.
> - KnownOne &= KnownOne2;
> + Known.One &= Known2.One;
> // Output known-0 are known to be clear if zero in either the LHS | RHS.
> - KnownZero |= KnownZero2;
> + Known.Zero |= Known2.Zero;
>
> // and(x, add (x, -1)) is a common idiom that always clears the low bit;
> // here we handle the more general case of adding any odd number by
> @@ -923,115 +920,115 @@ static void computeKnownBitsFromOperator
> // TODO: This could be generalized to clearing any bit set in y where the
> // following bit is known to be unset in y.
> Value *Y = nullptr;
> - if (!KnownZero[0] && !KnownOne[0] &&
> + if (!Known.Zero[0] && !Known.One[0] &&
> (match(I->getOperand(0), m_Add(m_Specific(I->getOperand(1)),
> m_Value(Y))) ||
> match(I->getOperand(1), m_Add(m_Specific(I->getOperand(0)),
> m_Value(Y))))) {
> - KnownZero2.clearAllBits(); KnownOne2.clearAllBits();
> - computeKnownBits(Y, KnownZero2, KnownOne2, Depth + 1, Q);
> - if (KnownOne2.countTrailingOnes() > 0)
> - KnownZero.setBit(0);
> + Known2.Zero.clearAllBits(); Known2.One.clearAllBits();
> + computeKnownBits(Y, Known2, Depth + 1, Q);
> + if (Known2.One.countTrailingOnes() > 0)
> + Known.Zero.setBit(0);
> }
> break;
> }
> case Instruction::Or: {
> - computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(1), Known, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
>
> // Output known-0 bits are only known if clear in both the LHS & RHS.
> - KnownZero &= KnownZero2;
> + Known.Zero &= Known2.Zero;
> // Output known-1 are known to be set if set in either the LHS | RHS.
> - KnownOne |= KnownOne2;
> + Known.One |= Known2.One;
> break;
> }
> case Instruction::Xor: {
> - computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(1), Known, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
>
> // Output known-0 bits are known if clear or set in both the LHS & RHS.
> - APInt KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2);
> + APInt KnownZeroOut = (Known.Zero & Known2.Zero) | (Known.One & Known2.One);
> // Output known-1 are known to be set if set in only one of the LHS, RHS.
> - KnownOne = (KnownZero & KnownOne2) | (KnownOne & KnownZero2);
> - KnownZero = std::move(KnownZeroOut);
> + Known.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
> + Known.Zero = std::move(KnownZeroOut);
> break;
> }
> case Instruction::Mul: {
> bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
> - computeKnownBitsMul(I->getOperand(0), I->getOperand(1), NSW, KnownZero,
> - KnownOne, KnownZero2, KnownOne2, Depth, Q);
> + computeKnownBitsMul(I->getOperand(0), I->getOperand(1), NSW, Known,
> + Known2, Depth, Q);
> break;
> }
> case Instruction::UDiv: {
> // For the purposes of computing leading zeros we can conservatively
> // treat a udiv as a logical right shift by the power of 2 known to
> // be less than the denominator.
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> - unsigned LeadZ = KnownZero2.countLeadingOnes();
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
> + unsigned LeadZ = Known2.Zero.countLeadingOnes();
>
> - KnownOne2.clearAllBits();
> - KnownZero2.clearAllBits();
> - computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
> - unsigned RHSUnknownLeadingOnes = KnownOne2.countLeadingZeros();
> + Known2.One.clearAllBits();
> + Known2.Zero.clearAllBits();
> + computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q);
> + unsigned RHSUnknownLeadingOnes = Known2.One.countLeadingZeros();
> if (RHSUnknownLeadingOnes != BitWidth)
> LeadZ = std::min(BitWidth,
> LeadZ + BitWidth - RHSUnknownLeadingOnes - 1);
>
> - KnownZero.setHighBits(LeadZ);
> + Known.Zero.setHighBits(LeadZ);
> break;
> }
> case Instruction::Select: {
> const Value *LHS, *RHS;
> SelectPatternFlavor SPF = matchSelectPattern(I, LHS, RHS).Flavor;
> if (SelectPatternResult::isMinOrMax(SPF)) {
> - computeKnownBits(RHS, KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(LHS, KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(RHS, Known, Depth + 1, Q);
> + computeKnownBits(LHS, Known2, Depth + 1, Q);
> } else {
> - computeKnownBits(I->getOperand(2), KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(2), Known, Depth + 1, Q);
> + computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q);
> }
>
> unsigned MaxHighOnes = 0;
> unsigned MaxHighZeros = 0;
> if (SPF == SPF_SMAX) {
> // If both sides are negative, the result is negative.
> - if (KnownOne.isSignBitSet() && KnownOne2.isSignBitSet())
> + if (Known.One.isSignBitSet() && Known2.One.isSignBitSet())
> // We can derive a lower bound on the result by taking the max of the
> // leading one bits.
> - MaxHighOnes =
> - std::max(KnownOne.countLeadingOnes(), KnownOne2.countLeadingOnes());
> + MaxHighOnes = std::max(Known.One.countLeadingOnes(),
> + Known2.One.countLeadingOnes());
> // If either side is non-negative, the result is non-negative.
> - else if (KnownZero.isSignBitSet() || KnownZero2.isSignBitSet())
> + else if (Known.Zero.isSignBitSet() || Known2.Zero.isSignBitSet())
> MaxHighZeros = 1;
> } else if (SPF == SPF_SMIN) {
> // If both sides are non-negative, the result is non-negative.
> - if (KnownZero.isSignBitSet() && KnownZero2.isSignBitSet())
> + if (Known.Zero.isSignBitSet() && Known2.Zero.isSignBitSet())
> // We can derive an upper bound on the result by taking the max of the
> // leading zero bits.
> - MaxHighZeros = std::max(KnownZero.countLeadingOnes(),
> - KnownZero2.countLeadingOnes());
> + MaxHighZeros = std::max(Known.Zero.countLeadingOnes(),
> + Known2.Zero.countLeadingOnes());
> // If either side is negative, the result is negative.
> - else if (KnownOne.isSignBitSet() || KnownOne2.isSignBitSet())
> + else if (Known.One.isSignBitSet() || Known2.One.isSignBitSet())
> MaxHighOnes = 1;
> } else if (SPF == SPF_UMAX) {
> // We can derive a lower bound on the result by taking the max of the
> // leading one bits.
> MaxHighOnes =
> - std::max(KnownOne.countLeadingOnes(), KnownOne2.countLeadingOnes());
> + std::max(Known.One.countLeadingOnes(), Known2.One.countLeadingOnes());
> } else if (SPF == SPF_UMIN) {
> // We can derive an upper bound on the result by taking the max of the
> // leading zero bits.
> MaxHighZeros =
> - std::max(KnownZero.countLeadingOnes(), KnownZero2.countLeadingOnes());
> + std::max(Known.Zero.countLeadingOnes(), Known2.Zero.countLeadingOnes());
> }
>
> // Only known if known in both the LHS and RHS.
> - KnownOne &= KnownOne2;
> - KnownZero &= KnownZero2;
> + Known.One &= Known2.One;
> + Known.Zero &= Known2.Zero;
> if (MaxHighOnes > 0)
> - KnownOne.setHighBits(MaxHighOnes);
> + Known.One.setHighBits(MaxHighOnes);
> if (MaxHighZeros > 0)
> - KnownZero.setHighBits(MaxHighZeros);
> + Known.Zero.setHighBits(MaxHighZeros);
> break;
> }
> case Instruction::FPTrunc:
> @@ -1055,14 +1052,14 @@ static void computeKnownBitsFromOperator
> SrcBitWidth = Q.DL.getTypeSizeInBits(SrcTy->getScalarType());
>
> assert(SrcBitWidth && "SrcBitWidth can't be zero");
> - KnownZero = KnownZero.zextOrTrunc(SrcBitWidth);
> - KnownOne = KnownOne.zextOrTrunc(SrcBitWidth);
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> - KnownZero = KnownZero.zextOrTrunc(BitWidth);
> - KnownOne = KnownOne.zextOrTrunc(BitWidth);
> + Known.Zero = Known.Zero.zextOrTrunc(SrcBitWidth);
> + Known.One = Known.One.zextOrTrunc(SrcBitWidth);
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> + Known.Zero = Known.Zero.zextOrTrunc(BitWidth);
> + Known.One = Known.One.zextOrTrunc(BitWidth);
> // Any top bits are known to be zero.
> if (BitWidth > SrcBitWidth)
> - KnownZero.setBitsFrom(SrcBitWidth);
> + Known.Zero.setBitsFrom(SrcBitWidth);
> break;
> }
> case Instruction::BitCast: {
> @@ -1071,7 +1068,7 @@ static void computeKnownBitsFromOperator
> // TODO: For now, not handling conversions like:
> // (bitcast i64 %x to <2 x i32>)
> !I->getType()->isVectorTy()) {
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> break;
> }
> break;
> @@ -1080,13 +1077,13 @@ static void computeKnownBitsFromOperator
> // Compute the bits in the result that are not present in the input.
> unsigned SrcBitWidth = I->getOperand(0)->getType()->getScalarSizeInBits();
>
> - KnownZero = KnownZero.trunc(SrcBitWidth);
> - KnownOne = KnownOne.trunc(SrcBitWidth);
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> + Known.Zero = Known.Zero.trunc(SrcBitWidth);
> + Known.One = Known.One.trunc(SrcBitWidth);
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> // If the sign bit of the input is known set or clear, then we know the
> // top bits of the result.
> - KnownZero = KnownZero.sext(BitWidth);
> - KnownOne = KnownOne.sext(BitWidth);
> + Known.Zero = Known.Zero.sext(BitWidth);
> + Known.One = Known.One.sext(BitWidth);
> break;
> }
> case Instruction::Shl: {
> @@ -1109,9 +1106,7 @@ static void computeKnownBitsFromOperator
> return KOResult;
> };
>
> - computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
> - KnownZero2, KnownOne2, Depth, Q, KZF,
> - KOF);
> + computeKnownBitsFromShiftOperator(I, Known, Known2, Depth, Q, KZF, KOF);
> break;
> }
> case Instruction::LShr: {
> @@ -1127,9 +1122,7 @@ static void computeKnownBitsFromOperator
> return KnownOne.lshr(ShiftAmt);
> };
>
> - computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
> - KnownZero2, KnownOne2, Depth, Q, KZF,
> - KOF);
> + computeKnownBitsFromShiftOperator(I, Known, Known2, Depth, Q, KZF, KOF);
> break;
> }
> case Instruction::AShr: {
> @@ -1142,23 +1135,19 @@ static void computeKnownBitsFromOperator
> return KnownOne.ashr(ShiftAmt);
> };
>
> - computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
> - KnownZero2, KnownOne2, Depth, Q, KZF,
> - KOF);
> + computeKnownBitsFromShiftOperator(I, Known, Known2, Depth, Q, KZF, KOF);
> break;
> }
> case Instruction::Sub: {
> bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
> computeKnownBitsAddSub(false, I->getOperand(0), I->getOperand(1), NSW,
> - KnownZero, KnownOne, KnownZero2, KnownOne2, Depth,
> - Q);
> + Known, Known2, Depth, Q);
> break;
> }
> case Instruction::Add: {
> bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
> computeKnownBitsAddSub(true, I->getOperand(0), I->getOperand(1), NSW,
> - KnownZero, KnownOne, KnownZero2, KnownOne2, Depth,
> - Q);
> + Known, Known2, Depth, Q);
> break;
> }
> case Instruction::SRem:
> @@ -1166,34 +1155,33 @@ static void computeKnownBitsFromOperator
> APInt RA = Rem->getValue().abs();
> if (RA.isPowerOf2()) {
> APInt LowBits = RA - 1;
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1,
> - Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
>
> // The low bits of the first operand are unchanged by the srem.
> - KnownZero = KnownZero2 & LowBits;
> - KnownOne = KnownOne2 & LowBits;
> + Known.Zero = Known2.Zero & LowBits;
> + Known.One = Known2.One & LowBits;
>
> // If the first operand is non-negative or has all low bits zero, then
> // the upper bits are all zero.
> - if (KnownZero2.isSignBitSet() || ((KnownZero2 & LowBits) == LowBits))
> - KnownZero |= ~LowBits;
> + if (Known2.Zero.isSignBitSet() || ((Known2.Zero & LowBits) == LowBits))
> + Known.Zero |= ~LowBits;
>
> // If the first operand is negative and not all low bits are zero, then
> // the upper bits are all one.
> - if (KnownOne2.isSignBitSet() && ((KnownOne2 & LowBits) != 0))
> - KnownOne |= ~LowBits;
> + if (Known2.One.isSignBitSet() && ((Known2.One & LowBits) != 0))
> + Known.One |= ~LowBits;
>
> - assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
> + assert((Known.Zero & Known.One) == 0 && "Bits known to be one AND zero?");
> break;
> }
> }
>
> // The sign bit is the LHS's sign bit, except when the result of the
> // remainder is zero.
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
> // If it's known zero, our sign bit is also zero.
> - if (KnownZero2.isSignBitSet())
> - KnownZero.setSignBit();
> + if (Known2.Zero.isSignBitSet())
> + Known.Zero.setSignBit();
>
> break;
> case Instruction::URem: {
> @@ -1201,23 +1189,23 @@ static void computeKnownBitsFromOperator
> const APInt &RA = Rem->getValue();
> if (RA.isPowerOf2()) {
> APInt LowBits = (RA - 1);
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> - KnownZero |= ~LowBits;
> - KnownOne &= LowBits;
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> + Known.Zero |= ~LowBits;
> + Known.One &= LowBits;
> break;
> }
> }
>
> // Since the result is less than or equal to either operand, any leading
> // zero bits in either operand must also exist in the result.
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> - computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> + computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q);
>
> - unsigned Leaders = std::max(KnownZero.countLeadingOnes(),
> - KnownZero2.countLeadingOnes());
> - KnownOne.clearAllBits();
> - KnownZero.clearAllBits();
> - KnownZero.setHighBits(Leaders);
> + unsigned Leaders = std::max(Known.Zero.countLeadingOnes(),
> + Known2.Zero.countLeadingOnes());
> + Known.One.clearAllBits();
> + Known.Zero.clearAllBits();
> + Known.Zero.setHighBits(Leaders);
> break;
> }
>
> @@ -1228,16 +1216,15 @@ static void computeKnownBitsFromOperator
> Align = Q.DL.getABITypeAlignment(AI->getAllocatedType());
>
> if (Align > 0)
> - KnownZero.setLowBits(countTrailingZeros(Align));
> + Known.Zero.setLowBits(countTrailingZeros(Align));
> break;
> }
> case Instruction::GetElementPtr: {
> // Analyze all of the subscripts of this getelementptr instruction
> // to determine if we can prove known low zero bits.
> - APInt LocalKnownZero(BitWidth, 0), LocalKnownOne(BitWidth, 0);
> - computeKnownBits(I->getOperand(0), LocalKnownZero, LocalKnownOne, Depth + 1,
> - Q);
> - unsigned TrailZ = LocalKnownZero.countTrailingOnes();
> + KnownBits LocalKnown(BitWidth);
> + computeKnownBits(I->getOperand(0), LocalKnown, Depth + 1, Q);
> + unsigned TrailZ = LocalKnown.Zero.countTrailingOnes();
>
> gep_type_iterator GTI = gep_type_begin(I);
> for (unsigned i = 1, e = I->getNumOperands(); i != e; ++i, ++GTI) {
> @@ -1267,15 +1254,15 @@ static void computeKnownBitsFromOperator
> }
> unsigned GEPOpiBits = Index->getType()->getScalarSizeInBits();
> uint64_t TypeSize = Q.DL.getTypeAllocSize(IndexedTy);
> - LocalKnownZero = LocalKnownOne = APInt(GEPOpiBits, 0);
> - computeKnownBits(Index, LocalKnownZero, LocalKnownOne, Depth + 1, Q);
> + LocalKnown.Zero = LocalKnown.One = APInt(GEPOpiBits, 0);
> + computeKnownBits(Index, LocalKnown, Depth + 1, Q);
> TrailZ = std::min(TrailZ,
> unsigned(countTrailingZeros(TypeSize) +
> - LocalKnownZero.countTrailingOnes()));
> + LocalKnown.Zero.countTrailingOnes()));
> }
> }
>
> - KnownZero.setLowBits(TrailZ);
> + Known.Zero.setLowBits(TrailZ);
> break;
> }
> case Instruction::PHI: {
> @@ -1310,14 +1297,14 @@ static void computeKnownBitsFromOperator
> break;
> // Ok, we have a PHI of the form L op= R. Check for low
> // zero bits.
> - computeKnownBits(R, KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(R, Known2, Depth + 1, Q);
>
> // We need to take the minimum number of known bits
> - APInt KnownZero3(KnownZero), KnownOne3(KnownOne);
> - computeKnownBits(L, KnownZero3, KnownOne3, Depth + 1, Q);
> + KnownBits Known3(Known);
> + computeKnownBits(L, Known3, Depth + 1, Q);
>
> - KnownZero.setLowBits(std::min(KnownZero2.countTrailingOnes(),
> - KnownZero3.countTrailingOnes()));
> + Known.Zero.setLowBits(std::min(Known2.Zero.countTrailingOnes(),
> + Known3.Zero.countTrailingOnes()));
>
> if (DontImproveNonNegativePhiBits)
> break;
> @@ -1334,25 +1321,25 @@ static void computeKnownBitsFromOperator
> // (add non-negative, non-negative) --> non-negative
> // (add negative, negative) --> negative
> if (Opcode == Instruction::Add) {
> - if (KnownZero2.isSignBitSet() && KnownZero3.isSignBitSet())
> - KnownZero.setSignBit();
> - else if (KnownOne2.isSignBitSet() && KnownOne3.isSignBitSet())
> - KnownOne.setSignBit();
> + if (Known2.Zero.isSignBitSet() && Known3.Zero.isSignBitSet())
> + Known.Zero.setSignBit();
> + else if (Known2.One.isSignBitSet() && Known3.One.isSignBitSet())
> + Known.One.setSignBit();
> }
>
> // (sub nsw non-negative, negative) --> non-negative
> // (sub nsw negative, non-negative) --> negative
> else if (Opcode == Instruction::Sub && LL == I) {
> - if (KnownZero2.isSignBitSet() && KnownOne3.isSignBitSet())
> - KnownZero.setSignBit();
> - else if (KnownOne2.isSignBitSet() && KnownZero3.isSignBitSet())
> - KnownOne.setSignBit();
> + if (Known2.Zero.isSignBitSet() && Known3.One.isSignBitSet())
> + Known.Zero.setSignBit();
> + else if (Known2.One.isSignBitSet() && Known3.Zero.isSignBitSet())
> + Known.One.setSignBit();
> }
>
> // (mul nsw non-negative, non-negative) --> non-negative
> - else if (Opcode == Instruction::Mul && KnownZero2.isSignBitSet() &&
> - KnownZero3.isSignBitSet())
> - KnownZero.setSignBit();
> + else if (Opcode == Instruction::Mul && Known2.Zero.isSignBitSet() &&
> + Known3.Zero.isSignBitSet())
> + Known.Zero.setSignBit();
> }
>
> break;
> @@ -1366,27 +1353,26 @@ static void computeKnownBitsFromOperator
>
> // Otherwise take the unions of the known bit sets of the operands,
> // taking conservative care to avoid excessive recursion.
> - if (Depth < MaxDepth - 1 && !KnownZero && !KnownOne) {
> + if (Depth < MaxDepth - 1 && !Known.Zero && !Known.One) {
> // Skip if every incoming value references to ourself.
> if (dyn_cast_or_null<UndefValue>(P->hasConstantValue()))
> break;
>
> - KnownZero.setAllBits();
> - KnownOne.setAllBits();
> + Known.Zero.setAllBits();
> + Known.One.setAllBits();
> for (Value *IncValue : P->incoming_values()) {
> // Skip direct self references.
> if (IncValue == P) continue;
>
> - KnownZero2 = APInt(BitWidth, 0);
> - KnownOne2 = APInt(BitWidth, 0);
> + Known2 = KnownBits(BitWidth);
> // Recurse, but cap the recursion to one level, because we don't
> // want to waste time spinning around in loops.
> - computeKnownBits(IncValue, KnownZero2, KnownOne2, MaxDepth - 1, Q);
> - KnownZero &= KnownZero2;
> - KnownOne &= KnownOne2;
> + computeKnownBits(IncValue, Known2, MaxDepth - 1, Q);
> + Known.Zero &= Known2.Zero;
> + Known.One &= Known2.One;
> // If all bits have been ruled out, there's no need to check
> // more operands.
> - if (!KnownZero && !KnownOne)
> + if (!Known.Zero && !Known.One)
> break;
> }
> }
> @@ -1398,24 +1384,24 @@ static void computeKnownBitsFromOperator
> // and then intersect with known bits based on other properties of the
> // function.
> if (MDNode *MD = cast<Instruction>(I)->getMetadata(LLVMContext::MD_range))
> - computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
> + computeKnownBitsFromRangeMetadata(*MD, Known.Zero, Known.One);
> if (const Value *RV = ImmutableCallSite(I).getReturnedArgOperand()) {
> - computeKnownBits(RV, KnownZero2, KnownOne2, Depth + 1, Q);
> - KnownZero |= KnownZero2;
> - KnownOne |= KnownOne2;
> + computeKnownBits(RV, Known2, Depth + 1, Q);
> + Known.Zero |= Known2.Zero;
> + Known.One |= Known2.One;
> }
> if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
> switch (II->getIntrinsicID()) {
> default: break;
> case Intrinsic::bitreverse:
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> - KnownZero |= KnownZero2.reverseBits();
> - KnownOne |= KnownOne2.reverseBits();
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
> + Known.Zero |= Known2.Zero.reverseBits();
> + Known.One |= Known2.One.reverseBits();
> break;
> case Intrinsic::bswap:
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> - KnownZero |= KnownZero2.byteSwap();
> - KnownOne |= KnownOne2.byteSwap();
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
> + Known.Zero |= Known2.Zero.byteSwap();
> + Known.One |= Known2.One.byteSwap();
> break;
> case Intrinsic::ctlz:
> case Intrinsic::cttz: {
> @@ -1423,22 +1409,22 @@ static void computeKnownBitsFromOperator
> // If this call is undefined for 0, the result will be less than 2^n.
> if (II->getArgOperand(1) == ConstantInt::getTrue(II->getContext()))
> LowBits -= 1;
> - KnownZero.setBitsFrom(LowBits);
> + Known.Zero.setBitsFrom(LowBits);
> break;
> }
> case Intrinsic::ctpop: {
> - computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
> // We can bound the space the count needs. Also, bits known to be zero
> // can't contribute to the population.
> - unsigned BitsPossiblySet = BitWidth - KnownZero2.countPopulation();
> + unsigned BitsPossiblySet = BitWidth - Known2.Zero.countPopulation();
> unsigned LowBits = Log2_32(BitsPossiblySet)+1;
> - KnownZero.setBitsFrom(LowBits);
> + Known.Zero.setBitsFrom(LowBits);
> // TODO: we could bound KnownOne using the lower bound on the number
> // of bits which might be set provided by popcnt KnownOne2.
> break;
> }
> case Intrinsic::x86_sse42_crc32_64_64:
> - KnownZero.setBitsFrom(32);
> + Known.Zero.setBitsFrom(32);
> break;
> }
> }
> @@ -1448,7 +1434,7 @@ static void computeKnownBitsFromOperator
> // tracking the specific element. But at least we might find information
> // valid for all elements of the vector (for example if vector is sign
> // extended, shifted, etc).
> - computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> + computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
> break;
> case Instruction::ExtractValue:
> if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I->getOperand(0))) {
> @@ -1460,20 +1446,19 @@ static void computeKnownBitsFromOperator
> case Intrinsic::uadd_with_overflow:
> case Intrinsic::sadd_with_overflow:
> computeKnownBitsAddSub(true, II->getArgOperand(0),
> - II->getArgOperand(1), false, KnownZero,
> - KnownOne, KnownZero2, KnownOne2, Depth, Q);
> + II->getArgOperand(1), false, Known, Known2,
> + Depth, Q);
> break;
> case Intrinsic::usub_with_overflow:
> case Intrinsic::ssub_with_overflow:
> computeKnownBitsAddSub(false, II->getArgOperand(0),
> - II->getArgOperand(1), false, KnownZero,
> - KnownOne, KnownZero2, KnownOne2, Depth, Q);
> + II->getArgOperand(1), false, Known, Known2,
> + Depth, Q);
> break;
> case Intrinsic::umul_with_overflow:
> case Intrinsic::smul_with_overflow:
> computeKnownBitsMul(II->getArgOperand(0), II->getArgOperand(1), false,
> - KnownZero, KnownOne, KnownZero2, KnownOne2, Depth,
> - Q);
> + Known, Known2, Depth, Q);
> break;
> }
> }
> @@ -1482,7 +1467,7 @@ static void computeKnownBitsFromOperator
> }
>
> /// Determine which bits of V are known to be either zero or one and return
> -/// them in the KnownZero/KnownOne bit sets.
> +/// them in the Known bit set.
> ///
> /// NOTE: we cannot consider 'undef' to be "IsZero" here. The problem is that
> /// we cannot optimize based on the assumption that it is zero without changing
> @@ -1496,11 +1481,11 @@ static void computeKnownBitsFromOperator
> /// where V is a vector, known zero, and known one values are the
> /// same width as the vector element, and the bit is set only if it is true
> /// for all of the elements in the vector.
> -void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
> - unsigned Depth, const Query &Q) {
> +void computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
> + const Query &Q) {
> assert(V && "No Value?");
> assert(Depth <= MaxDepth && "Limit Search Depth");
> - unsigned BitWidth = KnownZero.getBitWidth();
> + unsigned BitWidth = Known.getBitWidth();
>
> assert((V->getType()->isIntOrIntVectorTy() ||
> V->getType()->getScalarType()->isPointerTy()) &&
> @@ -1508,22 +1493,20 @@ void computeKnownBits(const Value *V, AP
> assert((Q.DL.getTypeSizeInBits(V->getType()->getScalarType()) == BitWidth) &&
> (!V->getType()->isIntOrIntVectorTy() ||
> V->getType()->getScalarSizeInBits() == BitWidth) &&
> - KnownZero.getBitWidth() == BitWidth &&
> - KnownOne.getBitWidth() == BitWidth &&
> - "V, KnownOne and KnownZero should have same BitWidth");
> + "V and Known should have same BitWidth");
> (void)BitWidth;
>
> const APInt *C;
> if (match(V, m_APInt(C))) {
> // We know all of the bits for a scalar constant or a splat vector constant!
> - KnownOne = *C;
> - KnownZero = ~KnownOne;
> + Known.One = *C;
> + Known.Zero = ~Known.One;
> return;
> }
> // Null and aggregate-zero are all-zeros.
> if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
> - KnownOne.clearAllBits();
> - KnownZero.setAllBits();
> + Known.One.clearAllBits();
> + Known.Zero.setAllBits();
> return;
> }
> // Handle a constant vector by taking the intersection of the known bits of
> @@ -1531,12 +1514,12 @@ void computeKnownBits(const Value *V, AP
> if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V)) {
> // We know that CDS must be a vector of integers. Take the intersection of
> // each element.
> - KnownZero.setAllBits(); KnownOne.setAllBits();
> + Known.Zero.setAllBits(); Known.One.setAllBits();
> APInt Elt(BitWidth, 0);
> for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
> Elt = CDS->getElementAsInteger(i);
> - KnownZero &= ~Elt;
> - KnownOne &= Elt;
> + Known.Zero &= ~Elt;
> + Known.One &= Elt;
> }
> return;
> }
> @@ -1544,25 +1527,25 @@ void computeKnownBits(const Value *V, AP
> if (const auto *CV = dyn_cast<ConstantVector>(V)) {
> // We know that CV must be a vector of integers. Take the intersection of
> // each element.
> - KnownZero.setAllBits(); KnownOne.setAllBits();
> - APInt Elt(KnownZero.getBitWidth(), 0);
> + Known.Zero.setAllBits(); Known.One.setAllBits();
> + APInt Elt(BitWidth, 0);
> for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
> Constant *Element = CV->getAggregateElement(i);
> auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
> if (!ElementCI) {
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
> return;
> }
> Elt = ElementCI->getValue();
> - KnownZero &= ~Elt;
> - KnownOne &= Elt;
> + Known.Zero &= ~Elt;
> + Known.One &= Elt;
> }
> return;
> }
>
> // Start out not knowing anything.
> - KnownZero.clearAllBits(); KnownOne.clearAllBits();
> + Known.Zero.clearAllBits(); Known.One.clearAllBits();
>
> // We can't imply anything about undefs.
> if (isa<UndefValue>(V))
> @@ -1581,27 +1564,27 @@ void computeKnownBits(const Value *V, AP
> // the bits of its aliasee.
> if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
> if (!GA->isInterposable())
> - computeKnownBits(GA->getAliasee(), KnownZero, KnownOne, Depth + 1, Q);
> + computeKnownBits(GA->getAliasee(), Known, Depth + 1, Q);
> return;
> }
>
> if (const Operator *I = dyn_cast<Operator>(V))
> - computeKnownBitsFromOperator(I, KnownZero, KnownOne, Depth, Q);
> + computeKnownBitsFromOperator(I, Known, Depth, Q);
>
> - // Aligned pointers have trailing zeros - refine KnownZero set
> + // Aligned pointers have trailing zeros - refine Known.Zero set
> if (V->getType()->isPointerTy()) {
> unsigned Align = V->getPointerAlignment(Q.DL);
> if (Align)
> - KnownZero.setLowBits(countTrailingZeros(Align));
> + Known.Zero.setLowBits(countTrailingZeros(Align));
> }
>
> - // computeKnownBitsFromAssume strictly refines KnownZero and
> - // KnownOne. Therefore, we run them after computeKnownBitsFromOperator.
> + // computeKnownBitsFromAssume strictly refines Known.
> + // Therefore, we run them after computeKnownBitsFromOperator.
>
> // Check whether a nearby assume intrinsic can determine some known bits.
> - computeKnownBitsFromAssume(V, KnownZero, KnownOne, Depth, Q);
> + computeKnownBitsFromAssume(V, Known, Depth, Q);
>
> - assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
> + assert((Known.Zero & Known.One) == 0 && "Bits known to be one AND zero?");
> }
>
> /// Determine whether the sign bit is known to be zero or one.
> @@ -1614,11 +1597,10 @@ void ComputeSignBit(const Value *V, bool
> KnownOne = false;
> return;
> }
> - APInt ZeroBits(BitWidth, 0);
> - APInt OneBits(BitWidth, 0);
> - computeKnownBits(V, ZeroBits, OneBits, Depth, Q);
> - KnownOne = OneBits.isSignBitSet();
> - KnownZero = ZeroBits.isSignBitSet();
> + KnownBits Bits(BitWidth);
> + computeKnownBits(V, Bits, Depth, Q);
> + KnownOne = Bits.One.isSignBitSet();
> + KnownZero = Bits.Zero.isSignBitSet();
> }
>
> /// Return true if the given value is known to have exactly one
> @@ -1690,18 +1672,18 @@ bool isKnownToBeAPowerOfTwo(const Value
> return true;
>
> unsigned BitWidth = V->getType()->getScalarSizeInBits();
> - APInt LHSZeroBits(BitWidth, 0), LHSOneBits(BitWidth, 0);
> - computeKnownBits(X, LHSZeroBits, LHSOneBits, Depth, Q);
> + KnownBits LHSBits(BitWidth);
> + computeKnownBits(X, LHSBits, Depth, Q);
>
> - APInt RHSZeroBits(BitWidth, 0), RHSOneBits(BitWidth, 0);
> - computeKnownBits(Y, RHSZeroBits, RHSOneBits, Depth, Q);
> + KnownBits RHSBits(BitWidth);
> + computeKnownBits(Y, RHSBits, Depth, Q);
> // If i8 V is a power of two or zero:
> // ZeroBits: 1 1 1 0 1 1 1 1
> // ~ZeroBits: 0 0 0 1 0 0 0 0
> - if ((~(LHSZeroBits & RHSZeroBits)).isPowerOf2())
> + if ((~(LHSBits.Zero & RHSBits.Zero)).isPowerOf2())
> // If OrZero isn't set, we cannot give back a zero result.
> // Make sure either the LHS or RHS has a bit set.
> - if (OrZero || RHSOneBits.getBoolValue() || LHSOneBits.getBoolValue())
> + if (OrZero || RHSBits.One.getBoolValue() || LHSBits.One.getBoolValue())
> return true;
> }
> }
> @@ -1872,10 +1854,9 @@ bool isKnownNonZero(const Value *V, unsi
> if (BO->hasNoUnsignedWrap())
> return isKnownNonZero(X, Depth, Q);
>
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(X, KnownZero, KnownOne, Depth, Q);
> - if (KnownOne[0])
> + KnownBits Known(BitWidth);
> + computeKnownBits(X, Known, Depth, Q);
> + if (Known.One[0])
> return true;
> }
> // shr X, Y != 0 if X is negative. Note that the value of the shift is not
> @@ -1895,16 +1876,15 @@ bool isKnownNonZero(const Value *V, unsi
> // out are known to be zero, and X is known non-zero then at least one
> // non-zero bit must remain.
> if (ConstantInt *Shift = dyn_cast<ConstantInt>(Y)) {
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(X, KnownZero, KnownOne, Depth, Q);
> + KnownBits Known(BitWidth);
> + computeKnownBits(X, Known, Depth, Q);
>
> auto ShiftVal = Shift->getLimitedValue(BitWidth - 1);
> // Is there a known one in the portion not shifted out?
> - if (KnownOne.countLeadingZeros() < BitWidth - ShiftVal)
> + if (Known.One.countLeadingZeros() < BitWidth - ShiftVal)
> return true;
> // Are all the bits to be shifted out known zero?
> - if (KnownZero.countTrailingOnes() >= ShiftVal)
> + if (Known.Zero.countTrailingOnes() >= ShiftVal)
> return isKnownNonZero(X, Depth, Q);
> }
> }
> @@ -1928,18 +1908,17 @@ bool isKnownNonZero(const Value *V, unsi
> // If X and Y are both negative (as signed values) then their sum is not
> // zero unless both X and Y equal INT_MIN.
> if (BitWidth && XKnownNegative && YKnownNegative) {
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> + KnownBits Known(BitWidth);
> APInt Mask = APInt::getSignedMaxValue(BitWidth);
> // The sign bit of X is set. If some other bit is set then X is not equal
> // to INT_MIN.
> - computeKnownBits(X, KnownZero, KnownOne, Depth, Q);
> - if (KnownOne.intersects(Mask))
> + computeKnownBits(X, Known, Depth, Q);
> + if (Known.One.intersects(Mask))
> return true;
> // The sign bit of Y is set. If some other bit is set then Y is not equal
> // to INT_MIN.
> - computeKnownBits(Y, KnownZero, KnownOne, Depth, Q);
> - if (KnownOne.intersects(Mask))
> + computeKnownBits(Y, Known, Depth, Q);
> + if (Known.One.intersects(Mask))
> return true;
> }
>
> @@ -1994,10 +1973,9 @@ bool isKnownNonZero(const Value *V, unsi
> }
>
> if (!BitWidth) return false;
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(V, KnownZero, KnownOne, Depth, Q);
> - return KnownOne != 0;
> + KnownBits Known(BitWidth);
> + computeKnownBits(V, Known, Depth, Q);
> + return Known.One != 0;
> }
>
> /// Return true if V2 == V1 + X, where X is known non-zero.
> @@ -2029,14 +2007,13 @@ static bool isKnownNonEqual(const Value
> // Are any known bits in V1 contradictory to known bits in V2? If V1
> // has a known zero where V2 has a known one, they must not be equal.
> auto BitWidth = Ty->getBitWidth();
> - APInt KnownZero1(BitWidth, 0);
> - APInt KnownOne1(BitWidth, 0);
> - computeKnownBits(V1, KnownZero1, KnownOne1, 0, Q);
> - APInt KnownZero2(BitWidth, 0);
> - APInt KnownOne2(BitWidth, 0);
> - computeKnownBits(V2, KnownZero2, KnownOne2, 0, Q);
> + KnownBits Known1(BitWidth);
> + computeKnownBits(V1, Known1, 0, Q);
> + KnownBits Known2(BitWidth);
> + computeKnownBits(V2, Known2, 0, Q);
>
> - APInt OppositeBits = (KnownZero1 & KnownOne2) | (KnownZero2 & KnownOne1);
> + APInt OppositeBits = (Known1.Zero & Known2.One) |
> + (Known2.Zero & Known1.One);
> if (OppositeBits.getBoolValue())
> return true;
> }
> @@ -2054,9 +2031,9 @@ static bool isKnownNonEqual(const Value
> /// for all of the elements in the vector.
> bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth,
> const Query &Q) {
> - APInt KnownZero(Mask.getBitWidth(), 0), KnownOne(Mask.getBitWidth(), 0);
> - computeKnownBits(V, KnownZero, KnownOne, Depth, Q);
> - return Mask.isSubsetOf(KnownZero);
> + KnownBits Known(Mask.getBitWidth());
> + computeKnownBits(V, Known, Depth, Q);
> + return Mask.isSubsetOf(Known.Zero);
> }
>
> /// For vector constants, loop over the elements and find the constant with the
> @@ -2234,17 +2211,17 @@ static unsigned ComputeNumSignBitsImpl(c
> // Special case decrementing a value (ADD X, -1):
> if (const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
> if (CRHS->isAllOnesValue()) {
> - APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
> - computeKnownBits(U->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
> + KnownBits Known(TyBits);
> + computeKnownBits(U->getOperand(0), Known, Depth + 1, Q);
>
> // If the input is known to be 0 or 1, the output is 0/-1, which is all
> // sign bits set.
> - if ((KnownZero | 1).isAllOnesValue())
> + if ((Known.Zero | 1).isAllOnesValue())
> return TyBits;
>
> // If we are subtracting one from a positive number, there is no carry
> // out of the result.
> - if (KnownZero.isSignBitSet())
> + if (Known.Zero.isSignBitSet())
> return Tmp;
> }
>
> @@ -2259,16 +2236,16 @@ static unsigned ComputeNumSignBitsImpl(c
> // Handle NEG.
> if (const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
> if (CLHS->isNullValue()) {
> - APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
> - computeKnownBits(U->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
> + KnownBits Known(TyBits);
> + computeKnownBits(U->getOperand(1), Known, Depth + 1, Q);
> // If the input is known to be 0 or 1, the output is 0/-1, which is all
> // sign bits set.
> - if ((KnownZero | 1).isAllOnesValue())
> + if ((Known.Zero | 1).isAllOnesValue())
> return TyBits;
>
> // If the input is known to be positive (the sign bit is known clear),
> // the output of the NEG has the same number of sign bits as the input.
> - if (KnownZero.isSignBitSet())
> + if (Known.Zero.isSignBitSet())
> return Tmp2;
>
> // Otherwise, we treat this like a SUB.
> @@ -2320,16 +2297,16 @@ static unsigned ComputeNumSignBitsImpl(c
> if (unsigned VecSignBits = computeNumSignBitsVectorConstant(V, TyBits))
> return VecSignBits;
>
> - APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
> - computeKnownBits(V, KnownZero, KnownOne, Depth, Q);
> + KnownBits Known(TyBits);
> + computeKnownBits(V, Known, Depth, Q);
>
> // If we know that the sign bit is either zero or one, determine the number of
> // identical bits in the top of the input value.
> - if (KnownZero.isSignBitSet())
> - return std::max(FirstAnswer, KnownZero.countLeadingOnes());
> + if (Known.Zero.isSignBitSet())
> + return std::max(FirstAnswer, Known.Zero.countLeadingOnes());
>
> - if (KnownOne.isSignBitSet())
> - return std::max(FirstAnswer, KnownOne.countLeadingOnes());
> + if (Known.One.isSignBitSet())
> + return std::max(FirstAnswer, Known.One.countLeadingOnes());
>
> // computeKnownBits gave us no extra information about the top bits.
> return FirstAnswer;
> @@ -3535,26 +3512,22 @@ OverflowResult llvm::computeOverflowForU
> // we can guarantee that the result does not overflow.
> // Ref: "Hacker's Delight" by Henry Warren
> unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
> - APInt LHSKnownZero(BitWidth, 0);
> - APInt LHSKnownOne(BitWidth, 0);
> - APInt RHSKnownZero(BitWidth, 0);
> - APInt RHSKnownOne(BitWidth, 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, DL, /*Depth=*/0, AC, CxtI,
> - DT);
> - computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, DL, /*Depth=*/0, AC, CxtI,
> - DT);
> + KnownBits LHSKnown(BitWidth);
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(LHS, LHSKnown, DL, /*Depth=*/0, AC, CxtI, DT);
> + computeKnownBits(RHS, RHSKnown, DL, /*Depth=*/0, AC, CxtI, DT);
> // Note that underestimating the number of zero bits gives a more
> // conservative answer.
> - unsigned ZeroBits = LHSKnownZero.countLeadingOnes() +
> - RHSKnownZero.countLeadingOnes();
> + unsigned ZeroBits = LHSKnown.Zero.countLeadingOnes() +
> + RHSKnown.Zero.countLeadingOnes();
> // First handle the easy case: if we have enough zero bits there's
> // definitely no overflow.
> if (ZeroBits >= BitWidth)
> return OverflowResult::NeverOverflows;
>
> // Get the largest possible values for each operand.
> - APInt LHSMax = ~LHSKnownZero;
> - APInt RHSMax = ~RHSKnownZero;
> + APInt LHSMax = ~LHSKnown.Zero;
> + APInt RHSMax = ~RHSKnown.Zero;
>
> // We know the multiply operation doesn't overflow if the maximum values for
> // each operand will not overflow after we multiply them together.
> @@ -3566,7 +3539,7 @@ OverflowResult llvm::computeOverflowForU
> // We know it always overflows if multiplying the smallest possible values for
> // the operands also results in overflow.
> bool MinOverflow;
> - (void)LHSKnownOne.umul_ov(RHSKnownOne, MinOverflow);
> + (void)LHSKnown.One.umul_ov(RHSKnown.One, MinOverflow);
> if (MinOverflow)
> return OverflowResult::AlwaysOverflows;
>
> @@ -4285,11 +4258,10 @@ static bool isTruePredicate(CmpInst::Pre
> // If X & C == 0 then (X | C) == X +_{nuw} C
> if (match(A, m_Or(m_Value(X), m_APInt(CA))) &&
> match(B, m_Or(m_Specific(X), m_APInt(CB)))) {
> - unsigned BitWidth = CA->getBitWidth();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(X, KnownZero, KnownOne, DL, Depth + 1, AC, CxtI, DT);
> + KnownBits Known(CA->getBitWidth());
> + computeKnownBits(X, Known, DL, Depth + 1, AC, CxtI, DT);
>
> - if (CA->isSubsetOf(KnownZero) && CB->isSubsetOf(KnownZero))
> + if (CA->isSubsetOf(Known.Zero) && CB->isSubsetOf(Known.Zero))
> return true;
> }
>
>
> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (original)
> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp Wed Apr 26 11:39:58 2017
> @@ -36,6 +36,7 @@
> #include "llvm/IR/Intrinsics.h"
> #include "llvm/Support/Debug.h"
> #include "llvm/Support/ErrorHandling.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/ManagedStatic.h"
> #include "llvm/Support/MathExtras.h"
> #include "llvm/Support/Mutex.h"
> @@ -7539,10 +7540,10 @@ unsigned SelectionDAG::InferPtrAlignment
> int64_t GVOffset = 0;
> if (TLI->isGAPlusOffset(Ptr.getNode(), GV, GVOffset)) {
> unsigned PtrWidth = getDataLayout().getPointerTypeSizeInBits(GV->getType());
> - APInt KnownZero(PtrWidth, 0), KnownOne(PtrWidth, 0);
> - llvm::computeKnownBits(const_cast<GlobalValue *>(GV), KnownZero, KnownOne,
> + KnownBits Known(PtrWidth);
> + llvm::computeKnownBits(const_cast<GlobalValue *>(GV), Known,
> getDataLayout());
> - unsigned AlignBits = KnownZero.countTrailingOnes();
> + unsigned AlignBits = Known.Zero.countTrailingOnes();
> unsigned Align = AlignBits ? 1 << std::min(31U, AlignBits) : 0;
> if (Align)
> return MinAlign(Align, GVOffset);
>
> Modified: llvm/trunk/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp (original)
> +++ llvm/trunk/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp Wed Apr 26 11:39:58 2017
> @@ -26,6 +26,7 @@
> #include "llvm/Transforms/Scalar.h"
> #include "llvm/Transforms/Utils/Local.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/raw_ostream.h"
>
> #include <algorithm>
> @@ -1206,10 +1207,9 @@ bool PolynomialMultiplyRecognize::highBi
> if (!T)
> return false;
>
> - unsigned BW = T->getBitWidth();
> - APInt K0(BW, 0), K1(BW, 0);
> - computeKnownBits(V, K0, K1, DL);
> - return K0.countLeadingOnes() >= IterCount;
> + KnownBits Known(T->getBitWidth());
> + computeKnownBits(V, Known, DL);
> + return Known.Zero.countLeadingOnes() >= IterCount;
> }
>
>
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp Wed Apr 26 11:39:58 2017
> @@ -17,6 +17,7 @@
> #include "llvm/IR/DataLayout.h"
> #include "llvm/IR/GetElementPtrTypeIterator.h"
> #include "llvm/IR/PatternMatch.h"
> +#include "llvm/Support/KnownBits.h"
>
> using namespace llvm;
> using namespace PatternMatch;
> @@ -899,24 +900,22 @@ bool InstCombiner::WillNotOverflowSigned
> return true;
>
> unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
> - APInt LHSKnownZero(BitWidth, 0);
> - APInt LHSKnownOne(BitWidth, 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, &CxtI);
> -
> - APInt RHSKnownZero(BitWidth, 0);
> - APInt RHSKnownOne(BitWidth, 0);
> - computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, &CxtI);
> + KnownBits LHSKnown(BitWidth);
> + computeKnownBits(LHS, LHSKnown, 0, &CxtI);
> +
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(RHS, RHSKnown, 0, &CxtI);
>
> // Addition of two 2's complement numbers having opposite signs will never
> // overflow.
> - if ((LHSKnownOne[BitWidth - 1] && RHSKnownZero[BitWidth - 1]) ||
> - (LHSKnownZero[BitWidth - 1] && RHSKnownOne[BitWidth - 1]))
> + if ((LHSKnown.One[BitWidth - 1] && RHSKnown.Zero[BitWidth - 1]) ||
> + (LHSKnown.Zero[BitWidth - 1] && RHSKnown.One[BitWidth - 1]))
> return true;
>
> // Check if carry bit of addition will not cause overflow.
> - if (checkRippleForAdd(LHSKnownZero, RHSKnownZero))
> + if (checkRippleForAdd(LHSKnown.Zero, RHSKnown.Zero))
> return true;
> - if (checkRippleForAdd(RHSKnownZero, LHSKnownZero))
> + if (checkRippleForAdd(RHSKnown.Zero, LHSKnown.Zero))
> return true;
>
> return false;
> @@ -936,18 +935,16 @@ bool InstCombiner::WillNotOverflowSigned
> return true;
>
> unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
> - APInt LHSKnownZero(BitWidth, 0);
> - APInt LHSKnownOne(BitWidth, 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, &CxtI);
> -
> - APInt RHSKnownZero(BitWidth, 0);
> - APInt RHSKnownOne(BitWidth, 0);
> - computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, &CxtI);
> + KnownBits LHSKnown(BitWidth);
> + computeKnownBits(LHS, LHSKnown, 0, &CxtI);
> +
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(RHS, RHSKnown, 0, &CxtI);
>
> // Subtraction of two 2's complement numbers having identical signs will
> // never overflow.
> - if ((LHSKnownOne[BitWidth - 1] && RHSKnownOne[BitWidth - 1]) ||
> - (LHSKnownZero[BitWidth - 1] && RHSKnownZero[BitWidth - 1]))
> + if ((LHSKnown.One[BitWidth - 1] && RHSKnown.One[BitWidth - 1]) ||
> + (LHSKnown.Zero[BitWidth - 1] && RHSKnown.Zero[BitWidth - 1]))
> return true;
>
> // TODO: implement logic similar to checkRippleForAdd
> @@ -1118,10 +1115,9 @@ Instruction *InstCombiner::visitAdd(Bina
> // a sub and fuse this add with it.
> if (LHS->hasOneUse() && (XorRHS->getValue()+1).isPowerOf2()) {
> IntegerType *IT = cast<IntegerType>(I.getType());
> - APInt LHSKnownOne(IT->getBitWidth(), 0);
> - APInt LHSKnownZero(IT->getBitWidth(), 0);
> - computeKnownBits(XorLHS, LHSKnownZero, LHSKnownOne, 0, &I);
> - if ((XorRHS->getValue() | LHSKnownZero).isAllOnesValue())
> + KnownBits LHSKnown(IT->getBitWidth());
> + computeKnownBits(XorLHS, LHSKnown, 0, &I);
> + if ((XorRHS->getValue() | LHSKnown.Zero).isAllOnesValue())
> return BinaryOperator::CreateSub(ConstantExpr::getAdd(XorRHS, CI),
> XorLHS);
> }
> @@ -1641,10 +1637,9 @@ Instruction *InstCombiner::visitSub(Bina
> // Turn this into a xor if LHS is 2^n-1 and the remaining bits are known
> // zero.
> if (Op0C->isMask()) {
> - APInt RHSKnownZero(BitWidth, 0);
> - APInt RHSKnownOne(BitWidth, 0);
> - computeKnownBits(Op1, RHSKnownZero, RHSKnownOne, 0, &I);
> - if ((*Op0C | RHSKnownZero).isAllOnesValue())
> + KnownBits RHSKnown(BitWidth);
> + computeKnownBits(Op1, RHSKnown, 0, &I);
> + if ((*Op0C | RHSKnown.Zero).isAllOnesValue())
> return BinaryOperator::CreateXor(Op1, Op0);
> }
> }
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Wed Apr 26 11:39:58 2017
> @@ -44,6 +44,7 @@
> #include "llvm/IR/ValueHandle.h"
> #include "llvm/Support/Casting.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include "llvm/Transforms/Utils/Local.h"
> #include "llvm/Transforms/Utils/SimplifyLibCalls.h"
> @@ -1378,14 +1379,13 @@ static Instruction *foldCttzCtlz(Intrins
> return nullptr;
>
> unsigned BitWidth = IT->getBitWidth();
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - IC.computeKnownBits(Op0, KnownZero, KnownOne, 0, &II);
> + KnownBits Known(BitWidth);
> + IC.computeKnownBits(Op0, Known, 0, &II);
>
> // Create a mask for bits above (ctlz) or below (cttz) the first known one.
> bool IsTZ = II.getIntrinsicID() == Intrinsic::cttz;
> - unsigned NumMaskBits = IsTZ ? KnownOne.countTrailingZeros()
> - : KnownOne.countLeadingZeros();
> + unsigned NumMaskBits = IsTZ ? Known.One.countTrailingZeros()
> + : Known.One.countLeadingZeros();
> APInt Mask = IsTZ ? APInt::getLowBitsSet(BitWidth, NumMaskBits)
> : APInt::getHighBitsSet(BitWidth, NumMaskBits);
>
> @@ -1393,7 +1393,7 @@ static Instruction *foldCttzCtlz(Intrins
> // zero, this value is constant.
> // FIXME: This should be in InstSimplify because we're replacing an
> // instruction with a constant.
> - if (Mask.isSubsetOf(KnownZero)) {
> + if (Mask.isSubsetOf(Known.Zero)) {
> auto *C = ConstantInt::get(IT, APInt(BitWidth, NumMaskBits));
> return IC.replaceInstUsesWith(II, C);
> }
> @@ -1401,7 +1401,7 @@ static Instruction *foldCttzCtlz(Intrins
> // If the input to cttz/ctlz is known to be non-zero,
> // then change the 'ZeroIsUndef' parameter to 'true'
> // because we know the zero behavior can't affect the result.
> - if (KnownOne != 0 || isKnownNonZero(Op0, IC.getDataLayout())) {
> + if (Known.One != 0 || isKnownNonZero(Op0, IC.getDataLayout())) {
> if (!match(II.getArgOperand(1), m_One())) {
> II.setOperand(1, IC.Builder->getTrue());
> return &II;
> @@ -3617,9 +3617,9 @@ Instruction *InstCombiner::visitCallInst
>
> // If there is a dominating assume with the same condition as this one,
> // then this one is redundant, and should be removed.
> - APInt KnownZero(1, 0), KnownOne(1, 0);
> - computeKnownBits(IIOperand, KnownZero, KnownOne, 0, II);
> - if (KnownOne.isAllOnesValue())
> + KnownBits Known(1);
> + computeKnownBits(IIOperand, Known, 0, II);
> + if (Known.One.isAllOnesValue())
> return eraseInstFromFunction(*II);
>
> // Update the cache of affected values for this assumption (we might be
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCasts.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCasts.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCasts.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCasts.cpp Wed Apr 26 11:39:58 2017
> @@ -14,9 +14,10 @@
> #include "InstCombineInternal.h"
> #include "llvm/ADT/SetVector.h"
> #include "llvm/Analysis/ConstantFolding.h"
> +#include "llvm/Analysis/TargetLibraryInfo.h"
> #include "llvm/IR/DataLayout.h"
> #include "llvm/IR/PatternMatch.h"
> -#include "llvm/Analysis/TargetLibraryInfo.h"
> +#include "llvm/Support/KnownBits.h"
> using namespace llvm;
> using namespace PatternMatch;
>
> @@ -676,11 +677,10 @@ Instruction *InstCombiner::transformZExt
> // This only works for EQ and NE
> ICI->isEquality()) {
> // If Op1C some other power of two, convert:
> - uint32_t BitWidth = Op1C->getType()->getBitWidth();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(ICI->getOperand(0), KnownZero, KnownOne, 0, &CI);
> + KnownBits Known(Op1C->getType()->getBitWidth());
> + computeKnownBits(ICI->getOperand(0), Known, 0, &CI);
>
> - APInt KnownZeroMask(~KnownZero);
> + APInt KnownZeroMask(~Known.Zero);
> if (KnownZeroMask.isPowerOf2()) { // Exactly 1 possible 1?
> if (!DoTransform) return ICI;
>
> @@ -726,13 +726,13 @@ Instruction *InstCombiner::transformZExt
> Value *LHS = ICI->getOperand(0);
> Value *RHS = ICI->getOperand(1);
>
> - APInt KnownZeroLHS(BitWidth, 0), KnownOneLHS(BitWidth, 0);
> - APInt KnownZeroRHS(BitWidth, 0), KnownOneRHS(BitWidth, 0);
> - computeKnownBits(LHS, KnownZeroLHS, KnownOneLHS, 0, &CI);
> - computeKnownBits(RHS, KnownZeroRHS, KnownOneRHS, 0, &CI);
> + KnownBits KnownLHS(BitWidth);
> + KnownBits KnownRHS(BitWidth);
> + computeKnownBits(LHS, KnownLHS, 0, &CI);
> + computeKnownBits(RHS, KnownRHS, 0, &CI);
>
> - if (KnownZeroLHS == KnownZeroRHS && KnownOneLHS == KnownOneRHS) {
> - APInt KnownBits = KnownZeroLHS | KnownOneLHS;
> + if (KnownLHS.Zero == KnownRHS.Zero && KnownLHS.One == KnownRHS.One) {
> + APInt KnownBits = KnownLHS.Zero | KnownLHS.One;
> APInt UnknownBit = ~KnownBits;
> if (UnknownBit.countPopulation() == 1) {
> if (!DoTransform) return ICI;
> @@ -740,7 +740,7 @@ Instruction *InstCombiner::transformZExt
> Value *Result = Builder->CreateXor(LHS, RHS);
>
> // Mask off any bits that are set and won't be shifted away.
> - if (KnownOneLHS.uge(UnknownBit))
> + if (KnownLHS.One.uge(UnknownBit))
> Result = Builder->CreateAnd(Result,
> ConstantInt::get(ITy, UnknownBit));
>
> @@ -1049,10 +1049,10 @@ Instruction *InstCombiner::transformSExt
> if (ICI->hasOneUse() &&
> ICI->isEquality() && (Op1C->isZero() || Op1C->getValue().isPowerOf2())){
> unsigned BitWidth = Op1C->getType()->getBitWidth();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(Op0, KnownZero, KnownOne, 0, &CI);
> + KnownBits Known(BitWidth);
> + computeKnownBits(Op0, Known, 0, &CI);
>
> - APInt KnownZeroMask(~KnownZero);
> + APInt KnownZeroMask(~Known.Zero);
> if (KnownZeroMask.isPowerOf2()) {
> Value *In = ICI->getOperand(0);
>
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp Wed Apr 26 11:39:58 2017
> @@ -26,6 +26,7 @@
> #include "llvm/IR/IntrinsicInst.h"
> #include "llvm/IR/PatternMatch.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
>
> using namespace llvm;
> using namespace PatternMatch;
> @@ -175,19 +176,18 @@ static bool isSignTest(ICmpInst::Predica
> /// Given a signed integer type and a set of known zero and one bits, compute
> /// the maximum and minimum values that could have the specified known zero and
> /// known one bits, returning them in Min/Max.
> -static void computeSignedMinMaxValuesFromKnownBits(const APInt &KnownZero,
> - const APInt &KnownOne,
> +/// TODO: Move to method on KnownBits struct?
> +static void computeSignedMinMaxValuesFromKnownBits(const KnownBits &Known,
> APInt &Min, APInt &Max) {
> - assert(KnownZero.getBitWidth() == KnownOne.getBitWidth() &&
> - KnownZero.getBitWidth() == Min.getBitWidth() &&
> - KnownZero.getBitWidth() == Max.getBitWidth() &&
> + assert(Known.getBitWidth() == Min.getBitWidth() &&
> + Known.getBitWidth() == Max.getBitWidth() &&
> "KnownZero, KnownOne and Min, Max must have equal bitwidth.");
> - APInt UnknownBits = ~(KnownZero|KnownOne);
> + APInt UnknownBits = ~(Known.Zero|Known.One);
>
> // The minimum value is when all unknown bits are zeros, EXCEPT for the sign
> // bit if it is unknown.
> - Min = KnownOne;
> - Max = KnownOne|UnknownBits;
> + Min = Known.One;
> + Max = Known.One|UnknownBits;
>
> if (UnknownBits.isNegative()) { // Sign bit is unknown
> Min.setBit(Min.getBitWidth()-1);
> @@ -198,19 +198,18 @@ static void computeSignedMinMaxValuesFro
> /// Given an unsigned integer type and a set of known zero and one bits, compute
> /// the maximum and minimum values that could have the specified known zero and
> /// known one bits, returning them in Min/Max.
> -static void computeUnsignedMinMaxValuesFromKnownBits(const APInt &KnownZero,
> - const APInt &KnownOne,
> +/// TODO: Move to method on KnownBits struct?
> +static void computeUnsignedMinMaxValuesFromKnownBits(const KnownBits &Known,
> APInt &Min, APInt &Max) {
> - assert(KnownZero.getBitWidth() == KnownOne.getBitWidth() &&
> - KnownZero.getBitWidth() == Min.getBitWidth() &&
> - KnownZero.getBitWidth() == Max.getBitWidth() &&
> + assert(Known.getBitWidth() == Min.getBitWidth() &&
> + Known.getBitWidth() == Max.getBitWidth() &&
> "Ty, KnownZero, KnownOne and Min, Max must have equal bitwidth.");
> - APInt UnknownBits = ~(KnownZero|KnownOne);
> + APInt UnknownBits = ~(Known.Zero|Known.One);
>
> // The minimum value is when the unknown bits are all zeros.
> - Min = KnownOne;
> + Min = Known.One;
> // The maximum value is when the unknown bits are all ones.
> - Max = KnownOne|UnknownBits;
> + Max = Known.One|UnknownBits;
> }
>
> /// This is called when we see this pattern:
> @@ -1479,14 +1478,14 @@ Instruction *InstCombiner::foldICmpTrunc
> // of the high bits truncated out of x are known.
> unsigned DstBits = Trunc->getType()->getScalarSizeInBits(),
> SrcBits = X->getType()->getScalarSizeInBits();
> - APInt KnownZero(SrcBits, 0), KnownOne(SrcBits, 0);
> - computeKnownBits(X, KnownZero, KnownOne, 0, &Cmp);
> + KnownBits Known(SrcBits);
> + computeKnownBits(X, Known, 0, &Cmp);
>
> // If all the high bits are known, we can do this xform.
> - if ((KnownZero | KnownOne).countLeadingOnes() >= SrcBits - DstBits) {
> + if ((Known.Zero | Known.One).countLeadingOnes() >= SrcBits - DstBits) {
> // Pull in the high bits from known-ones set.
> APInt NewRHS = C->zext(SrcBits);
> - NewRHS |= KnownOne & APInt::getHighBitsSet(SrcBits, SrcBits - DstBits);
> + NewRHS |= Known.One & APInt::getHighBitsSet(SrcBits, SrcBits - DstBits);
> return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), NewRHS));
> }
> }
> @@ -4001,16 +4000,16 @@ Instruction *InstCombiner::foldICmpUsing
> IsSignBit = isSignBitCheck(Pred, *CmpC, UnusedBit);
> }
>
> - APInt Op0KnownZero(BitWidth, 0), Op0KnownOne(BitWidth, 0);
> - APInt Op1KnownZero(BitWidth, 0), Op1KnownOne(BitWidth, 0);
> + KnownBits Op0Known(BitWidth);
> + KnownBits Op1Known(BitWidth);
>
> if (SimplifyDemandedBits(&I, 0,
> getDemandedBitsLHSMask(I, BitWidth, IsSignBit),
> - Op0KnownZero, Op0KnownOne, 0))
> + Op0Known, 0))
> return &I;
>
> if (SimplifyDemandedBits(&I, 1, APInt::getAllOnesValue(BitWidth),
> - Op1KnownZero, Op1KnownOne, 0))
> + Op1Known, 0))
> return &I;
>
> // Given the known and unknown bits, compute a range that the LHS could be
> @@ -4019,15 +4018,11 @@ Instruction *InstCombiner::foldICmpUsing
> APInt Op0Min(BitWidth, 0), Op0Max(BitWidth, 0);
> APInt Op1Min(BitWidth, 0), Op1Max(BitWidth, 0);
> if (I.isSigned()) {
> - computeSignedMinMaxValuesFromKnownBits(Op0KnownZero, Op0KnownOne, Op0Min,
> - Op0Max);
> - computeSignedMinMaxValuesFromKnownBits(Op1KnownZero, Op1KnownOne, Op1Min,
> - Op1Max);
> + computeSignedMinMaxValuesFromKnownBits(Op0Known, Op0Min, Op0Max);
> + computeSignedMinMaxValuesFromKnownBits(Op1Known, Op1Min, Op1Max);
> } else {
> - computeUnsignedMinMaxValuesFromKnownBits(Op0KnownZero, Op0KnownOne, Op0Min,
> - Op0Max);
> - computeUnsignedMinMaxValuesFromKnownBits(Op1KnownZero, Op1KnownOne, Op1Min,
> - Op1Max);
> + computeUnsignedMinMaxValuesFromKnownBits(Op0Known, Op0Min, Op0Max);
> + computeUnsignedMinMaxValuesFromKnownBits(Op1Known, Op1Min, Op1Max);
> }
>
> // If Min and Max are known to be the same, then SimplifyDemandedBits
> @@ -4054,8 +4049,8 @@ Instruction *InstCombiner::foldICmpUsing
> // If all bits are known zero except for one, then we know at most one bit
> // is set. If the comparison is against zero, then this is a check to see if
> // *that* bit is set.
> - APInt Op0KnownZeroInverted = ~Op0KnownZero;
> - if (~Op1KnownZero == 0) {
> + APInt Op0KnownZeroInverted = ~Op0Known.Zero;
> + if (~Op1Known.Zero == 0) {
> // If the LHS is an AND with the same constant, look through it.
> Value *LHS = nullptr;
> const APInt *LHSC;
> @@ -4193,8 +4188,8 @@ Instruction *InstCombiner::foldICmpUsing
> // Turn a signed comparison into an unsigned one if both operands are known to
> // have the same sign.
> if (I.isSigned() &&
> - ((Op0KnownZero.isNegative() && Op1KnownZero.isNegative()) ||
> - (Op0KnownOne.isNegative() && Op1KnownOne.isNegative())))
> + ((Op0Known.Zero.isNegative() && Op1Known.Zero.isNegative()) ||
> + (Op0Known.One.isNegative() && Op1Known.One.isNegative())))
> return new ICmpInst(I.getUnsignedPredicate(), Op0, Op1);
>
> return nullptr;
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineInternal.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineInternal.h?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineInternal.h (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineInternal.h Wed Apr 26 11:39:58 2017
> @@ -489,10 +489,9 @@ public:
> return nullptr; // Don't do anything with FI
> }
>
> - void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
> + void computeKnownBits(Value *V, KnownBits &Known,
> unsigned Depth, Instruction *CxtI) const {
> - return llvm::computeKnownBits(V, KnownZero, KnownOne, DL, Depth, &AC, CxtI,
> - &DT);
> + return llvm::computeKnownBits(V, Known, DL, Depth, &AC, CxtI, &DT);
> }
>
> bool MaskedValueIsZero(Value *V, const APInt &Mask, unsigned Depth = 0,
> @@ -536,25 +535,23 @@ private:
>
> /// \brief Attempts to replace V with a simpler value based on the demanded
> /// bits.
> - Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, APInt &KnownZero,
> - APInt &KnownOne, unsigned Depth,
> - Instruction *CxtI);
> + Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, KnownBits &Known,
> + unsigned Depth, Instruction *CxtI);
> bool SimplifyDemandedBits(Instruction *I, unsigned Op,
> - const APInt &DemandedMask, APInt &KnownZero,
> - APInt &KnownOne, unsigned Depth = 0);
> + const APInt &DemandedMask, KnownBits &Known,
> + unsigned Depth = 0);
> /// Helper routine of SimplifyDemandedUseBits. It computes KnownZero/KnownOne
> /// bits. It also tries to handle simplifications that can be done based on
> /// DemandedMask, but without modifying the Instruction.
> Value *SimplifyMultipleUseDemandedBits(Instruction *I,
> const APInt &DemandedMask,
> - APInt &KnownZero, APInt &KnownOne,
> + KnownBits &Known,
> unsigned Depth, Instruction *CxtI);
> /// Helper routine of SimplifyDemandedUseBits. It tries to simplify demanded
> /// bit for "r1 = shr x, c1; r2 = shl r1, c2" instruction sequence.
> Value *simplifyShrShlDemandedBits(
> Instruction *Shr, const APInt &ShrOp1, Instruction *Shl,
> - const APInt &ShlOp1, const APInt &DemandedMask, APInt &KnownZero,
> - APInt &KnownOne);
> + const APInt &ShlOp1, const APInt &DemandedMask, KnownBits &Known);
>
> /// \brief Tries to simplify operands to an integer instruction based on its
> /// demanded bits.
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp Wed Apr 26 11:39:58 2017
> @@ -17,6 +17,7 @@
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/IR/MDBuilder.h"
> #include "llvm/IR/PatternMatch.h"
> +#include "llvm/Support/KnownBits.h"
> using namespace llvm;
> using namespace PatternMatch;
>
> @@ -1476,11 +1477,11 @@ Instruction *InstCombiner::visitSelectIn
> // The motivation for this call into value tracking is to take advantage of
> // the assumption cache, so make sure that is populated.
> if (!CondVal->getType()->isVectorTy() && !AC.assumptions().empty()) {
> - APInt KnownOne(1, 0), KnownZero(1, 0);
> - computeKnownBits(CondVal, KnownZero, KnownOne, 0, &SI);
> - if (KnownOne == 1)
> + KnownBits Known(1);
> + computeKnownBits(CondVal, Known, 0, &SI);
> + if (Known.One == 1)
> return replaceInstUsesWith(SI, TrueVal);
> - if (KnownZero == 1)
> + if (Known.Zero == 1)
> return replaceInstUsesWith(SI, FalseVal);
> }
>
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp Wed Apr 26 11:39:58 2017
> @@ -16,6 +16,7 @@
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/IR/IntrinsicInst.h"
> #include "llvm/IR/PatternMatch.h"
> +#include "llvm/Support/KnownBits.h"
>
> using namespace llvm;
> using namespace llvm::PatternMatch;
> @@ -52,10 +53,10 @@ static bool ShrinkDemandedConstant(Instr
> /// the instruction has any properties that allow us to simplify its operands.
> bool InstCombiner::SimplifyDemandedInstructionBits(Instruction &Inst) {
> unsigned BitWidth = Inst.getType()->getScalarSizeInBits();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> + KnownBits Known(BitWidth);
> APInt DemandedMask(APInt::getAllOnesValue(BitWidth));
>
> - Value *V = SimplifyDemandedUseBits(&Inst, DemandedMask, KnownZero, KnownOne,
> + Value *V = SimplifyDemandedUseBits(&Inst, DemandedMask, Known,
> 0, &Inst);
> if (!V) return false;
> if (V == &Inst) return true;
> @@ -68,11 +69,11 @@ bool InstCombiner::SimplifyDemandedInstr
> /// change and false otherwise.
> bool InstCombiner::SimplifyDemandedBits(Instruction *I, unsigned OpNo,
> const APInt &DemandedMask,
> - APInt &KnownZero, APInt &KnownOne,
> + KnownBits &Known,
> unsigned Depth) {
> Use &U = I->getOperandUse(OpNo);
> - Value *NewVal = SimplifyDemandedUseBits(U.get(), DemandedMask, KnownZero,
> - KnownOne, Depth, I);
> + Value *NewVal = SimplifyDemandedUseBits(U.get(), DemandedMask, Known,
> + Depth, I);
> if (!NewVal) return false;
> U = NewVal;
> return true;
> @@ -86,15 +87,16 @@ bool InstCombiner::SimplifyDemandedBits(
> /// with a constant or one of its operands. In such cases, this function does
> /// the replacement and returns true. In all other cases, it returns false after
> /// analyzing the expression and setting KnownOne and known to be one in the
> -/// expression. KnownZero contains all the bits that are known to be zero in the
> -/// expression. These are provided to potentially allow the caller (which might
> -/// recursively be SimplifyDemandedBits itself) to simplify the expression.
> -/// KnownOne and KnownZero always follow the invariant that:
> -/// KnownOne & KnownZero == 0.
> -/// That is, a bit can't be both 1 and 0. Note that the bits in KnownOne and
> -/// KnownZero may only be accurate for those bits set in DemandedMask. Note also
> -/// that the bitwidth of V, DemandedMask, KnownZero and KnownOne must all be the
> -/// same.
> +/// expression. Known.Zero contains all the bits that are known to be zero in
> +/// the expression. These are provided to potentially allow the caller (which
> +/// might recursively be SimplifyDemandedBits itself) to simplify the
> +/// expression.
> +/// Known.One and Known.Zero always follow the invariant that:
> +/// Known.One & Known.Zero == 0.
> +/// That is, a bit can't be both 1 and 0. Note that the bits in Known.One and
> +/// Known.Zero may only be accurate for those bits set in DemandedMask. Note
> +/// also that the bitwidth of V, DemandedMask, Known.Zero and Known.One must all
> +/// be the same.
> ///
> /// This returns null if it did not change anything and it permits no
> /// simplification. This returns V itself if it did some simplification of V's
> @@ -102,8 +104,7 @@ bool InstCombiner::SimplifyDemandedBits(
> /// some other non-null value if it found out that V is equal to another value
> /// in the context where the specified bits are demanded, but not for all users.
> Value *InstCombiner::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
> - APInt &KnownZero, APInt &KnownOne,
> - unsigned Depth,
> + KnownBits &Known, unsigned Depth,
> Instruction *CxtI) {
> assert(V != nullptr && "Null pointer of Value???");
> assert(Depth <= 6 && "Limit Search Depth");
> @@ -111,18 +112,16 @@ Value *InstCombiner::SimplifyDemandedUse
> Type *VTy = V->getType();
> assert(
> (!VTy->isIntOrIntVectorTy() || VTy->getScalarSizeInBits() == BitWidth) &&
> - KnownZero.getBitWidth() == BitWidth &&
> - KnownOne.getBitWidth() == BitWidth &&
> - "Value *V, DemandedMask, KnownZero and KnownOne "
> - "must have same BitWidth");
> + Known.getBitWidth() == BitWidth &&
> + "Value *V, DemandedMask and Known must have same BitWidth");
>
> if (isa<Constant>(V)) {
> - computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
> + computeKnownBits(V, Known, Depth, CxtI);
> return nullptr;
> }
>
> - KnownZero.clearAllBits();
> - KnownOne.clearAllBits();
> + Known.Zero.clearAllBits();
> + Known.One.clearAllBits();
> if (DemandedMask == 0) // Not demanding any bits from V.
> return UndefValue::get(VTy);
>
> @@ -131,7 +130,7 @@ Value *InstCombiner::SimplifyDemandedUse
>
> Instruction *I = dyn_cast<Instruction>(V);
> if (!I) {
> - computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
> + computeKnownBits(V, Known, Depth, CxtI);
> return nullptr; // Only analyze instructions.
> }
>
> @@ -139,11 +138,9 @@ Value *InstCombiner::SimplifyDemandedUse
> // we can't do any simplifications of the operands, because DemandedMask
> // only reflects the bits demanded by *one* of the users.
> if (Depth != 0 && !I->hasOneUse())
> - return SimplifyMultipleUseDemandedBits(I, DemandedMask, KnownZero, KnownOne,
> - Depth, CxtI);
> + return SimplifyMultipleUseDemandedBits(I, DemandedMask, Known, Depth, CxtI);
>
> - APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> + KnownBits LHSKnown(BitWidth), RHSKnown(BitWidth);
>
> // If this is the root being simplified, allow it to have multiple uses,
> // just set the DemandedMask to all bits so that we can try to simplify the
> @@ -154,22 +151,21 @@ Value *InstCombiner::SimplifyDemandedUse
>
> switch (I->getOpcode()) {
> default:
> - computeKnownBits(I, KnownZero, KnownOne, Depth, CxtI);
> + computeKnownBits(I, Known, Depth, CxtI);
> break;
> case Instruction::And: {
> // If either the LHS or the RHS are Zero, the result is zero.
> - if (SimplifyDemandedBits(I, 1, DemandedMask, RHSKnownZero, RHSKnownOne,
> - Depth + 1) ||
> - SimplifyDemandedBits(I, 0, DemandedMask & ~RHSKnownZero, LHSKnownZero,
> - LHSKnownOne, Depth + 1))
> + if (SimplifyDemandedBits(I, 1, DemandedMask, RHSKnown, Depth + 1) ||
> + SimplifyDemandedBits(I, 0, DemandedMask & ~RHSKnown.Zero, LHSKnown,
> + Depth + 1))
> return I;
> - assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
> - assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
> + assert(!(RHSKnown.Zero & RHSKnown.One) && "Bits known to be one AND zero?");
> + assert(!(LHSKnown.Zero & LHSKnown.One) && "Bits known to be one AND zero?");
>
> // Output known-0 are known to be clear if zero in either the LHS | RHS.
> - APInt IKnownZero = RHSKnownZero | LHSKnownZero;
> + APInt IKnownZero = RHSKnown.Zero | LHSKnown.Zero;
> // Output known-1 bits are only known if set in both the LHS & RHS.
> - APInt IKnownOne = RHSKnownOne & LHSKnownOne;
> + APInt IKnownOne = RHSKnown.One & LHSKnown.One;
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> @@ -178,33 +174,32 @@ Value *InstCombiner::SimplifyDemandedUse
>
> // If all of the demanded bits are known 1 on one side, return the other.
> // These bits cannot contribute to the result of the 'and'.
> - if (DemandedMask.isSubsetOf(LHSKnownZero | RHSKnownOne))
> + if (DemandedMask.isSubsetOf(LHSKnown.Zero | RHSKnown.One))
> return I->getOperand(0);
> - if (DemandedMask.isSubsetOf(RHSKnownZero | LHSKnownOne))
> + if (DemandedMask.isSubsetOf(RHSKnown.Zero | LHSKnown.One))
> return I->getOperand(1);
>
> // If the RHS is a constant, see if we can simplify it.
> - if (ShrinkDemandedConstant(I, 1, DemandedMask & ~LHSKnownZero))
> + if (ShrinkDemandedConstant(I, 1, DemandedMask & ~LHSKnown.Zero))
> return I;
>
> - KnownZero = std::move(IKnownZero);
> - KnownOne = std::move(IKnownOne);
> + Known.Zero = std::move(IKnownZero);
> + Known.One = std::move(IKnownOne);
> break;
> }
> case Instruction::Or: {
> // If either the LHS or the RHS are One, the result is One.
> - if (SimplifyDemandedBits(I, 1, DemandedMask, RHSKnownZero, RHSKnownOne,
> - Depth + 1) ||
> - SimplifyDemandedBits(I, 0, DemandedMask & ~RHSKnownOne, LHSKnownZero,
> - LHSKnownOne, Depth + 1))
> + if (SimplifyDemandedBits(I, 1, DemandedMask, RHSKnown, Depth + 1) ||
> + SimplifyDemandedBits(I, 0, DemandedMask & ~RHSKnown.One, LHSKnown,
> + Depth + 1))
> return I;
> - assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
> - assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
> + assert(!(RHSKnown.Zero & RHSKnown.One) && "Bits known to be one AND zero?");
> + assert(!(LHSKnown.Zero & LHSKnown.One) && "Bits known to be one AND zero?");
>
> // Output known-0 bits are only known if clear in both the LHS & RHS.
> - APInt IKnownZero = RHSKnownZero & LHSKnownZero;
> - // Output known-1 are known to be set if set in either the LHS | RHS.
> - APInt IKnownOne = RHSKnownOne | LHSKnownOne;
> + APInt IKnownZero = RHSKnown.Zero & LHSKnown.Zero;
> + // Output known-1 are known. to be set if s.et in either the LHS | RHS.
> + APInt IKnownOne = RHSKnown.One | LHSKnown.One;
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> @@ -213,34 +208,32 @@ Value *InstCombiner::SimplifyDemandedUse
>
> // If all of the demanded bits are known zero on one side, return the other.
> // These bits cannot contribute to the result of the 'or'.
> - if (DemandedMask.isSubsetOf(LHSKnownOne | RHSKnownZero))
> + if (DemandedMask.isSubsetOf(LHSKnown.One | RHSKnown.Zero))
> return I->getOperand(0);
> - if (DemandedMask.isSubsetOf(RHSKnownOne | LHSKnownZero))
> + if (DemandedMask.isSubsetOf(RHSKnown.One | LHSKnown.Zero))
> return I->getOperand(1);
>
> // If the RHS is a constant, see if we can simplify it.
> if (ShrinkDemandedConstant(I, 1, DemandedMask))
> return I;
>
> - KnownZero = std::move(IKnownZero);
> - KnownOne = std::move(IKnownOne);
> + Known.Zero = std::move(IKnownZero);
> + Known.One = std::move(IKnownOne);
> break;
> }
> case Instruction::Xor: {
> - if (SimplifyDemandedBits(I, 1, DemandedMask, RHSKnownZero, RHSKnownOne,
> - Depth + 1) ||
> - SimplifyDemandedBits(I, 0, DemandedMask, LHSKnownZero, LHSKnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 1, DemandedMask, RHSKnown, Depth + 1) ||
> + SimplifyDemandedBits(I, 0, DemandedMask, LHSKnown, Depth + 1))
> return I;
> - assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
> - assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
> + assert(!(RHSKnown.Zero & RHSKnown.One) && "Bits known to be one AND zero?");
> + assert(!(LHSKnown.Zero & LHSKnown.One) && "Bits known to be one AND zero?");
>
> // Output known-0 bits are known if clear or set in both the LHS & RHS.
> - APInt IKnownZero = (RHSKnownZero & LHSKnownZero) |
> - (RHSKnownOne & LHSKnownOne);
> + APInt IKnownZero = (RHSKnown.Zero & LHSKnown.Zero) |
> + (RHSKnown.One & LHSKnown.One);
> // Output known-1 are known to be set if set in only one of the LHS, RHS.
> - APInt IKnownOne = (RHSKnownZero & LHSKnownOne) |
> - (RHSKnownOne & LHSKnownZero);
> + APInt IKnownOne = (RHSKnown.Zero & LHSKnown.One) |
> + (RHSKnown.One & LHSKnown.Zero);
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> @@ -249,15 +242,15 @@ Value *InstCombiner::SimplifyDemandedUse
>
> // If all of the demanded bits are known zero on one side, return the other.
> // These bits cannot contribute to the result of the 'xor'.
> - if (DemandedMask.isSubsetOf(RHSKnownZero))
> + if (DemandedMask.isSubsetOf(RHSKnown.Zero))
> return I->getOperand(0);
> - if (DemandedMask.isSubsetOf(LHSKnownZero))
> + if (DemandedMask.isSubsetOf(LHSKnown.Zero))
> return I->getOperand(1);
>
> // If all of the demanded bits are known to be zero on one side or the
> // other, turn this into an *inclusive* or.
> // e.g. (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0
> - if (DemandedMask.isSubsetOf(RHSKnownZero | LHSKnownZero)) {
> + if (DemandedMask.isSubsetOf(RHSKnown.Zero | LHSKnown.Zero)) {
> Instruction *Or =
> BinaryOperator::CreateOr(I->getOperand(0), I->getOperand(1),
> I->getName());
> @@ -268,10 +261,10 @@ Value *InstCombiner::SimplifyDemandedUse
> // bits on that side are also known to be set on the other side, turn this
> // into an AND, as we know the bits will be cleared.
> // e.g. (X | C1) ^ C2 --> (X | C1) & ~C2 iff (C1&C2) == C2
> - if (DemandedMask.isSubsetOf(RHSKnownZero|RHSKnownOne) &&
> - RHSKnownOne.isSubsetOf(LHSKnownOne)) {
> + if (DemandedMask.isSubsetOf(RHSKnown.Zero|RHSKnown.One) &&
> + RHSKnown.One.isSubsetOf(LHSKnown.One)) {
> Constant *AndC = Constant::getIntegerValue(VTy,
> - ~RHSKnownOne & DemandedMask);
> + ~RHSKnown.One & DemandedMask);
> Instruction *And = BinaryOperator::CreateAnd(I->getOperand(0), AndC);
> return InsertNewInstWith(And, *I);
> }
> @@ -289,10 +282,10 @@ Value *InstCombiner::SimplifyDemandedUse
> if (LHSInst->getOpcode() == Instruction::And && LHSInst->hasOneUse() &&
> isa<ConstantInt>(I->getOperand(1)) &&
> isa<ConstantInt>(LHSInst->getOperand(1)) &&
> - (LHSKnownOne & RHSKnownOne & DemandedMask) != 0) {
> + (LHSKnown.One & RHSKnown.One & DemandedMask) != 0) {
> ConstantInt *AndRHS = cast<ConstantInt>(LHSInst->getOperand(1));
> ConstantInt *XorRHS = cast<ConstantInt>(I->getOperand(1));
> - APInt NewMask = ~(LHSKnownOne & RHSKnownOne & DemandedMask);
> + APInt NewMask = ~(LHSKnown.One & RHSKnown.One & DemandedMask);
>
> Constant *AndC =
> ConstantInt::get(I->getType(), NewMask & AndRHS->getValue());
> @@ -306,9 +299,9 @@ Value *InstCombiner::SimplifyDemandedUse
> }
>
> // Output known-0 bits are known if clear or set in both the LHS & RHS.
> - KnownZero = std::move(IKnownZero);
> + Known.Zero = std::move(IKnownZero);
> // Output known-1 are known to be set if set in only one of the LHS, RHS.
> - KnownOne = std::move(IKnownOne);
> + Known.One = std::move(IKnownOne);
> break;
> }
> case Instruction::Select:
> @@ -318,13 +311,11 @@ Value *InstCombiner::SimplifyDemandedUse
> if (matchSelectPattern(I, LHS, RHS).Flavor != SPF_UNKNOWN)
> return nullptr;
>
> - if (SimplifyDemandedBits(I, 2, DemandedMask, RHSKnownZero, RHSKnownOne,
> - Depth + 1) ||
> - SimplifyDemandedBits(I, 1, DemandedMask, LHSKnownZero, LHSKnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 2, DemandedMask, RHSKnown, Depth + 1) ||
> + SimplifyDemandedBits(I, 1, DemandedMask, LHSKnown, Depth + 1))
> return I;
> - assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
> - assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
> + assert(!(RHSKnown.Zero & RHSKnown.One) && "Bits known to be one AND zero?");
> + assert(!(LHSKnown.Zero & LHSKnown.One) && "Bits known to be one AND zero?");
>
> // If the operands are constants, see if we can simplify them.
> if (ShrinkDemandedConstant(I, 1, DemandedMask) ||
> @@ -332,21 +323,20 @@ Value *InstCombiner::SimplifyDemandedUse
> return I;
>
> // Only known if known in both the LHS and RHS.
> - KnownOne = RHSKnownOne & LHSKnownOne;
> - KnownZero = RHSKnownZero & LHSKnownZero;
> + Known.One = RHSKnown.One & LHSKnown.One;
> + Known.Zero = RHSKnown.Zero & LHSKnown.Zero;
> break;
> case Instruction::Trunc: {
> unsigned truncBf = I->getOperand(0)->getType()->getScalarSizeInBits();
> DemandedMask = DemandedMask.zext(truncBf);
> - KnownZero = KnownZero.zext(truncBf);
> - KnownOne = KnownOne.zext(truncBf);
> - if (SimplifyDemandedBits(I, 0, DemandedMask, KnownZero, KnownOne,
> - Depth + 1))
> + Known.Zero = Known.Zero.zext(truncBf);
> + Known.One = Known.One.zext(truncBf);
> + if (SimplifyDemandedBits(I, 0, DemandedMask, Known, Depth + 1))
> return I;
> DemandedMask = DemandedMask.trunc(BitWidth);
> - KnownZero = KnownZero.trunc(BitWidth);
> - KnownOne = KnownOne.trunc(BitWidth);
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> + Known.Zero = Known.Zero.trunc(BitWidth);
> + Known.One = Known.One.trunc(BitWidth);
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> break;
> }
> case Instruction::BitCast:
> @@ -366,27 +356,25 @@ Value *InstCombiner::SimplifyDemandedUse
> // Don't touch a vector-to-scalar bitcast.
> return nullptr;
>
> - if (SimplifyDemandedBits(I, 0, DemandedMask, KnownZero, KnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 0, DemandedMask, Known, Depth + 1))
> return I;
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> break;
> case Instruction::ZExt: {
> // Compute the bits in the result that are not present in the input.
> unsigned SrcBitWidth =I->getOperand(0)->getType()->getScalarSizeInBits();
>
> DemandedMask = DemandedMask.trunc(SrcBitWidth);
> - KnownZero = KnownZero.trunc(SrcBitWidth);
> - KnownOne = KnownOne.trunc(SrcBitWidth);
> - if (SimplifyDemandedBits(I, 0, DemandedMask, KnownZero, KnownOne,
> - Depth + 1))
> + Known.Zero = Known.Zero.trunc(SrcBitWidth);
> + Known.One = Known.One.trunc(SrcBitWidth);
> + if (SimplifyDemandedBits(I, 0, DemandedMask, Known, Depth + 1))
> return I;
> DemandedMask = DemandedMask.zext(BitWidth);
> - KnownZero = KnownZero.zext(BitWidth);
> - KnownOne = KnownOne.zext(BitWidth);
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> + Known.Zero = Known.Zero.zext(BitWidth);
> + Known.One = Known.One.zext(BitWidth);
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> // The top bits are known to be zero.
> - KnownZero.setBitsFrom(SrcBitWidth);
> + Known.Zero.setBitsFrom(SrcBitWidth);
> break;
> }
> case Instruction::SExt: {
> @@ -403,27 +391,26 @@ Value *InstCombiner::SimplifyDemandedUse
> InputDemandedBits.setBit(SrcBitWidth-1);
>
> InputDemandedBits = InputDemandedBits.trunc(SrcBitWidth);
> - KnownZero = KnownZero.trunc(SrcBitWidth);
> - KnownOne = KnownOne.trunc(SrcBitWidth);
> - if (SimplifyDemandedBits(I, 0, InputDemandedBits, KnownZero, KnownOne,
> - Depth + 1))
> + Known.Zero = Known.Zero.trunc(SrcBitWidth);
> + Known.One = Known.One.trunc(SrcBitWidth);
> + if (SimplifyDemandedBits(I, 0, InputDemandedBits, Known, Depth + 1))
> return I;
> InputDemandedBits = InputDemandedBits.zext(BitWidth);
> - KnownZero = KnownZero.zext(BitWidth);
> - KnownOne = KnownOne.zext(BitWidth);
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> + Known.Zero = Known.Zero.zext(BitWidth);
> + Known.One = Known.One.zext(BitWidth);
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
>
> // If the sign bit of the input is known set or clear, then we know the
> // top bits of the result.
>
> // If the input sign bit is known zero, or if the NewBits are not demanded
> // convert this into a zero extension.
> - if (KnownZero[SrcBitWidth-1] || (NewBits & ~DemandedMask) == NewBits) {
> + if (Known.Zero[SrcBitWidth-1] || (NewBits & ~DemandedMask) == NewBits) {
> // Convert to ZExt cast
> CastInst *NewCast = new ZExtInst(I->getOperand(0), VTy, I->getName());
> return InsertNewInstWith(NewCast, *I);
> - } else if (KnownOne[SrcBitWidth-1]) { // Input sign bit known set
> - KnownOne |= NewBits;
> + } else if (Known.One[SrcBitWidth-1]) { // Input sign bit known set
> + Known.One |= NewBits;
> }
> break;
> }
> @@ -437,11 +424,9 @@ Value *InstCombiner::SimplifyDemandedUse
> // significant bit and all those below it.
> APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth, BitWidth-NLZ));
> if (ShrinkDemandedConstant(I, 0, DemandedFromOps) ||
> - SimplifyDemandedBits(I, 0, DemandedFromOps, LHSKnownZero, LHSKnownOne,
> - Depth + 1) ||
> + SimplifyDemandedBits(I, 0, DemandedFromOps, LHSKnown, Depth + 1) ||
> ShrinkDemandedConstant(I, 1, DemandedFromOps) ||
> - SimplifyDemandedBits(I, 1, DemandedFromOps, RHSKnownZero, RHSKnownOne,
> - Depth + 1)) {
> + SimplifyDemandedBits(I, 1, DemandedFromOps, RHSKnown, 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.
> @@ -453,17 +438,17 @@ Value *InstCombiner::SimplifyDemandedUse
>
> // If we are known to be adding/subtracting zeros to every bit below
> // the highest demanded bit, we just return the other side.
> - if (DemandedFromOps.isSubsetOf(RHSKnownZero))
> + if (DemandedFromOps.isSubsetOf(RHSKnown.Zero))
> return I->getOperand(0);
> // We can't do this with the LHS for subtraction.
> if (I->getOpcode() == Instruction::Add &&
> - DemandedFromOps.isSubsetOf(LHSKnownZero))
> + DemandedFromOps.isSubsetOf(LHSKnown.Zero))
> return I->getOperand(1);
> }
>
> // Otherwise just hand the add/sub off to computeKnownBits to fill in
> // the known zeros and ones.
> - computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
> + computeKnownBits(V, Known, Depth, CxtI);
> break;
> }
> case Instruction::Shl: {
> @@ -473,7 +458,7 @@ Value *InstCombiner::SimplifyDemandedUse
> if (match(I->getOperand(0), m_Shr(m_Value(), m_APInt(ShrAmt)))) {
> Instruction *Shr = cast<Instruction>(I->getOperand(0));
> if (Value *R = simplifyShrShlDemandedBits(
> - Shr, *ShrAmt, I, *SA, DemandedMask, KnownZero, KnownOne))
> + Shr, *ShrAmt, I, *SA, DemandedMask, Known))
> return R;
> }
>
> @@ -487,15 +472,14 @@ Value *InstCombiner::SimplifyDemandedUse
> else if (IOp->hasNoUnsignedWrap())
> DemandedMaskIn.setHighBits(ShiftAmt);
>
> - if (SimplifyDemandedBits(I, 0, DemandedMaskIn, KnownZero, KnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1))
> return I;
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> - KnownZero <<= ShiftAmt;
> - KnownOne <<= ShiftAmt;
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> + Known.Zero <<= ShiftAmt;
> + Known.One <<= ShiftAmt;
> // low bits known zero.
> if (ShiftAmt)
> - KnownZero.setLowBits(ShiftAmt);
> + Known.Zero.setLowBits(ShiftAmt);
> }
> break;
> }
> @@ -512,14 +496,13 @@ Value *InstCombiner::SimplifyDemandedUse
> if (cast<LShrOperator>(I)->isExact())
> DemandedMaskIn.setLowBits(ShiftAmt);
>
> - if (SimplifyDemandedBits(I, 0, DemandedMaskIn, KnownZero, KnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1))
> return I;
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> - KnownZero.lshrInPlace(ShiftAmt);
> - KnownOne.lshrInPlace(ShiftAmt);
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> + Known.Zero.lshrInPlace(ShiftAmt);
> + Known.One.lshrInPlace(ShiftAmt);
> if (ShiftAmt)
> - KnownZero.setHighBits(ShiftAmt); // high bits known zero.
> + Known.Zero.setHighBits(ShiftAmt); // high bits known zero.
> }
> break;
> }
> @@ -556,15 +539,14 @@ Value *InstCombiner::SimplifyDemandedUse
> if (cast<AShrOperator>(I)->isExact())
> DemandedMaskIn.setLowBits(ShiftAmt);
>
> - if (SimplifyDemandedBits(I, 0, DemandedMaskIn, KnownZero, KnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1))
> return I;
>
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> // Compute the new bits that are at the top now.
> APInt HighBits(APInt::getHighBitsSet(BitWidth, ShiftAmt));
> - KnownZero.lshrInPlace(ShiftAmt);
> - KnownOne.lshrInPlace(ShiftAmt);
> + Known.Zero.lshrInPlace(ShiftAmt);
> + Known.One.lshrInPlace(ShiftAmt);
>
> // Handle the sign bits.
> APInt SignMask(APInt::getSignMask(BitWidth));
> @@ -573,14 +555,14 @@ Value *InstCombiner::SimplifyDemandedUse
>
> // If the input sign bit is known to be zero, or if none of the top bits
> // are demanded, turn this into an unsigned shift right.
> - if (BitWidth <= ShiftAmt || KnownZero[BitWidth-ShiftAmt-1] ||
> + if (BitWidth <= ShiftAmt || Known.Zero[BitWidth-ShiftAmt-1] ||
> !DemandedMask.intersects(HighBits)) {
> BinaryOperator *LShr = BinaryOperator::CreateLShr(I->getOperand(0),
> I->getOperand(1));
> LShr->setIsExact(cast<BinaryOperator>(I)->isExact());
> return InsertNewInstWith(LShr, *I);
> - } else if (KnownOne.intersects(SignMask)) { // New bits are known one.
> - KnownOne |= HighBits;
> + } else if (Known.One.intersects(SignMask)) { // New bits are known one.
> + Known.One |= HighBits;
> }
> }
> break;
> @@ -598,25 +580,24 @@ Value *InstCombiner::SimplifyDemandedUse
>
> APInt LowBits = RA - 1;
> APInt Mask2 = LowBits | APInt::getSignMask(BitWidth);
> - if (SimplifyDemandedBits(I, 0, Mask2, LHSKnownZero, LHSKnownOne,
> - Depth + 1))
> + if (SimplifyDemandedBits(I, 0, Mask2, LHSKnown, Depth + 1))
> return I;
>
> // The low bits of LHS are unchanged by the srem.
> - KnownZero = LHSKnownZero & LowBits;
> - KnownOne = LHSKnownOne & LowBits;
> + Known.Zero = LHSKnown.Zero & LowBits;
> + Known.One = LHSKnown.One & LowBits;
>
> // If LHS is non-negative or has all low bits zero, then the upper bits
> // are all zero.
> - if (LHSKnownZero.isSignBitSet() || LowBits.isSubsetOf(LHSKnownZero))
> - KnownZero |= ~LowBits;
> + if (LHSKnown.Zero.isSignBitSet() || LowBits.isSubsetOf(LHSKnown.Zero))
> + Known.Zero |= ~LowBits;
>
> // If LHS is negative and not all low bits are zero, then the upper bits
> // are all one.
> - if (LHSKnownOne.isSignBitSet() && LowBits.intersects(LHSKnownOne))
> - KnownOne |= ~LowBits;
> + if (LHSKnown.One.isSignBitSet() && LowBits.intersects(LHSKnown.One))
> + Known.One |= ~LowBits;
>
> - assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
> + assert(!(Known.Zero & Known.One) && "Bits known to be one AND zero?");
> break;
> }
> }
> @@ -624,22 +605,21 @@ Value *InstCombiner::SimplifyDemandedUse
> // The sign bit is the LHS's sign bit, except when the result of the
> // remainder is zero.
> if (DemandedMask.isSignBitSet()) {
> - computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
> - CxtI);
> + computeKnownBits(I->getOperand(0), LHSKnown, Depth + 1, CxtI);
> // If it's known zero, our sign bit is also zero.
> - if (LHSKnownZero.isSignBitSet())
> - KnownZero.setSignBit();
> + if (LHSKnown.Zero.isSignBitSet())
> + Known.Zero.setSignBit();
> }
> break;
> case Instruction::URem: {
> - APInt KnownZero2(BitWidth, 0), KnownOne2(BitWidth, 0);
> + KnownBits Known2(BitWidth);
> APInt AllOnes = APInt::getAllOnesValue(BitWidth);
> - if (SimplifyDemandedBits(I, 0, AllOnes, KnownZero2, KnownOne2, Depth + 1) ||
> - SimplifyDemandedBits(I, 1, AllOnes, KnownZero2, KnownOne2, Depth + 1))
> + if (SimplifyDemandedBits(I, 0, AllOnes, Known2, Depth + 1) ||
> + SimplifyDemandedBits(I, 1, AllOnes, Known2, Depth + 1))
> return I;
>
> - unsigned Leaders = KnownZero2.countLeadingOnes();
> - KnownZero = APInt::getHighBitsSet(BitWidth, Leaders) & DemandedMask;
> + unsigned Leaders = Known2.Zero.countLeadingOnes();
> + Known.Zero = APInt::getHighBitsSet(BitWidth, Leaders) & DemandedMask;
> break;
> }
> case Instruction::Call:
> @@ -703,56 +683,54 @@ Value *InstCombiner::SimplifyDemandedUse
> return ConstantInt::getNullValue(VTy);
>
> // We know that the upper bits are set to zero.
> - KnownZero.setBitsFrom(ArgWidth);
> + Known.Zero.setBitsFrom(ArgWidth);
> return nullptr;
> }
> case Intrinsic::x86_sse42_crc32_64_64:
> - KnownZero.setBitsFrom(32);
> + Known.Zero.setBitsFrom(32);
> return nullptr;
> }
> }
> - computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
> + computeKnownBits(V, Known, Depth, CxtI);
> break;
> }
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> - if (DemandedMask.isSubsetOf(KnownZero|KnownOne))
> - return Constant::getIntegerValue(VTy, KnownOne);
> + if (DemandedMask.isSubsetOf(Known.Zero|Known.One))
> + return Constant::getIntegerValue(VTy, Known.One);
> return nullptr;
> }
>
> -/// Helper routine of SimplifyDemandedUseBits. It computes KnownZero/KnownOne
> +/// Helper routine of SimplifyDemandedUseBits. It computes Known
> /// bits. It also tries to handle simplifications that can be done based on
> /// DemandedMask, but without modifying the Instruction.
> Value *InstCombiner::SimplifyMultipleUseDemandedBits(Instruction *I,
> const APInt &DemandedMask,
> - APInt &KnownZero,
> - APInt &KnownOne,
> + KnownBits &Known,
> unsigned Depth,
> Instruction *CxtI) {
> unsigned BitWidth = DemandedMask.getBitWidth();
> Type *ITy = I->getType();
>
> - APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
> - APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> + KnownBits LHSKnown(BitWidth);
> + KnownBits RHSKnown(BitWidth);
>
> // Despite the fact that we can't simplify this instruction in all User's
> - // context, we can at least compute the knownzero/knownone bits, and we can
> + // context, we can at least compute the known bits, and we can
> // do simplifications that apply to *just* the one user if we know that
> // this instruction has a simpler value in that context.
> switch (I->getOpcode()) {
> case Instruction::And: {
> // If either the LHS or the RHS are Zero, the result is zero.
> - computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth + 1,
> - CxtI);
> - computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
> + computeKnownBits(I->getOperand(1), RHSKnown, Depth + 1, CxtI);
> + computeKnownBits(I->getOperand(0), LHSKnown, Depth + 1,
> CxtI);
>
> // Output known-0 are known to be clear if zero in either the LHS | RHS.
> - APInt IKnownZero = RHSKnownZero | LHSKnownZero;
> + APInt IKnownZero = RHSKnown.Zero | LHSKnown.Zero;
> // Output known-1 bits are only known if set in both the LHS & RHS.
> - APInt IKnownOne = RHSKnownOne & LHSKnownOne;
> + APInt IKnownOne = RHSKnown.One & LHSKnown.One;
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> @@ -762,13 +740,13 @@ Value *InstCombiner::SimplifyMultipleUse
> // If all of the demanded bits are known 1 on one side, return the other.
> // These bits cannot contribute to the result of the 'and' in this
> // context.
> - if (DemandedMask.isSubsetOf(LHSKnownZero | RHSKnownOne))
> + if (DemandedMask.isSubsetOf(LHSKnown.Zero | RHSKnown.One))
> return I->getOperand(0);
> - if (DemandedMask.isSubsetOf(RHSKnownZero | LHSKnownOne))
> + if (DemandedMask.isSubsetOf(RHSKnown.Zero | LHSKnown.One))
> return I->getOperand(1);
>
> - KnownZero = std::move(IKnownZero);
> - KnownOne = std::move(IKnownOne);
> + Known.Zero = std::move(IKnownZero);
> + Known.One = std::move(IKnownOne);
> break;
> }
> case Instruction::Or: {
> @@ -776,15 +754,14 @@ Value *InstCombiner::SimplifyMultipleUse
> // only bits from X or Y are demanded.
>
> // If either the LHS or the RHS are One, the result is One.
> - computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth + 1,
> - CxtI);
> - computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
> + computeKnownBits(I->getOperand(1), RHSKnown, Depth + 1, CxtI);
> + computeKnownBits(I->getOperand(0), LHSKnown, Depth + 1,
> CxtI);
>
> // Output known-0 bits are only known if clear in both the LHS & RHS.
> - APInt IKnownZero = RHSKnownZero & LHSKnownZero;
> + APInt IKnownZero = RHSKnown.Zero & LHSKnown.Zero;
> // Output known-1 are known to be set if set in either the LHS | RHS.
> - APInt IKnownOne = RHSKnownOne | LHSKnownOne;
> + APInt IKnownOne = RHSKnown.One | LHSKnown.One;
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> @@ -794,30 +771,29 @@ Value *InstCombiner::SimplifyMultipleUse
> // If all of the demanded bits are known zero on one side, return the
> // other. These bits cannot contribute to the result of the 'or' in this
> // context.
> - if (DemandedMask.isSubsetOf(LHSKnownOne | RHSKnownZero))
> + if (DemandedMask.isSubsetOf(LHSKnown.One | RHSKnown.Zero))
> return I->getOperand(0);
> - if (DemandedMask.isSubsetOf(RHSKnownOne | LHSKnownZero))
> + if (DemandedMask.isSubsetOf(RHSKnown.One | LHSKnown.Zero))
> return I->getOperand(1);
>
> - KnownZero = std::move(IKnownZero);
> - KnownOne = std::move(IKnownOne);
> + Known.Zero = std::move(IKnownZero);
> + Known.One = std::move(IKnownOne);
> break;
> }
> case Instruction::Xor: {
> // We can simplify (X^Y) -> X or Y in the user's context if we know that
> // only bits from X or Y are demanded.
>
> - computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth + 1,
> - CxtI);
> - computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
> + computeKnownBits(I->getOperand(1), RHSKnown, Depth + 1, CxtI);
> + computeKnownBits(I->getOperand(0), LHSKnown, Depth + 1,
> CxtI);
>
> // Output known-0 bits are known if clear or set in both the LHS & RHS.
> - APInt IKnownZero = (RHSKnownZero & LHSKnownZero) |
> - (RHSKnownOne & LHSKnownOne);
> + APInt IKnownZero = (RHSKnown.Zero & LHSKnown.Zero) |
> + (RHSKnown.One & LHSKnown.One);
> // Output known-1 are known to be set if set in only one of the LHS, RHS.
> - APInt IKnownOne = (RHSKnownZero & LHSKnownOne) |
> - (RHSKnownOne & LHSKnownZero);
> + APInt IKnownOne = (RHSKnown.Zero & LHSKnown.One) |
> + (RHSKnown.One & LHSKnown.Zero);
>
> // If the client is only demanding bits that we know, return the known
> // constant.
> @@ -826,25 +802,25 @@ Value *InstCombiner::SimplifyMultipleUse
>
> // If all of the demanded bits are known zero on one side, return the
> // other.
> - if (DemandedMask.isSubsetOf(RHSKnownZero))
> + if (DemandedMask.isSubsetOf(RHSKnown.Zero))
> return I->getOperand(0);
> - if (DemandedMask.isSubsetOf(LHSKnownZero))
> + if (DemandedMask.isSubsetOf(LHSKnown.Zero))
> return I->getOperand(1);
>
> // Output known-0 bits are known if clear or set in both the LHS & RHS.
> - KnownZero = std::move(IKnownZero);
> + Known.Zero = std::move(IKnownZero);
> // Output known-1 are known to be set if set in only one of the LHS, RHS.
> - KnownOne = std::move(IKnownOne);
> + Known.One = std::move(IKnownOne);
> break;
> }
> default:
> - // Compute the KnownZero/KnownOne bits to simplify things downstream.
> - computeKnownBits(I, KnownZero, KnownOne, Depth, CxtI);
> + // Compute the Known bits to simplify things downstream.
> + computeKnownBits(I, Known, Depth, CxtI);
>
> // If this user is only demanding bits that we know, return the known
> // constant.
> - if (DemandedMask.isSubsetOf(KnownZero|KnownOne))
> - return Constant::getIntegerValue(ITy, KnownOne);
> + if (DemandedMask.isSubsetOf(Known.Zero|Known.One))
> + return Constant::getIntegerValue(ITy, Known.One);
>
> break;
> }
> @@ -874,7 +850,7 @@ Value *
> InstCombiner::simplifyShrShlDemandedBits(Instruction *Shr, const APInt &ShrOp1,
> Instruction *Shl, const APInt &ShlOp1,
> const APInt &DemandedMask,
> - APInt &KnownZero, APInt &KnownOne) {
> + KnownBits &Known) {
> if (!ShlOp1 || !ShrOp1)
> return nullptr; // No-op.
>
> @@ -887,9 +863,9 @@ InstCombiner::simplifyShrShlDemandedBits
> unsigned ShlAmt = ShlOp1.getZExtValue();
> unsigned ShrAmt = ShrOp1.getZExtValue();
>
> - KnownOne.clearAllBits();
> - KnownZero.setLowBits(ShlAmt - 1);
> - KnownZero &= DemandedMask;
> + Known.One.clearAllBits();
> + Known.Zero.setLowBits(ShlAmt - 1);
> + Known.Zero &= DemandedMask;
>
> APInt BitMask1(APInt::getAllOnesValue(BitWidth));
> APInt BitMask2(APInt::getAllOnesValue(BitWidth));
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp Wed Apr 26 11:39:58 2017
> @@ -60,6 +60,7 @@
> #include "llvm/IR/ValueHandle.h"
> #include "llvm/Support/CommandLine.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/raw_ostream.h"
> #include "llvm/Transforms/Scalar.h"
> #include "llvm/Transforms/Utils/Local.h"
> @@ -2180,11 +2181,10 @@ Instruction *InstCombiner::visitReturnIn
>
> // There might be assume intrinsics dominating this return that completely
> // determine the value. If so, constant fold it.
> - unsigned BitWidth = VTy->getPrimitiveSizeInBits();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(ResultOp, KnownZero, KnownOne, 0, &RI);
> - if ((KnownZero|KnownOne).isAllOnesValue())
> - RI.setOperand(0, Constant::getIntegerValue(VTy, KnownOne));
> + KnownBits Known(VTy->getPrimitiveSizeInBits());
> + computeKnownBits(ResultOp, Known, 0, &RI);
> + if ((Known.Zero|Known.One).isAllOnesValue())
> + RI.setOperand(0, Constant::getIntegerValue(VTy, Known.One));
>
> return nullptr;
> }
> @@ -2263,10 +2263,10 @@ Instruction *InstCombiner::visitSwitchIn
> }
>
> unsigned BitWidth = cast<IntegerType>(Cond->getType())->getBitWidth();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(Cond, KnownZero, KnownOne, 0, &SI);
> - unsigned LeadingKnownZeros = KnownZero.countLeadingOnes();
> - unsigned LeadingKnownOnes = KnownOne.countLeadingOnes();
> + KnownBits Known(BitWidth);
> + computeKnownBits(Cond, Known, 0, &SI);
> + unsigned LeadingKnownZeros = Known.Zero.countLeadingOnes();
> + unsigned LeadingKnownOnes = Known.One.countLeadingOnes();
>
> // Compute the number of leading bits we can ignore.
> // TODO: A better way to determine this would use ComputeNumSignBits().
> @@ -2863,11 +2863,10 @@ bool InstCombiner::run() {
> Type *Ty = I->getType();
> if (ExpensiveCombines && !I->use_empty() && Ty->isIntOrIntVectorTy()) {
> unsigned BitWidth = Ty->getScalarSizeInBits();
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(I, KnownZero, KnownOne, /*Depth*/0, I);
> - if ((KnownZero | KnownOne).isAllOnesValue()) {
> - Constant *C = ConstantInt::get(Ty, KnownOne);
> + KnownBits Known(BitWidth);
> + computeKnownBits(I, Known, /*Depth*/0, I);
> + if ((Known.Zero | Known.One).isAllOnesValue()) {
> + Constant *C = ConstantInt::get(Ty, Known.One);
> DEBUG(dbgs() << "IC: ConstFold (all bits known) to: " << *C <<
> " from: " << *I << '\n');
>
>
> Modified: llvm/trunk/lib/Transforms/Scalar/GuardWidening.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GuardWidening.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/GuardWidening.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/GuardWidening.cpp Wed Apr 26 11:39:58 2017
> @@ -51,6 +51,7 @@
> #include "llvm/IR/IntrinsicInst.h"
> #include "llvm/IR/PatternMatch.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Transforms/Scalar.h"
>
> using namespace llvm;
> @@ -537,9 +538,9 @@ bool GuardWideningImpl::parseRangeChecks
> } else if (match(Check.getBase(),
> m_Or(m_Value(OpLHS), m_ConstantInt(OpRHS)))) {
> unsigned BitWidth = OpLHS->getType()->getScalarSizeInBits();
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(OpLHS, KnownZero, KnownOne, DL);
> - if ((OpRHS->getValue() & KnownZero) == OpRHS->getValue()) {
> + KnownBits Known(BitWidth);
> + computeKnownBits(OpLHS, Known, DL);
> + if ((OpRHS->getValue() & Known.Zero) == OpRHS->getValue()) {
> Check.setBase(OpLHS);
> APInt NewOffset = Check.getOffsetValue() + OpRHS->getValue();
> Check.setOffset(ConstantInt::get(Ctx, NewOffset));
>
> Modified: llvm/trunk/lib/Transforms/Utils/BypassSlowDivision.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/BypassSlowDivision.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/BypassSlowDivision.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/BypassSlowDivision.cpp Wed Apr 26 11:39:58 2017
> @@ -22,6 +22,7 @@
> #include "llvm/IR/Function.h"
> #include "llvm/IR/IRBuilder.h"
> #include "llvm/IR/Instructions.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Transforms/Utils/Local.h"
>
> using namespace llvm;
> @@ -256,14 +257,14 @@ ValueRange FastDivInsertionTask::getValu
> unsigned HiBits = LongLen - ShortLen;
>
> const DataLayout &DL = SlowDivOrRem->getModule()->getDataLayout();
> - APInt Zeros(LongLen, 0), Ones(LongLen, 0);
> + KnownBits Known(LongLen);
>
> - computeKnownBits(V, Zeros, Ones, DL);
> + computeKnownBits(V, Known, DL);
>
> - if (Zeros.countLeadingOnes() >= HiBits)
> + if (Known.Zero.countLeadingOnes() >= HiBits)
> return VALRNG_KNOWN_SHORT;
>
> - if (Ones.countLeadingZeros() < HiBits)
> + if (Known.One.countLeadingZeros() < HiBits)
> return VALRNG_LIKELY_LONG;
>
> // Long integer divisions are often used in hashtable implementations. It's
>
> Modified: llvm/trunk/lib/Transforms/Utils/Local.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Local.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/Local.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/Local.cpp Wed Apr 26 11:39:58 2017
> @@ -45,6 +45,7 @@
> #include "llvm/IR/PatternMatch.h"
> #include "llvm/IR/ValueHandle.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include "llvm/Support/raw_ostream.h"
> using namespace llvm;
> @@ -1038,9 +1039,9 @@ unsigned llvm::getOrEnforceKnownAlignmen
> "getOrEnforceKnownAlignment expects a pointer!");
> unsigned BitWidth = DL.getPointerTypeSizeInBits(V->getType());
>
> - APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC, CxtI, DT);
> - unsigned TrailZ = KnownZero.countTrailingOnes();
> + KnownBits Known(BitWidth);
> + computeKnownBits(V, Known, DL, 0, AC, CxtI, DT);
> + unsigned TrailZ = Known.Zero.countTrailingOnes();
>
> // Avoid trouble with ridiculously large TrailZ values, such as
> // those computed from a null pointer.
>
> Modified: llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp Wed Apr 26 11:39:58 2017
> @@ -60,6 +60,7 @@
> #include "llvm/Support/CommandLine.h"
> #include "llvm/Support/Debug.h"
> #include "llvm/Support/ErrorHandling.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/MathExtras.h"
> #include "llvm/Support/raw_ostream.h"
> #include "llvm/Transforms/Utils/BasicBlockUtils.h"
> @@ -4367,8 +4368,8 @@ static bool EliminateDeadSwitchCases(Swi
> const DataLayout &DL) {
> Value *Cond = SI->getCondition();
> unsigned Bits = Cond->getType()->getIntegerBitWidth();
> - APInt KnownZero(Bits, 0), KnownOne(Bits, 0);
> - computeKnownBits(Cond, KnownZero, KnownOne, DL, 0, AC, SI);
> + KnownBits Known(Bits);
> + computeKnownBits(Cond, Known, DL, 0, AC, SI);
>
> // We can also eliminate cases by determining that their values are outside of
> // the limited range of the condition based on how many significant (non-sign)
> @@ -4380,7 +4381,7 @@ static bool EliminateDeadSwitchCases(Swi
> SmallVector<ConstantInt *, 8> DeadCases;
> for (auto &Case : SI->cases()) {
> APInt CaseVal = Case.getCaseValue()->getValue();
> - if (KnownZero.intersects(CaseVal) || !KnownOne.isSubsetOf(CaseVal) ||
> + if (Known.Zero.intersects(CaseVal) || !Known.One.isSubsetOf(CaseVal) ||
> (CaseVal.getMinSignedBits() > MaxSignificantBitsInCond)) {
> DeadCases.push_back(Case.getCaseValue());
> DEBUG(dbgs() << "SimplifyCFG: switch case " << CaseVal << " is dead.\n");
> @@ -4394,7 +4395,7 @@ static bool EliminateDeadSwitchCases(Swi
> bool HasDefault =
> !isa<UnreachableInst>(SI->getDefaultDest()->getFirstNonPHIOrDbg());
> const unsigned NumUnknownBits =
> - Bits - (KnownZero | KnownOne).countPopulation();
> + Bits - (Known.Zero | Known.One).countPopulation();
> assert(NumUnknownBits <= Bits);
> if (HasDefault && DeadCases.empty() &&
> NumUnknownBits < 64 /* avoid overflow */ &&
>
> Modified: llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/SimplifyLibCalls.cpp Wed Apr 26 11:39:58 2017
> @@ -30,6 +30,7 @@
> #include "llvm/IR/Module.h"
> #include "llvm/IR/PatternMatch.h"
> #include "llvm/Support/CommandLine.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Transforms/Utils/BuildLibCalls.h"
> #include "llvm/Transforms/Utils/Local.h"
>
> @@ -455,11 +456,9 @@ Value *LibCallSimplifier::optimizeStrLen
>
> Value *Offset = GEP->getOperand(2);
> unsigned BitWidth = Offset->getType()->getIntegerBitWidth();
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(Offset, KnownZero, KnownOne, DL, 0, nullptr, CI,
> - nullptr);
> - KnownZero.flipAllBits();
> + KnownBits Known(BitWidth);
> + computeKnownBits(Offset, Known, DL, 0, nullptr, CI, nullptr);
> + Known.Zero.flipAllBits();
> size_t ArrSize =
> cast<ArrayType>(GEP->getSourceElementType())->getNumElements();
>
> @@ -473,7 +472,7 @@ Value *LibCallSimplifier::optimizeStrLen
> // optimize if we can prove that the program has undefined behavior when
> // Offset is outside that range. That is the case when GEP->getOperand(0)
> // is a pointer to an object whose memory extent is NullTermIdx+1.
> - if ((KnownZero.isNonNegative() && KnownZero.ule(NullTermIdx)) ||
> + if ((Known.Zero.isNonNegative() && Known.Zero.ule(NullTermIdx)) ||
> (GEP->isInBounds() && isa<GlobalVariable>(GEP->getOperand(0)) &&
> NullTermIdx == ArrSize - 1))
> return B.CreateSub(ConstantInt::get(CI->getType(), NullTermIdx),
>
> Modified: llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp?rev=301432&r1=301431&r2=301432&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp (original)
> +++ llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp Wed Apr 26 11:39:58 2017
> @@ -30,6 +30,7 @@
> #include "llvm/IR/Value.h"
> #include "llvm/Support/CommandLine.h"
> #include "llvm/Support/Debug.h"
> +#include "llvm/Support/KnownBits.h"
> #include "llvm/Support/raw_ostream.h"
> #include "llvm/Transforms/Utils/Local.h"
> #include "llvm/Transforms/Vectorize.h"
> @@ -343,10 +344,9 @@ bool Vectorizer::isConsecutiveAccess(Val
> // If any bits are known to be zero other than the sign bit in OpA, we can
> // add 1 to it while guaranteeing no overflow of any sort.
> if (!Safe) {
> - APInt KnownZero(BitWidth, 0);
> - APInt KnownOne(BitWidth, 0);
> - computeKnownBits(OpA, KnownZero, KnownOne, DL, 0, nullptr, OpA, &DT);
> - if (KnownZero.countTrailingZeros() < (BitWidth - 1))
> + KnownBits Known(BitWidth);
> + computeKnownBits(OpA, Known, DL, 0, nullptr, OpA, &DT);
> + if (Known.Zero.countTrailingZeros() < (BitWidth - 1))
> Safe = true;
> }
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list