6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-25 16:29:20 +00:00
Code Issues Projects Releases Wiki Activity

whitespace

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@127340 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Andrew Trick 2011-03-09 17:23:39 +00:00
parent d7cdc3e1f9
commit 635f71880b
1 changed files with 18 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
lib/Analysis/ScalarEvolution.cpp
View File

@ -203,7 +203,7 @@ void SCEV::print(raw_ostream &OS) const {
OS << "alignof(" << *AllocTy << ")";
return;
}
const Type *CTy;
Constant *FieldNo;
if (U->isOffsetOf(CTy, FieldNo)) {
@ -212,7 +212,7 @@ void SCEV::print(raw_ostream &OS) const {
OS << ")";
return;
}
// Otherwise just print it normally.
WriteAsOperand(OS, U->getValue(), false);
return;
@ -2783,7 +2783,7 @@ const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
HasNUW = true;
if (OBO->hasNoSignedWrap())
HasNSW = true;
} else if (const GEPOperator *GEP =
} else if (const GEPOperator *GEP =
dyn_cast<GEPOperator>(BEValueV)) {
// If the increment is a GEP, then we know it won't perform a
// signed overflow, because the address space cannot be
@ -2798,7 +2798,7 @@ const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
//
// This is a highly theoretical concern though, and this is good
// enough for all cases we know of at this point. :)
//
//
HasNSW |= GEP->isInBounds();
}
@ -3349,7 +3349,7 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
SmallVector<const SCEV *, 4> MulOps;
MulOps.push_back(getSCEV(U->getOperand(1)));
for (Value *Op = U->getOperand(0);
Op->getValueID() == Instruction::Mul + Value::InstructionVal;
Op->getValueID() == Instruction::Mul + Value::InstructionVal;
Op = U->getOperand(0)) {
U = cast<Operator>(Op);
MulOps.push_back(getSCEV(U->getOperand(1)));
@ -4025,11 +4025,11 @@ ScalarEvolution::ComputeBackedgeTakenCountFromExitCond(const Loop *L,
static const SCEVAddRecExpr *
isSimpleUnwrappingAddRec(const SCEV *S, const Loop *L) {
const SCEVAddRecExpr *SA = dyn_cast<SCEVAddRecExpr>(S);
// The SCEV must be an addrec of this loop.
if (!SA || SA->getLoop() != L || !SA->isAffine())
return 0;
// The SCEV must be known to not wrap in some way to be interesting.
if (!SA->hasNoUnsignedWrap() && !SA->hasNoSignedWrap())
return 0;
@ -4064,24 +4064,24 @@ static const SCEV *getMinusSCEVForExitTest(const SCEV *LHS, const SCEV *RHS,
// See if LHS and RHS are addrec's we can handle.
const SCEVAddRecExpr *LHSA = isSimpleUnwrappingAddRec(LHS, L);
const SCEVAddRecExpr *RHSA = isSimpleUnwrappingAddRec(RHS, L);
// If neither addrec is interesting, just return a minus.
if (RHSA == 0 && LHSA == 0)
return SE.getMinusSCEV(LHS, RHS);
// If only one of LHS and RHS are an AddRec of this loop, make sure it is LHS.
if (RHSA && LHSA == 0) {
// Safe because a-b === b-a for comparisons against zero.
std::swap(LHS, RHS);
std::swap(LHSA, RHSA);
}
// Handle the case when only one is advancing in a non-overflowing way.
if (RHSA == 0) {
// If RHS is loop varying, then we can't predict when LHS will cross it.
if (!SE.isLoopInvariant(RHS, L))
return SE.getMinusSCEV(LHS, RHS);
// If LHS has a positive stride, then we compute RHS-LHS, because the loop
// is counting up until it crosses RHS (which must be larger than LHS). If
// it is negative, we compute LHS-RHS because we're counting down to RHS.
@ -4092,19 +4092,19 @@ static const SCEV *getMinusSCEVForExitTest(const SCEV *LHS, const SCEV *RHS,
return SE.getMinusSCEV(RHS, LHS, true /*HasNUW*/);
}
// If both LHS and RHS are interesting, we have something like:
// a+i*4 != b+i*8.
const ConstantInt *LHSStride =
cast<SCEVConstant>(LHSA->getOperand(1))->getValue();
const ConstantInt *RHSStride =
cast<SCEVConstant>(RHSA->getOperand(1))->getValue();
// If the strides are equal, then this is just a (complex) loop invariant
// comparison of a and b.
if (LHSStride == RHSStride)
return SE.getMinusSCEV(LHSA->getStart(), RHSA->getStart());
// If the signs of the strides differ, then the negative stride is counting
// down to the positive stride.
if (LHSStride->getValue().isNegative() != RHSStride->getValue().isNegative()){
@ -4117,7 +4117,7 @@ static const SCEV *getMinusSCEVForExitTest(const SCEV *LHS, const SCEV *RHS,
if (RHSStride->getValue().slt(LHSStride->getValue()))
std::swap(LHS, RHS);
}
return SE.getMinusSCEV(LHS, RHS, true /*HasNUW*/);
}
@ -4903,7 +4903,7 @@ ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
R2->getValue()))) {
if (CB->getZExtValue() == false)
std::swap(R1, R2); // R1 is the minimum root now.
// We can only use this value if the chrec ends up with an exact zero
// value at this index. When solving for "X*X != 5", for example, we
// should not accept a root of 2.
@ -4942,7 +4942,7 @@ ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
if (AddRec->hasNoUnsignedWrap())
// FIXME: We really want an "isexact" bit for udiv.
return getUDivExpr(Start, getNegativeSCEV(Step));
// For now we handle only constant steps.
const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step);
if (StepC == 0)
@ -4951,7 +4951,7 @@ ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
// First, handle unitary steps.
if (StepC->getValue()->equalsInt(1)) // 1*N = -Start (mod 2^BW), so:
return getNegativeSCEV(Start); // N = -Start (as unsigned)
if (StepC->getValue()->isAllOnesValue()) // -1*N = -Start (mod 2^BW), so:
return Start; // N = Start (as unsigned)