6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-12 13:38:21 +00:00
Code Issues Projects Releases Wiki Activity

The maximum power of 2 dividing a power of 2 is itself. This occurs

Browse Source 
in 403.gcc and was spotted by my super-optimizer.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@143054 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands
2011-10-26 20:55:21 +00:00
parent 1832f4d94e
commit dd3149d579
4 changed files with 52 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
lib/Analysis/ValueTracking.cpp
View File

@ -745,10 +745,15 @@ void llvm::ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
/// 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 TargetData *TD, unsigned Depth) {
if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
return CI->getValue().isPowerOf2();
// TODO: Handle vector constants.
bool llvm::isPowerOfTwo(Value *V, const TargetData *TD, bool OrZero,
unsigned Depth) {
if (Constant *C = dyn_cast<Constant>(V)) {
if (C->isNullValue())
return OrZero;
if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
return CI->getValue().isPowerOf2();
// TODO: Handle vector constants.
}
// 1 << X is clearly a power of two if the one is not shifted off the end. If
// it is shifted off the end then the result is undefined.
@ -765,11 +770,23 @@ bool llvm::isPowerOfTwo(Value *V, const TargetData *TD, unsigned Depth) {
return false;
if (ZExtInst *ZI = dyn_cast<ZExtInst>(V))
return isPowerOfTwo(ZI->getOperand(0), TD, Depth);
return isPowerOfTwo(ZI->getOperand(0), TD, OrZero, Depth);
if (SelectInst *SI = dyn_cast<SelectInst>(V))
return isPowerOfTwo(SI->getTrueValue(), TD, Depth) &&
isPowerOfTwo(SI->getFalseValue(), TD, Depth);
return isPowerOfTwo(SI->getTrueValue(), TD, OrZero, Depth) &&
isPowerOfTwo(SI->getFalseValue(), TD, OrZero, Depth);
Value *X = 0, *Y = 0;
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))
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))))
return true;
return false;
}
// An exact divide or right shift can only shift off zero bits, so the result
// is a power of two only if the first operand is a power of two and not
@ -778,7 +795,7 @@ bool llvm::isPowerOfTwo(Value *V, const TargetData *TD, unsigned Depth) {
match(V, m_UDiv(m_Value(), m_Value()))) {
PossiblyExactOperator *PEO = cast<PossiblyExactOperator>(V);
if (PEO->isExact())
return isPowerOfTwo(PEO->getOperand(0), TD, Depth);
return isPowerOfTwo(PEO->getOperand(0), TD, OrZero, Depth);
}
return false;
@ -879,9 +896,9 @@ bool llvm::isKnownNonZero(Value *V, const TargetData *TD, unsigned Depth) {
}
// The sum of a non-negative number and a power of two is not zero.
if (XKnownNonNegative && isPowerOfTwo(Y, TD, Depth))
if (XKnownNonNegative && isPowerOfTwo(Y, TD, /*OrZero*/false, Depth))
return true;
if (YKnownNonNegative && isPowerOfTwo(X, TD, Depth))
if (YKnownNonNegative && isPowerOfTwo(X, TD, /*OrZero*/false, Depth))
return true;
}
// X * Y.