[cfe-commits] [PATCH] Simplify isPowerOfTwo signature
Rafael EspĂndola
rafael.espindola at gmail.com
Mon Dec 10 20:21:40 PST 2012
lgtm
On 10 December 2012 22:12, Saleem Abdulrasool <compnerd at compnerd.org> wrote:
> Hi chandlerc, baldrick,
>
> The TargetData is not used for the isPowerOfTwo determination. It has never
> been used in the first place. It simply was passed to the function and to the
> recursive invocations. Simply drop the parameter and update the callers for the
> new signature.
>
>
> http://llvm-reviews.chandlerc.com/D201
>
> Files:
> include/llvm/Analysis/ValueTracking.h
> lib/Analysis/InstructionSimplify.cpp
> lib/Analysis/ValueTracking.cpp
> lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
>
> Index: include/llvm/Analysis/ValueTracking.h
> ===================================================================
> --- include/llvm/Analysis/ValueTracking.h
> +++ include/llvm/Analysis/ValueTracking.h
> @@ -50,8 +50,7 @@
> /// be a power of two when defined. Supports values with integer or pointer
> /// type and vectors of integers. If 'OrZero' is set then returns true if the
> /// given value is either a power of two or zero.
> - bool isPowerOfTwo(Value *V, const DataLayout *TD = 0, bool OrZero = false,
> - unsigned Depth = 0);
> + bool isPowerOfTwo(Value *V, bool OrZero = false, unsigned Depth = 0);
>
> /// isKnownNonZero - Return true if the given value is known to be non-zero
> /// when defined. For vectors return true if every element is known to be
> Index: lib/Analysis/InstructionSimplify.cpp
> ===================================================================
> --- lib/Analysis/InstructionSimplify.cpp
> +++ lib/Analysis/InstructionSimplify.cpp
> @@ -1399,9 +1399,9 @@
> // A & (-A) = A if A is a power of two or zero.
> if (match(Op0, m_Neg(m_Specific(Op1))) ||
> match(Op1, m_Neg(m_Specific(Op0)))) {
> - if (isPowerOfTwo(Op0, Q.TD, /*OrZero*/true))
> + if (isPowerOfTwo(Op0, /*OrZero*/true))
> return Op0;
> - if (isPowerOfTwo(Op1, Q.TD, /*OrZero*/true))
> + if (isPowerOfTwo(Op1, /*OrZero*/true))
> return Op1;
> }
>
> Index: lib/Analysis/ValueTracking.cpp
> ===================================================================
> --- lib/Analysis/ValueTracking.cpp
> +++ lib/Analysis/ValueTracking.cpp
> @@ -803,8 +803,7 @@
> /// bit set when defined. For vectors return true if every element is known to
> /// be a power of two when defined. Supports values with integer or pointer
> /// types and vectors of integers.
> -bool llvm::isPowerOfTwo(Value *V, const DataLayout *TD, bool OrZero,
> - unsigned Depth) {
> +bool llvm::isPowerOfTwo(Value *V, bool OrZero, unsigned Depth) {
> if (Constant *C = dyn_cast<Constant>(V)) {
> if (C->isNullValue())
> return OrZero;
> @@ -831,19 +830,19 @@
> // A shift of a power of two is a power of two or zero.
> if (OrZero && (match(V, m_Shl(m_Value(X), m_Value())) ||
> match(V, m_Shr(m_Value(X), m_Value()))))
> - return isPowerOfTwo(X, TD, /*OrZero*/true, Depth);
> + return isPowerOfTwo(X, /*OrZero*/true, Depth);
>
> if (ZExtInst *ZI = dyn_cast<ZExtInst>(V))
> - return isPowerOfTwo(ZI->getOperand(0), TD, OrZero, Depth);
> + return isPowerOfTwo(ZI->getOperand(0), OrZero, Depth);
>
> if (SelectInst *SI = dyn_cast<SelectInst>(V))
> - return isPowerOfTwo(SI->getTrueValue(), TD, OrZero, Depth) &&
> - isPowerOfTwo(SI->getFalseValue(), TD, OrZero, Depth);
> + return isPowerOfTwo(SI->getTrueValue(), OrZero, Depth) &&
> + isPowerOfTwo(SI->getFalseValue(), OrZero, Depth);
>
> if (OrZero && match(V, m_And(m_Value(X), m_Value(Y)))) {
> // A power of two and'd with anything is a power of two or zero.
> - if (isPowerOfTwo(X, TD, /*OrZero*/true, Depth) ||
> - isPowerOfTwo(Y, TD, /*OrZero*/true, Depth))
> + if (isPowerOfTwo(X, /*OrZero*/true, Depth) ||
> + isPowerOfTwo(Y, /*OrZero*/true, Depth))
> return true;
> // X & (-X) is always a power of two or zero.
> if (match(X, m_Neg(m_Specific(Y))) || match(Y, m_Neg(m_Specific(X))))
> @@ -856,7 +855,7 @@
> // copying a sign bit (sdiv int_min, 2).
> if (match(V, m_Exact(m_LShr(m_Value(), m_Value()))) ||
> match(V, m_Exact(m_UDiv(m_Value(), m_Value())))) {
> - return isPowerOfTwo(cast<Operator>(V)->getOperand(0), TD, OrZero, Depth);
> + return isPowerOfTwo(cast<Operator>(V)->getOperand(0), OrZero, Depth);
> }
>
> return false;
> @@ -1028,9 +1027,9 @@
> }
>
> // The sum of a non-negative number and a power of two is not zero.
> - if (XKnownNonNegative && isPowerOfTwo(Y, TD, /*OrZero*/false, Depth))
> + if (XKnownNonNegative && isPowerOfTwo(Y, /*OrZero*/false, Depth))
> return true;
> - if (YKnownNonNegative && isPowerOfTwo(X, TD, /*OrZero*/false, Depth))
> + if (YKnownNonNegative && isPowerOfTwo(X, /*OrZero*/false, Depth))
> return true;
> }
> // X * Y.
> Index: lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
> ===================================================================
> --- lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
> +++ lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
> @@ -37,7 +37,7 @@
> if (match(V, m_LShr(m_OneUse(m_Shl(m_Value(PowerOf2), m_Value(A))),
> m_Value(B))) &&
> // The "1" can be any value known to be a power of 2.
> - isPowerOfTwo(PowerOf2, IC.getDataLayout())) {
> + isPowerOfTwo(PowerOf2)) {
> A = IC.Builder->CreateSub(A, B);
> return IC.Builder->CreateShl(PowerOf2, A);
> }
> @@ -45,8 +45,7 @@
> // (PowerOfTwo >>u B) --> isExact since shifting out the result would make it
> // inexact. Similarly for <<.
> if (BinaryOperator *I = dyn_cast<BinaryOperator>(V))
> - if (I->isLogicalShift() &&
> - isPowerOfTwo(I->getOperand(0), IC.getDataLayout())) {
> + if (I->isLogicalShift() && isPowerOfTwo(I->getOperand(0))) {
> // We know that this is an exact/nuw shift and that the input is a
> // non-zero context as well.
> if (Value *V2 = simplifyValueKnownNonZero(I->getOperand(0), IC)) {
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>
More information about the cfe-commits
mailing list