2004-04-03 04:23:17 +08:00
|
|
|
//===- ScalarEvolution.cpp - Scalar Evolution Analysis ----------*- C++ -*-===//
|
2005-04-22 05:13:18 +08:00
|
|
|
//
|
2004-04-03 04:23:17 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 05:13:18 +08:00
|
|
|
//
|
2004-04-03 04:23:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains the implementation of the scalar evolution analysis
|
|
|
|
// engine, which is used primarily to analyze expressions involving induction
|
|
|
|
// variables in loops.
|
|
|
|
//
|
|
|
|
// There are several aspects to this library. First is the representation of
|
|
|
|
// scalar expressions, which are represented as subclasses of the SCEV class.
|
|
|
|
// These classes are used to represent certain types of subexpressions that we
|
2009-07-26 00:18:07 +08:00
|
|
|
// can handle. We only create one SCEV of a particular shape, so
|
|
|
|
// pointer-comparisons for equality are legal.
|
2004-04-03 04:23:17 +08:00
|
|
|
//
|
|
|
|
// One important aspect of the SCEV objects is that they are never cyclic, even
|
|
|
|
// if there is a cycle in the dataflow for an expression (ie, a PHI node). If
|
|
|
|
// the PHI node is one of the idioms that we can represent (e.g., a polynomial
|
|
|
|
// recurrence) then we represent it directly as a recurrence node, otherwise we
|
|
|
|
// represent it as a SCEVUnknown node.
|
|
|
|
//
|
|
|
|
// In addition to being able to represent expressions of various types, we also
|
|
|
|
// have folders that are used to build the *canonical* representation for a
|
|
|
|
// particular expression. These folders are capable of using a variety of
|
|
|
|
// rewrite rules to simplify the expressions.
|
2005-04-22 05:13:18 +08:00
|
|
|
//
|
2004-04-03 04:23:17 +08:00
|
|
|
// Once the folders are defined, we can implement the more interesting
|
|
|
|
// higher-level code, such as the code that recognizes PHI nodes of various
|
|
|
|
// types, computes the execution count of a loop, etc.
|
|
|
|
//
|
|
|
|
// TODO: We should use these routines and value representations to implement
|
|
|
|
// dependence analysis!
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// There are several good references for the techniques used in this analysis.
|
|
|
|
//
|
|
|
|
// Chains of recurrences -- a method to expedite the evaluation
|
|
|
|
// of closed-form functions
|
|
|
|
// Olaf Bachmann, Paul S. Wang, Eugene V. Zima
|
|
|
|
//
|
|
|
|
// On computational properties of chains of recurrences
|
|
|
|
// Eugene V. Zima
|
|
|
|
//
|
|
|
|
// Symbolic Evaluation of Chains of Recurrences for Loop Optimization
|
|
|
|
// Robert A. van Engelen
|
|
|
|
//
|
|
|
|
// Efficient Symbolic Analysis for Optimizing Compilers
|
|
|
|
// Robert A. van Engelen
|
|
|
|
//
|
|
|
|
// Using the chains of recurrences algebra for data dependence testing and
|
|
|
|
// induction variable substitution
|
|
|
|
// MS Thesis, Johnie Birch
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-12-20 06:30:33 +08:00
|
|
|
#define DEBUG_TYPE "scalar-evolution"
|
2004-04-15 23:07:24 +08:00
|
|
|
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
#include "llvm/GlobalVariable.h"
|
2009-08-26 01:49:57 +08:00
|
|
|
#include "llvm/GlobalAlias.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Instructions.h"
|
2009-07-07 06:37:39 +08:00
|
|
|
#include "llvm/LLVMContext.h"
|
2009-07-18 04:47:02 +08:00
|
|
|
#include "llvm/Operator.h"
|
2005-10-27 23:54:34 +08:00
|
|
|
#include "llvm/Analysis/ConstantFolding.h"
|
2009-02-17 08:13:06 +08:00
|
|
|
#include "llvm/Analysis/Dominators.h"
|
2010-11-17 12:18:45 +08:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2009-06-17 03:52:01 +08:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
2009-04-16 11:18:22 +08:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2006-06-29 07:17:24 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Support/ConstantRange.h"
|
2009-12-24 06:58:38 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-12 04:10:48 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-04-16 11:18:22 +08:00
|
|
|
#include "llvm/Support/GetElementPtrTypeIterator.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Support/InstIterator.h"
|
2006-12-19 09:16:02 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2009-04-21 08:47:46 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2004-09-02 06:55:40 +08:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2009-04-16 11:18:22 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2009-07-09 03:23:34 +08:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2004-09-04 02:19:51 +08:00
|
|
|
#include <algorithm>
|
2004-04-03 04:23:17 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2006-12-20 06:30:33 +08:00
|
|
|
STATISTIC(NumArrayLenItCounts,
|
|
|
|
"Number of trip counts computed with array length");
|
|
|
|
STATISTIC(NumTripCountsComputed,
|
|
|
|
"Number of loops with predictable loop counts");
|
|
|
|
STATISTIC(NumTripCountsNotComputed,
|
|
|
|
"Number of loops without predictable loop counts");
|
|
|
|
STATISTIC(NumBruteForceTripCountsComputed,
|
|
|
|
"Number of loops with trip counts computed by force");
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
static cl::opt<unsigned>
|
2006-12-20 06:30:33 +08:00
|
|
|
MaxBruteForceIterations("scalar-evolution-max-iterations", cl::ReallyHidden,
|
|
|
|
cl::desc("Maximum number of iterations SCEV will "
|
2009-06-24 12:48:43 +08:00
|
|
|
"symbolically execute a constant "
|
|
|
|
"derived loop"),
|
2006-12-20 06:30:33 +08:00
|
|
|
cl::init(100));
|
|
|
|
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(ScalarEvolution, "scalar-evolution",
|
|
|
|
"Scalar Evolution Analysis", false, true)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(LoopInfo)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTree)
|
|
|
|
INITIALIZE_PASS_END(ScalarEvolution, "scalar-evolution",
|
2010-10-08 06:25:06 +08:00
|
|
|
"Scalar Evolution Analysis", false, true)
|
2007-05-03 09:11:54 +08:00
|
|
|
char ScalarEvolution::ID = 0;
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SCEV class definitions
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implementation of the SCEV class.
|
|
|
|
//
|
2009-07-01 04:13:32 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
void SCEV::dump() const {
|
2009-12-24 06:18:14 +08:00
|
|
|
print(dbgs());
|
|
|
|
dbgs() << '\n';
|
2009-04-21 08:47:46 +08:00
|
|
|
}
|
|
|
|
|
2010-11-18 06:27:42 +08:00
|
|
|
void SCEV::print(raw_ostream &OS) const {
|
|
|
|
switch (getSCEVType()) {
|
|
|
|
case scConstant:
|
|
|
|
WriteAsOperand(OS, cast<SCEVConstant>(this)->getValue(), false);
|
|
|
|
return;
|
|
|
|
case scTruncate: {
|
|
|
|
const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(this);
|
|
|
|
const SCEV *Op = Trunc->getOperand();
|
|
|
|
OS << "(trunc " << *Op->getType() << " " << *Op << " to "
|
|
|
|
<< *Trunc->getType() << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scZeroExtend: {
|
|
|
|
const SCEVZeroExtendExpr *ZExt = cast<SCEVZeroExtendExpr>(this);
|
|
|
|
const SCEV *Op = ZExt->getOperand();
|
|
|
|
OS << "(zext " << *Op->getType() << " " << *Op << " to "
|
|
|
|
<< *ZExt->getType() << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scSignExtend: {
|
|
|
|
const SCEVSignExtendExpr *SExt = cast<SCEVSignExtendExpr>(this);
|
|
|
|
const SCEV *Op = SExt->getOperand();
|
|
|
|
OS << "(sext " << *Op->getType() << " " << *Op << " to "
|
|
|
|
<< *SExt->getType() << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scAddRecExpr: {
|
|
|
|
const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(this);
|
|
|
|
OS << "{" << *AR->getOperand(0);
|
|
|
|
for (unsigned i = 1, e = AR->getNumOperands(); i != e; ++i)
|
|
|
|
OS << ",+," << *AR->getOperand(i);
|
|
|
|
OS << "}<";
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AR->getNoWrapFlags(FlagNUW))
|
2011-01-09 10:16:18 +08:00
|
|
|
OS << "nuw><";
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AR->getNoWrapFlags(FlagNSW))
|
2011-01-09 10:16:18 +08:00
|
|
|
OS << "nsw><";
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AR->getNoWrapFlags(FlagNW) &&
|
|
|
|
!AR->getNoWrapFlags((NoWrapFlags)(FlagNUW | FlagNSW)))
|
|
|
|
OS << "nw><";
|
2010-11-18 06:27:42 +08:00
|
|
|
WriteAsOperand(OS, AR->getLoop()->getHeader(), /*PrintType=*/false);
|
|
|
|
OS << ">";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scAddExpr:
|
|
|
|
case scMulExpr:
|
|
|
|
case scUMaxExpr:
|
|
|
|
case scSMaxExpr: {
|
|
|
|
const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(this);
|
2010-11-19 19:37:26 +08:00
|
|
|
const char *OpStr = 0;
|
2010-11-18 06:27:42 +08:00
|
|
|
switch (NAry->getSCEVType()) {
|
|
|
|
case scAddExpr: OpStr = " + "; break;
|
|
|
|
case scMulExpr: OpStr = " * "; break;
|
|
|
|
case scUMaxExpr: OpStr = " umax "; break;
|
|
|
|
case scSMaxExpr: OpStr = " smax "; break;
|
|
|
|
}
|
|
|
|
OS << "(";
|
|
|
|
for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
OS << **I;
|
|
|
|
if (llvm::next(I) != E)
|
|
|
|
OS << OpStr;
|
|
|
|
}
|
|
|
|
OS << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scUDivExpr: {
|
|
|
|
const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(this);
|
|
|
|
OS << "(" << *UDiv->getLHS() << " /u " << *UDiv->getRHS() << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scUnknown: {
|
|
|
|
const SCEVUnknown *U = cast<SCEVUnknown>(this);
|
|
|
|
const Type *AllocTy;
|
|
|
|
if (U->isSizeOf(AllocTy)) {
|
|
|
|
OS << "sizeof(" << *AllocTy << ")";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (U->isAlignOf(AllocTy)) {
|
|
|
|
OS << "alignof(" << *AllocTy << ")";
|
|
|
|
return;
|
|
|
|
}
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2010-11-18 06:27:42 +08:00
|
|
|
const Type *CTy;
|
|
|
|
Constant *FieldNo;
|
|
|
|
if (U->isOffsetOf(CTy, FieldNo)) {
|
|
|
|
OS << "offsetof(" << *CTy << ", ";
|
|
|
|
WriteAsOperand(OS, FieldNo, false);
|
|
|
|
OS << ")";
|
|
|
|
return;
|
|
|
|
}
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2010-11-18 06:27:42 +08:00
|
|
|
// Otherwise just print it normally.
|
|
|
|
WriteAsOperand(OS, U->getValue(), false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case scCouldNotCompute:
|
|
|
|
OS << "***COULDNOTCOMPUTE***";
|
|
|
|
return;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
|
|
|
}
|
|
|
|
|
|
|
|
const Type *SCEV::getType() const {
|
|
|
|
switch (getSCEVType()) {
|
|
|
|
case scConstant:
|
|
|
|
return cast<SCEVConstant>(this)->getType();
|
|
|
|
case scTruncate:
|
|
|
|
case scZeroExtend:
|
|
|
|
case scSignExtend:
|
|
|
|
return cast<SCEVCastExpr>(this)->getType();
|
|
|
|
case scAddRecExpr:
|
|
|
|
case scMulExpr:
|
|
|
|
case scUMaxExpr:
|
|
|
|
case scSMaxExpr:
|
|
|
|
return cast<SCEVNAryExpr>(this)->getType();
|
|
|
|
case scAddExpr:
|
|
|
|
return cast<SCEVAddExpr>(this)->getType();
|
|
|
|
case scUDivExpr:
|
|
|
|
return cast<SCEVUDivExpr>(this)->getType();
|
|
|
|
case scUnknown:
|
|
|
|
return cast<SCEVUnknown>(this)->getType();
|
|
|
|
case scCouldNotCompute:
|
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
|
|
|
return 0;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-19 00:23:07 +08:00
|
|
|
bool SCEV::isZero() const {
|
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
|
|
|
|
return SC->getValue()->isZero();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-05-18 23:22:39 +08:00
|
|
|
bool SCEV::isOne() const {
|
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
|
|
|
|
return SC->getValue()->isOne();
|
|
|
|
return false;
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-06-24 08:30:26 +08:00
|
|
|
bool SCEV::isAllOnesValue() const {
|
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(this))
|
|
|
|
return SC->getValue()->isAllOnesValue();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-06-23 05:57:23 +08:00
|
|
|
SCEVCouldNotCompute::SCEVCouldNotCompute() :
|
2010-06-19 03:54:20 +08:00
|
|
|
SCEV(FoldingSetNodeIDRef(), scCouldNotCompute) {}
|
2009-06-28 05:21:31 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
bool SCEVCouldNotCompute::classof(const SCEV *S) {
|
|
|
|
return S->getSCEVType() == scCouldNotCompute;
|
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getConstant(ConstantInt *V) {
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scConstant);
|
|
|
|
ID.AddPointer(V);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
2010-06-19 03:54:20 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getConstant(const APInt& Val) {
|
2009-07-25 07:12:02 +08:00
|
|
|
return getConstant(ConstantInt::get(getContext(), Val));
|
2007-07-09 23:25:17 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
2009-06-16 06:12:54 +08:00
|
|
|
ScalarEvolution::getConstant(const Type *Ty, uint64_t V, bool isSigned) {
|
2010-04-22 00:04:04 +08:00
|
|
|
const IntegerType *ITy = cast<IntegerType>(getEffectiveSCEVType(Ty));
|
|
|
|
return getConstant(ConstantInt::get(ITy, V, isSigned));
|
2009-06-16 06:12:54 +08:00
|
|
|
}
|
|
|
|
|
2010-06-19 03:54:20 +08:00
|
|
|
SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeIDRef ID,
|
2009-07-14 04:50:19 +08:00
|
|
|
unsigned SCEVTy, const SCEV *op, const Type *ty)
|
2010-06-19 03:54:20 +08:00
|
|
|
: SCEV(ID, SCEVTy), Op(op), Ty(ty) {}
|
2009-06-28 05:21:31 +08:00
|
|
|
|
2010-06-19 03:54:20 +08:00
|
|
|
SCEVTruncateExpr::SCEVTruncateExpr(const FoldingSetNodeIDRef ID,
|
2009-07-14 04:50:19 +08:00
|
|
|
const SCEV *op, const Type *ty)
|
2010-06-19 03:54:20 +08:00
|
|
|
: SCEVCastExpr(ID, scTruncate, op, ty) {
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2004-04-15 23:07:24 +08:00
|
|
|
"Cannot truncate non-integer value!");
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2010-06-19 03:54:20 +08:00
|
|
|
SCEVZeroExtendExpr::SCEVZeroExtendExpr(const FoldingSetNodeIDRef ID,
|
2009-07-14 04:50:19 +08:00
|
|
|
const SCEV *op, const Type *ty)
|
2010-06-19 03:54:20 +08:00
|
|
|
: SCEVCastExpr(ID, scZeroExtend, op, ty) {
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2004-04-15 23:07:24 +08:00
|
|
|
"Cannot zero extend non-integer value!");
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2010-06-19 03:54:20 +08:00
|
|
|
SCEVSignExtendExpr::SCEVSignExtendExpr(const FoldingSetNodeIDRef ID,
|
2009-07-14 04:50:19 +08:00
|
|
|
const SCEV *op, const Type *ty)
|
2010-06-19 03:54:20 +08:00
|
|
|
: SCEVCastExpr(ID, scSignExtend, op, ty) {
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((Op->getType()->isIntegerTy() || Op->getType()->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2007-06-15 22:38:12 +08:00
|
|
|
"Cannot sign extend non-integer value!");
|
|
|
|
}
|
|
|
|
|
2010-08-03 07:49:30 +08:00
|
|
|
void SCEVUnknown::deleted() {
|
2010-11-17 10:44:44 +08:00
|
|
|
// Clear this SCEVUnknown from various maps.
|
2010-11-18 07:28:48 +08:00
|
|
|
SE->forgetMemoizedResults(this);
|
2010-08-03 07:49:30 +08:00
|
|
|
|
|
|
|
// Remove this SCEVUnknown from the uniquing map.
|
|
|
|
SE->UniqueSCEVs.RemoveNode(this);
|
|
|
|
|
|
|
|
// Release the value.
|
|
|
|
setValPtr(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SCEVUnknown::allUsesReplacedWith(Value *New) {
|
2010-11-17 10:44:44 +08:00
|
|
|
// Clear this SCEVUnknown from various maps.
|
2010-11-18 07:28:48 +08:00
|
|
|
SE->forgetMemoizedResults(this);
|
2010-08-03 07:49:30 +08:00
|
|
|
|
|
|
|
// Remove this SCEVUnknown from the uniquing map.
|
|
|
|
SE->UniqueSCEVs.RemoveNode(this);
|
|
|
|
|
|
|
|
// Update this SCEVUnknown to point to the new value. This is needed
|
|
|
|
// because there may still be outstanding SCEVs which still point to
|
|
|
|
// this SCEVUnknown.
|
|
|
|
setValPtr(New);
|
|
|
|
}
|
|
|
|
|
2010-01-28 10:15:55 +08:00
|
|
|
bool SCEVUnknown::isSizeOf(const Type *&AllocTy) const {
|
2010-08-03 07:49:30 +08:00
|
|
|
if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
|
2010-01-28 10:15:55 +08:00
|
|
|
if (VCE->getOpcode() == Instruction::PtrToInt)
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
|
2010-02-02 09:38:49 +08:00
|
|
|
if (CE->getOpcode() == Instruction::GetElementPtr &&
|
|
|
|
CE->getOperand(0)->isNullValue() &&
|
|
|
|
CE->getNumOperands() == 2)
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(1)))
|
|
|
|
if (CI->isOne()) {
|
|
|
|
AllocTy = cast<PointerType>(CE->getOperand(0)->getType())
|
|
|
|
->getElementType();
|
|
|
|
return true;
|
|
|
|
}
|
2010-01-28 10:15:55 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SCEVUnknown::isAlignOf(const Type *&AllocTy) const {
|
2010-08-03 07:49:30 +08:00
|
|
|
if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
|
2010-01-28 10:15:55 +08:00
|
|
|
if (VCE->getOpcode() == Instruction::PtrToInt)
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
|
2010-02-02 09:38:49 +08:00
|
|
|
if (CE->getOpcode() == Instruction::GetElementPtr &&
|
|
|
|
CE->getOperand(0)->isNullValue()) {
|
|
|
|
const Type *Ty =
|
|
|
|
cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
|
|
|
|
if (const StructType *STy = dyn_cast<StructType>(Ty))
|
|
|
|
if (!STy->isPacked() &&
|
|
|
|
CE->getNumOperands() == 3 &&
|
|
|
|
CE->getOperand(1)->isNullValue()) {
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(2)))
|
|
|
|
if (CI->isOne() &&
|
|
|
|
STy->getNumElements() == 2 &&
|
2010-02-16 00:12:20 +08:00
|
|
|
STy->getElementType(0)->isIntegerTy(1)) {
|
2010-02-02 09:38:49 +08:00
|
|
|
AllocTy = STy->getElementType(1);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-01-28 10:15:55 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-02-02 02:27:38 +08:00
|
|
|
bool SCEVUnknown::isOffsetOf(const Type *&CTy, Constant *&FieldNo) const {
|
2010-08-03 07:49:30 +08:00
|
|
|
if (ConstantExpr *VCE = dyn_cast<ConstantExpr>(getValue()))
|
2010-02-02 02:27:38 +08:00
|
|
|
if (VCE->getOpcode() == Instruction::PtrToInt)
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(VCE->getOperand(0)))
|
|
|
|
if (CE->getOpcode() == Instruction::GetElementPtr &&
|
|
|
|
CE->getNumOperands() == 3 &&
|
|
|
|
CE->getOperand(0)->isNullValue() &&
|
|
|
|
CE->getOperand(1)->isNullValue()) {
|
|
|
|
const Type *Ty =
|
|
|
|
cast<PointerType>(CE->getOperand(0)->getType())->getElementType();
|
|
|
|
// Ignore vector types here so that ScalarEvolutionExpander doesn't
|
|
|
|
// emit getelementptrs that index into vectors.
|
2010-02-16 19:11:14 +08:00
|
|
|
if (Ty->isStructTy() || Ty->isArrayTy()) {
|
2010-02-02 02:27:38 +08:00
|
|
|
CTy = Ty;
|
|
|
|
FieldNo = CE->getOperand(2);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2004-06-20 14:23:15 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SCEV Utilities
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
/// SCEVComplexityCompare - Return true if the complexity of the LHS is less
|
|
|
|
/// than the complexity of the RHS. This comparator is used to canonicalize
|
|
|
|
/// expressions.
|
2009-10-25 14:33:48 +08:00
|
|
|
class SCEVComplexityCompare {
|
2010-08-14 04:17:27 +08:00
|
|
|
const LoopInfo *const LI;
|
2009-05-07 22:39:04 +08:00
|
|
|
public:
|
2010-07-24 05:18:55 +08:00
|
|
|
explicit SCEVComplexityCompare(const LoopInfo *li) : LI(li) {}
|
2009-05-07 22:39:04 +08:00
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
// Return true or false if LHS is less than, or at least RHS, respectively.
|
2008-04-15 02:23:56 +08:00
|
|
|
bool operator()(const SCEV *LHS, const SCEV *RHS) const {
|
2010-08-27 23:26:01 +08:00
|
|
|
return compare(LHS, RHS) < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return negative, zero, or positive, if LHS is less than, equal to, or
|
|
|
|
// greater than RHS, respectively. A three-way result allows recursive
|
|
|
|
// comparisons to be more efficient.
|
|
|
|
int compare(const SCEV *LHS, const SCEV *RHS) const {
|
2009-09-01 05:15:23 +08:00
|
|
|
// Fast-path: SCEVs are uniqued so we can do a quick equality check.
|
|
|
|
if (LHS == RHS)
|
2010-08-27 23:26:01 +08:00
|
|
|
return 0;
|
2009-09-01 05:15:23 +08:00
|
|
|
|
2009-05-07 22:39:04 +08:00
|
|
|
// Primarily, sort the SCEVs by their getSCEVType().
|
2010-07-24 05:20:52 +08:00
|
|
|
unsigned LType = LHS->getSCEVType(), RType = RHS->getSCEVType();
|
|
|
|
if (LType != RType)
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LType - (int)RType;
|
2010-06-19 03:54:20 +08:00
|
|
|
|
|
|
|
// Aside from the getSCEVType() ordering, the particular ordering
|
|
|
|
// isn't very important except that it's beneficial to be consistent,
|
|
|
|
// so that (a + b) and (b + a) don't end up as different expressions.
|
2010-08-27 23:26:01 +08:00
|
|
|
switch (LType) {
|
|
|
|
case scUnknown: {
|
|
|
|
const SCEVUnknown *LU = cast<SCEVUnknown>(LHS);
|
2010-06-19 03:54:20 +08:00
|
|
|
const SCEVUnknown *RU = cast<SCEVUnknown>(RHS);
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Sort SCEVUnknown values with some loose heuristics. TODO: This is
|
|
|
|
// not as complete as it could be.
|
2010-08-14 05:24:58 +08:00
|
|
|
const Value *LV = LU->getValue(), *RV = RU->getValue();
|
2010-06-19 03:54:20 +08:00
|
|
|
|
|
|
|
// Order pointer values after integer values. This helps SCEVExpander
|
|
|
|
// form GEPs.
|
2010-08-14 05:24:58 +08:00
|
|
|
bool LIsPointer = LV->getType()->isPointerTy(),
|
|
|
|
RIsPointer = RV->getType()->isPointerTy();
|
2010-07-24 05:20:52 +08:00
|
|
|
if (LIsPointer != RIsPointer)
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LIsPointer - (int)RIsPointer;
|
2010-06-19 03:54:20 +08:00
|
|
|
|
|
|
|
// Compare getValueID values.
|
2010-08-14 05:24:58 +08:00
|
|
|
unsigned LID = LV->getValueID(),
|
|
|
|
RID = RV->getValueID();
|
2010-07-24 05:20:52 +08:00
|
|
|
if (LID != RID)
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LID - (int)RID;
|
2010-06-19 03:54:20 +08:00
|
|
|
|
|
|
|
// Sort arguments by their position.
|
2010-08-14 05:24:58 +08:00
|
|
|
if (const Argument *LA = dyn_cast<Argument>(LV)) {
|
|
|
|
const Argument *RA = cast<Argument>(RV);
|
2010-08-27 23:26:01 +08:00
|
|
|
unsigned LArgNo = LA->getArgNo(), RArgNo = RA->getArgNo();
|
|
|
|
return (int)LArgNo - (int)RArgNo;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
// For instructions, compare their loop depth, and their operand
|
|
|
|
// count. This is pretty loose.
|
2010-08-14 05:24:58 +08:00
|
|
|
if (const Instruction *LInst = dyn_cast<Instruction>(LV)) {
|
|
|
|
const Instruction *RInst = cast<Instruction>(RV);
|
2010-06-19 03:54:20 +08:00
|
|
|
|
|
|
|
// Compare loop depths.
|
2010-08-14 05:24:58 +08:00
|
|
|
const BasicBlock *LParent = LInst->getParent(),
|
|
|
|
*RParent = RInst->getParent();
|
|
|
|
if (LParent != RParent) {
|
|
|
|
unsigned LDepth = LI->getLoopDepth(LParent),
|
|
|
|
RDepth = LI->getLoopDepth(RParent);
|
|
|
|
if (LDepth != RDepth)
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LDepth - (int)RDepth;
|
2010-08-14 05:24:58 +08:00
|
|
|
}
|
2010-06-19 03:54:20 +08:00
|
|
|
|
|
|
|
// Compare the number of operands.
|
2010-08-14 05:24:58 +08:00
|
|
|
unsigned LNumOps = LInst->getNumOperands(),
|
|
|
|
RNumOps = RInst->getNumOperands();
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LNumOps - (int)RNumOps;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
return 0;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
case scConstant: {
|
|
|
|
const SCEVConstant *LC = cast<SCEVConstant>(LHS);
|
2010-06-19 03:54:20 +08:00
|
|
|
const SCEVConstant *RC = cast<SCEVConstant>(RHS);
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Compare constant values.
|
2010-08-17 00:25:35 +08:00
|
|
|
const APInt &LA = LC->getValue()->getValue();
|
|
|
|
const APInt &RA = RC->getValue()->getValue();
|
|
|
|
unsigned LBitWidth = LA.getBitWidth(), RBitWidth = RA.getBitWidth();
|
2010-07-24 05:20:52 +08:00
|
|
|
if (LBitWidth != RBitWidth)
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LBitWidth - (int)RBitWidth;
|
|
|
|
return LA.ult(RA) ? -1 : 1;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
case scAddRecExpr: {
|
|
|
|
const SCEVAddRecExpr *LA = cast<SCEVAddRecExpr>(LHS);
|
2010-06-19 03:54:20 +08:00
|
|
|
const SCEVAddRecExpr *RA = cast<SCEVAddRecExpr>(RHS);
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Compare addrec loop depths.
|
2010-08-14 05:24:58 +08:00
|
|
|
const Loop *LLoop = LA->getLoop(), *RLoop = RA->getLoop();
|
|
|
|
if (LLoop != RLoop) {
|
|
|
|
unsigned LDepth = LLoop->getLoopDepth(),
|
|
|
|
RDepth = RLoop->getLoopDepth();
|
|
|
|
if (LDepth != RDepth)
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LDepth - (int)RDepth;
|
2010-08-14 05:24:58 +08:00
|
|
|
}
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Addrec complexity grows with operand count.
|
|
|
|
unsigned LNumOps = LA->getNumOperands(), RNumOps = RA->getNumOperands();
|
|
|
|
if (LNumOps != RNumOps)
|
|
|
|
return (int)LNumOps - (int)RNumOps;
|
|
|
|
|
|
|
|
// Lexicographically compare.
|
|
|
|
for (unsigned i = 0; i != LNumOps; ++i) {
|
|
|
|
long X = compare(LA->getOperand(i), RA->getOperand(i));
|
|
|
|
if (X != 0)
|
|
|
|
return X;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
case scAddExpr:
|
|
|
|
case scMulExpr:
|
|
|
|
case scSMaxExpr:
|
|
|
|
case scUMaxExpr: {
|
|
|
|
const SCEVNAryExpr *LC = cast<SCEVNAryExpr>(LHS);
|
2010-06-19 03:54:20 +08:00
|
|
|
const SCEVNAryExpr *RC = cast<SCEVNAryExpr>(RHS);
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Lexicographically compare n-ary expressions.
|
2010-07-24 05:20:52 +08:00
|
|
|
unsigned LNumOps = LC->getNumOperands(), RNumOps = RC->getNumOperands();
|
|
|
|
for (unsigned i = 0; i != LNumOps; ++i) {
|
|
|
|
if (i >= RNumOps)
|
2010-08-27 23:26:01 +08:00
|
|
|
return 1;
|
|
|
|
long X = compare(LC->getOperand(i), RC->getOperand(i));
|
|
|
|
if (X != 0)
|
|
|
|
return X;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
2010-08-27 23:26:01 +08:00
|
|
|
return (int)LNumOps - (int)RNumOps;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
case scUDivExpr: {
|
|
|
|
const SCEVUDivExpr *LC = cast<SCEVUDivExpr>(LHS);
|
2010-06-19 03:54:20 +08:00
|
|
|
const SCEVUDivExpr *RC = cast<SCEVUDivExpr>(RHS);
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Lexicographically compare udiv expressions.
|
|
|
|
long X = compare(LC->getLHS(), RC->getLHS());
|
|
|
|
if (X != 0)
|
|
|
|
return X;
|
|
|
|
return compare(LC->getRHS(), RC->getRHS());
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
2010-08-27 23:26:01 +08:00
|
|
|
case scTruncate:
|
|
|
|
case scZeroExtend:
|
|
|
|
case scSignExtend: {
|
|
|
|
const SCEVCastExpr *LC = cast<SCEVCastExpr>(LHS);
|
2010-06-19 03:54:20 +08:00
|
|
|
const SCEVCastExpr *RC = cast<SCEVCastExpr>(RHS);
|
2010-08-27 23:26:01 +08:00
|
|
|
|
|
|
|
// Compare cast expressions by operand.
|
|
|
|
return compare(LC->getOperand(), RC->getOperand());
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
2010-06-19 03:54:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
2010-08-27 23:26:01 +08:00
|
|
|
return 0;
|
2004-06-20 14:23:15 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// GroupByComplexity - Given a list of SCEV objects, order them by their
|
|
|
|
/// complexity, and group objects of the same complexity together by value.
|
|
|
|
/// When this routine is finished, we know that any duplicates in the vector are
|
|
|
|
/// consecutive and that complexity is monotonically increasing.
|
|
|
|
///
|
2010-03-02 01:49:51 +08:00
|
|
|
/// Note that we go take special precautions to ensure that we get deterministic
|
2004-06-20 14:23:15 +08:00
|
|
|
/// results from this routine. In other words, we don't want the results of
|
|
|
|
/// this to depend on where the addresses of various SCEV objects happened to
|
|
|
|
/// land in memory.
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
static void GroupByComplexity(SmallVectorImpl<const SCEV *> &Ops,
|
2009-05-07 22:39:04 +08:00
|
|
|
LoopInfo *LI) {
|
2004-06-20 14:23:15 +08:00
|
|
|
if (Ops.size() < 2) return; // Noop
|
|
|
|
if (Ops.size() == 2) {
|
|
|
|
// This is the common case, which also happens to be trivially simple.
|
|
|
|
// Special case it.
|
2010-08-29 23:07:13 +08:00
|
|
|
const SCEV *&LHS = Ops[0], *&RHS = Ops[1];
|
|
|
|
if (SCEVComplexityCompare(LI)(RHS, LHS))
|
|
|
|
std::swap(LHS, RHS);
|
2004-06-20 14:23:15 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-06-19 03:54:20 +08:00
|
|
|
// Do the rough sort by complexity.
|
|
|
|
std::stable_sort(Ops.begin(), Ops.end(), SCEVComplexityCompare(LI));
|
|
|
|
|
|
|
|
// Now that we are sorted by complexity, group elements of the same
|
|
|
|
// complexity. Note that this is, at worst, N^2, but the vector is likely to
|
|
|
|
// be extremely short in practice. Note that we take this approach because we
|
|
|
|
// do not want to depend on the addresses of the objects we are grouping.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e-2; ++i) {
|
|
|
|
const SCEV *S = Ops[i];
|
|
|
|
unsigned Complexity = S->getSCEVType();
|
|
|
|
|
|
|
|
// If there are any objects of the same complexity and same value as this
|
|
|
|
// one, group them.
|
|
|
|
for (unsigned j = i+1; j != e && Ops[j]->getSCEVType() == Complexity; ++j) {
|
|
|
|
if (Ops[j] == S) { // Found a duplicate.
|
|
|
|
// Move it to immediately after i'th element.
|
|
|
|
std::swap(Ops[i+1], Ops[j]);
|
|
|
|
++i; // no need to rescan it.
|
|
|
|
if (i == e-2) return; // Done!
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-06-20 14:23:15 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Simple SCEV method implementations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-08-05 07:49:06 +08:00
|
|
|
/// BinomialCoefficient - Compute BC(It, K). The result has width W.
|
2009-05-25 07:45:28 +08:00
|
|
|
/// Assume, K > 0.
|
2009-07-08 01:06:11 +08:00
|
|
|
static const SCEV *BinomialCoefficient(const SCEV *It, unsigned K,
|
2009-07-21 08:38:55 +08:00
|
|
|
ScalarEvolution &SE,
|
|
|
|
const Type* ResultTy) {
|
2008-08-05 07:49:06 +08:00
|
|
|
// Handle the simplest case efficiently.
|
|
|
|
if (K == 1)
|
|
|
|
return SE.getTruncateOrZeroExtend(It, ResultTy);
|
|
|
|
|
2008-02-11 19:03:14 +08:00
|
|
|
// We are using the following formula for BC(It, K):
|
|
|
|
//
|
|
|
|
// BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / K!
|
|
|
|
//
|
2008-08-05 07:49:06 +08:00
|
|
|
// Suppose, W is the bitwidth of the return value. We must be prepared for
|
|
|
|
// overflow. Hence, we must assure that the result of our computation is
|
|
|
|
// equal to the accurate one modulo 2^W. Unfortunately, division isn't
|
|
|
|
// safe in modular arithmetic.
|
|
|
|
//
|
|
|
|
// However, this code doesn't use exactly that formula; the formula it uses
|
2009-06-24 12:48:43 +08:00
|
|
|
// is something like the following, where T is the number of factors of 2 in
|
2008-08-05 07:49:06 +08:00
|
|
|
// K! (i.e. trailing zeros in the binary representation of K!), and ^ is
|
|
|
|
// exponentiation:
|
2008-02-11 19:03:14 +08:00
|
|
|
//
|
2008-08-05 07:49:06 +08:00
|
|
|
// BC(It, K) = (It * (It - 1) * ... * (It - K + 1)) / 2^T / (K! / 2^T)
|
2008-02-11 19:03:14 +08:00
|
|
|
//
|
2008-08-05 07:49:06 +08:00
|
|
|
// This formula is trivially equivalent to the previous formula. However,
|
|
|
|
// this formula can be implemented much more efficiently. The trick is that
|
|
|
|
// K! / 2^T is odd, and exact division by an odd number *is* safe in modular
|
|
|
|
// arithmetic. To do exact division in modular arithmetic, all we have
|
|
|
|
// to do is multiply by the inverse. Therefore, this step can be done at
|
|
|
|
// width W.
|
2009-06-24 12:48:43 +08:00
|
|
|
//
|
2008-08-05 07:49:06 +08:00
|
|
|
// The next issue is how to safely do the division by 2^T. The way this
|
|
|
|
// is done is by doing the multiplication step at a width of at least W + T
|
|
|
|
// bits. This way, the bottom W+T bits of the product are accurate. Then,
|
|
|
|
// when we perform the division by 2^T (which is equivalent to a right shift
|
|
|
|
// by T), the bottom W bits are accurate. Extra bits are okay; they'll get
|
|
|
|
// truncated out after the division by 2^T.
|
2008-02-11 19:03:14 +08:00
|
|
|
//
|
2008-08-05 07:49:06 +08:00
|
|
|
// In comparison to just directly using the first formula, this technique
|
|
|
|
// is much more efficient; using the first formula requires W * K bits,
|
|
|
|
// but this formula less than W + K bits. Also, the first formula requires
|
|
|
|
// a division step, whereas this formula only requires multiplies and shifts.
|
|
|
|
//
|
|
|
|
// It doesn't matter whether the subtraction step is done in the calculation
|
|
|
|
// width or the input iteration count's width; if the subtraction overflows,
|
|
|
|
// the result must be zero anyway. We prefer here to do it in the width of
|
|
|
|
// the induction variable because it helps a lot for certain cases; CodeGen
|
|
|
|
// isn't smart enough to ignore the overflow, which leads to much less
|
|
|
|
// efficient code if the width of the subtraction is wider than the native
|
|
|
|
// register width.
|
|
|
|
//
|
|
|
|
// (It's possible to not widen at all by pulling out factors of 2 before
|
|
|
|
// the multiplication; for example, K=2 can be calculated as
|
|
|
|
// It/2*(It+(It*INT_MIN/INT_MIN)+-1). However, it requires
|
|
|
|
// extra arithmetic, so it's not an obvious win, and it gets
|
|
|
|
// much more complicated for K > 3.)
|
|
|
|
|
|
|
|
// Protection from insane SCEVs; this bound is conservative,
|
|
|
|
// but it probably doesn't matter.
|
|
|
|
if (K > 1000)
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute();
|
2008-08-05 07:49:06 +08:00
|
|
|
|
2009-04-21 09:07:12 +08:00
|
|
|
unsigned W = SE.getTypeSizeInBits(ResultTy);
|
2008-08-05 07:49:06 +08:00
|
|
|
|
|
|
|
// Calculate K! / 2^T and T; we divide out the factors of two before
|
|
|
|
// multiplying for calculating K! / 2^T to avoid overflow.
|
|
|
|
// Other overflow doesn't matter because we only care about the bottom
|
|
|
|
// W bits of the result.
|
|
|
|
APInt OddFactorial(W, 1);
|
|
|
|
unsigned T = 1;
|
|
|
|
for (unsigned i = 3; i <= K; ++i) {
|
|
|
|
APInt Mult(W, i);
|
|
|
|
unsigned TwoFactors = Mult.countTrailingZeros();
|
|
|
|
T += TwoFactors;
|
|
|
|
Mult = Mult.lshr(TwoFactors);
|
|
|
|
OddFactorial *= Mult;
|
|
|
|
}
|
2008-02-11 19:03:14 +08:00
|
|
|
|
2008-08-05 07:49:06 +08:00
|
|
|
// We need at least W + T bits for the multiplication step
|
2009-01-25 16:16:27 +08:00
|
|
|
unsigned CalculationBits = W + T;
|
2008-08-05 07:49:06 +08:00
|
|
|
|
2010-03-02 01:49:51 +08:00
|
|
|
// Calculate 2^T, at width T+W.
|
2008-08-05 07:49:06 +08:00
|
|
|
APInt DivFactor = APInt(CalculationBits, 1).shl(T);
|
|
|
|
|
|
|
|
// Calculate the multiplicative inverse of K! / 2^T;
|
|
|
|
// this multiplication factor will perform the exact division by
|
|
|
|
// K! / 2^T.
|
|
|
|
APInt Mod = APInt::getSignedMinValue(W+1);
|
|
|
|
APInt MultiplyFactor = OddFactorial.zext(W+1);
|
|
|
|
MultiplyFactor = MultiplyFactor.multiplicativeInverse(Mod);
|
|
|
|
MultiplyFactor = MultiplyFactor.trunc(W);
|
|
|
|
|
|
|
|
// Calculate the product, at width T+W
|
2009-08-14 05:58:54 +08:00
|
|
|
const IntegerType *CalculationTy = IntegerType::get(SE.getContext(),
|
|
|
|
CalculationBits);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Dividend = SE.getTruncateOrZeroExtend(It, CalculationTy);
|
2008-08-05 07:49:06 +08:00
|
|
|
for (unsigned i = 1; i != K; ++i) {
|
2010-05-04 06:09:21 +08:00
|
|
|
const SCEV *S = SE.getMinusSCEV(It, SE.getConstant(It->getType(), i));
|
2008-08-05 07:49:06 +08:00
|
|
|
Dividend = SE.getMulExpr(Dividend,
|
|
|
|
SE.getTruncateOrZeroExtend(S, CalculationTy));
|
|
|
|
}
|
2008-02-11 19:03:14 +08:00
|
|
|
|
2008-08-05 07:49:06 +08:00
|
|
|
// Divide by 2^T
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *DivResult = SE.getUDivExpr(Dividend, SE.getConstant(DivFactor));
|
2008-02-11 19:03:14 +08:00
|
|
|
|
2008-08-05 07:49:06 +08:00
|
|
|
// Truncate the result, and divide by K! / 2^T.
|
2008-06-13 12:38:55 +08:00
|
|
|
|
2008-08-05 07:49:06 +08:00
|
|
|
return SE.getMulExpr(SE.getConstant(MultiplyFactor),
|
|
|
|
SE.getTruncateOrZeroExtend(DivResult, ResultTy));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// evaluateAtIteration - Return the value of this chain of recurrences at
|
|
|
|
/// the specified iteration number. We can evaluate this recurrence by
|
|
|
|
/// multiplying each element in the chain by the binomial coefficient
|
|
|
|
/// corresponding to it. In other words, we can evaluate {A,+,B,+,C,+,D} as:
|
|
|
|
///
|
2008-02-11 19:03:14 +08:00
|
|
|
/// A*BC(It, 0) + B*BC(It, 1) + C*BC(It, 2) + D*BC(It, 3)
|
2004-04-03 04:23:17 +08:00
|
|
|
///
|
2008-02-11 19:03:14 +08:00
|
|
|
/// where BC(It, k) stands for binomial coefficient.
|
2004-04-03 04:23:17 +08:00
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SCEVAddRecExpr::evaluateAtIteration(const SCEV *It,
|
2009-07-21 08:38:55 +08:00
|
|
|
ScalarEvolution &SE) const {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Result = getStart();
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 1, e = getNumOperands(); i != e; ++i) {
|
2008-02-11 19:03:14 +08:00
|
|
|
// The computation is correct in the face of overflow provided that the
|
|
|
|
// multiplication is performed _after_ the evaluation of the binomial
|
|
|
|
// coefficient.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Coeff = BinomialCoefficient(It, i, SE, getType());
|
2008-10-13 11:58:02 +08:00
|
|
|
if (isa<SCEVCouldNotCompute>(Coeff))
|
|
|
|
return Coeff;
|
|
|
|
|
|
|
|
Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SCEV Expression folder implementations
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op,
|
2009-07-14 06:05:32 +08:00
|
|
|
const Type *Ty) {
|
2009-04-21 09:07:12 +08:00
|
|
|
assert(getTypeSizeInBits(Op->getType()) > getTypeSizeInBits(Ty) &&
|
2009-04-21 08:55:22 +08:00
|
|
|
"This is not a truncating conversion!");
|
2009-05-02 00:44:18 +08:00
|
|
|
assert(isSCEVable(Ty) &&
|
|
|
|
"This is not a conversion to a SCEVable type!");
|
|
|
|
Ty = getEffectiveSCEVType(Ty);
|
2009-04-21 08:55:22 +08:00
|
|
|
|
2009-07-14 04:50:19 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scTruncate);
|
|
|
|
ID.AddPointer(Op);
|
|
|
|
ID.AddPointer(Ty);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
|
|
|
|
2009-07-01 04:13:32 +08:00
|
|
|
// Fold if the operand is constant.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
|
2009-06-24 08:38:39 +08:00
|
|
|
return getConstant(
|
2010-06-25 00:33:38 +08:00
|
|
|
cast<ConstantInt>(ConstantExpr::getTrunc(SC->getValue(),
|
|
|
|
getEffectiveSCEVType(Ty))));
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-04-23 00:20:48 +08:00
|
|
|
// trunc(trunc(x)) --> trunc(x)
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op))
|
2009-04-23 00:20:48 +08:00
|
|
|
return getTruncateExpr(ST->getOperand(), Ty);
|
|
|
|
|
2009-04-23 13:15:08 +08:00
|
|
|
// trunc(sext(x)) --> sext(x) if widening or trunc(x) if narrowing
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
|
2009-04-23 13:15:08 +08:00
|
|
|
return getTruncateOrSignExtend(SS->getOperand(), Ty);
|
|
|
|
|
|
|
|
// trunc(zext(x)) --> zext(x) if widening or trunc(x) if narrowing
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
|
2009-04-23 13:15:08 +08:00
|
|
|
return getTruncateOrZeroExtend(SZ->getOperand(), Ty);
|
|
|
|
|
2011-01-20 00:59:46 +08:00
|
|
|
// trunc(x1+x2+...+xN) --> trunc(x1)+trunc(x2)+...+trunc(xN) if we can
|
|
|
|
// eliminate all the truncates.
|
|
|
|
if (const SCEVAddExpr *SA = dyn_cast<SCEVAddExpr>(Op)) {
|
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
|
|
|
bool hasTrunc = false;
|
|
|
|
for (unsigned i = 0, e = SA->getNumOperands(); i != e && !hasTrunc; ++i) {
|
|
|
|
const SCEV *S = getTruncateExpr(SA->getOperand(i), Ty);
|
|
|
|
hasTrunc = isa<SCEVTruncateExpr>(S);
|
|
|
|
Operands.push_back(S);
|
|
|
|
}
|
|
|
|
if (!hasTrunc)
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddExpr(Operands);
|
2011-01-26 16:40:22 +08:00
|
|
|
UniqueSCEVs.FindNodeOrInsertPos(ID, IP); // Mutates IP, returns NULL.
|
2011-01-20 00:59:46 +08:00
|
|
|
}
|
|
|
|
|
2011-01-20 02:56:00 +08:00
|
|
|
// trunc(x1*x2*...*xN) --> trunc(x1)*trunc(x2)*...*trunc(xN) if we can
|
|
|
|
// eliminate all the truncates.
|
|
|
|
if (const SCEVMulExpr *SM = dyn_cast<SCEVMulExpr>(Op)) {
|
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
|
|
|
bool hasTrunc = false;
|
|
|
|
for (unsigned i = 0, e = SM->getNumOperands(); i != e && !hasTrunc; ++i) {
|
|
|
|
const SCEV *S = getTruncateExpr(SM->getOperand(i), Ty);
|
|
|
|
hasTrunc = isa<SCEVTruncateExpr>(S);
|
|
|
|
Operands.push_back(S);
|
|
|
|
}
|
|
|
|
if (!hasTrunc)
|
2011-03-15 00:50:06 +08:00
|
|
|
return getMulExpr(Operands);
|
2011-01-26 16:40:22 +08:00
|
|
|
UniqueSCEVs.FindNodeOrInsertPos(ID, IP); // Mutates IP, returns NULL.
|
2011-01-20 02:56:00 +08:00
|
|
|
}
|
|
|
|
|
2009-06-19 00:24:47 +08:00
|
|
|
// If the input value is a chrec scev, truncate the chrec's operands.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(Op)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
|
2009-05-09 05:03:19 +08:00
|
|
|
Operands.push_back(getTruncateExpr(AddRec->getOperand(i), Ty));
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddRecExpr(Operands, AddRec->getLoop(), SCEV::FlagAnyWrap);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2010-07-16 04:02:11 +08:00
|
|
|
// As a special case, fold trunc(undef) to undef. We don't want to
|
|
|
|
// know too much about SCEVUnknowns, but this special case is handy
|
|
|
|
// and harmless.
|
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(Op))
|
|
|
|
if (isa<UndefValue>(U->getValue()))
|
|
|
|
return getSCEV(UndefValue::get(Ty));
|
|
|
|
|
2010-06-26 02:47:08 +08:00
|
|
|
// The cast wasn't folded; create an explicit cast node. We can reuse
|
|
|
|
// the existing insert position since if we get here, we won't have
|
|
|
|
// made any changes which would invalidate it.
|
2010-03-19 02:49:47 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVTruncateExpr(ID.Intern(SCEVAllocator),
|
|
|
|
Op, Ty);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getZeroExtendExpr(const SCEV *Op,
|
2009-07-14 06:05:32 +08:00
|
|
|
const Type *Ty) {
|
2009-04-21 09:07:12 +08:00
|
|
|
assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
|
2009-04-17 03:25:55 +08:00
|
|
|
"This is not an extending conversion!");
|
2009-05-02 00:44:18 +08:00
|
|
|
assert(isSCEVable(Ty) &&
|
|
|
|
"This is not a conversion to a SCEVable type!");
|
|
|
|
Ty = getEffectiveSCEVType(Ty);
|
2009-04-17 03:25:55 +08:00
|
|
|
|
2009-07-01 04:13:32 +08:00
|
|
|
// Fold if the operand is constant.
|
2010-06-25 00:47:03 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
|
|
|
|
return getConstant(
|
|
|
|
cast<ConstantInt>(ConstantExpr::getZExt(SC->getValue(),
|
|
|
|
getEffectiveSCEVType(Ty))));
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-04-23 00:20:48 +08:00
|
|
|
// zext(zext(x)) --> zext(x)
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
|
2009-04-23 00:20:48 +08:00
|
|
|
return getZeroExtendExpr(SZ->getOperand(), Ty);
|
|
|
|
|
2009-07-14 04:55:53 +08:00
|
|
|
// Before doing any expensive analysis, check to see if we've already
|
|
|
|
// computed a SCEV for this Op and Ty.
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scZeroExtend);
|
|
|
|
ID.AddPointer(Op);
|
|
|
|
ID.AddPointer(Ty);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
|
|
|
|
2011-01-23 14:20:19 +08:00
|
|
|
// zext(trunc(x)) --> zext(x) or x or trunc(x)
|
|
|
|
if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op)) {
|
|
|
|
// It's possible the bits taken off by the truncate were all zero bits. If
|
|
|
|
// so, we should be able to simplify this further.
|
|
|
|
const SCEV *X = ST->getOperand();
|
|
|
|
ConstantRange CR = getUnsignedRange(X);
|
|
|
|
unsigned TruncBits = getTypeSizeInBits(ST->getType());
|
|
|
|
unsigned NewBits = getTypeSizeInBits(Ty);
|
|
|
|
if (CR.truncate(TruncBits).zeroExtend(NewBits).contains(
|
2011-01-24 04:06:05 +08:00
|
|
|
CR.zextOrTrunc(NewBits)))
|
|
|
|
return getTruncateOrZeroExtend(X, Ty);
|
2011-01-23 14:20:19 +08:00
|
|
|
}
|
|
|
|
|
2009-04-28 04:16:15 +08:00
|
|
|
// If the input value is a chrec scev, and we can prove that the value
|
2004-04-03 04:23:17 +08:00
|
|
|
// did not overflow the old, smaller, value, we can zero extend all of the
|
2009-04-28 04:16:15 +08:00
|
|
|
// operands (often constants). This allows analysis of something like
|
2004-04-03 04:23:17 +08:00
|
|
|
// this: for (unsigned char X = 0; X < 100; ++X) { int Y = X; }
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
|
2009-04-28 04:16:15 +08:00
|
|
|
if (AR->isAffine()) {
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *Start = AR->getStart();
|
|
|
|
const SCEV *Step = AR->getStepRecurrence(*this);
|
|
|
|
unsigned BitWidth = getTypeSizeInBits(AR->getType());
|
|
|
|
const Loop *L = AR->getLoop();
|
|
|
|
|
2009-07-25 09:22:26 +08:00
|
|
|
// If we have special knowledge that this addrec won't overflow,
|
|
|
|
// we don't need to do any further analysis.
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AR->getNoWrapFlags(SCEV::FlagNUW))
|
2009-07-25 09:22:26 +08:00
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getZeroExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
2009-07-25 09:22:26 +08:00
|
|
|
|
2009-04-28 04:16:15 +08:00
|
|
|
// Check whether the backedge-taken count is SCEVCouldNotCompute.
|
|
|
|
// Note that this serves two purposes: It filters out loops that are
|
|
|
|
// simply not analyzable, and it covers the case where this code is
|
|
|
|
// being called from within backedge-taken count analysis, such that
|
|
|
|
// attempting to ask for the backedge-taken count would likely result
|
|
|
|
// in infinite recursion. In the later case, the analysis code will
|
|
|
|
// cope with a conservative value, and it will take care to purge
|
|
|
|
// that value once it has finished.
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
|
2009-05-01 04:47:05 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
|
2009-04-29 09:54:20 +08:00
|
|
|
// Manually compute the final value for AR, checking for
|
2009-04-30 06:28:28 +08:00
|
|
|
// overflow.
|
2009-04-28 04:16:15 +08:00
|
|
|
|
|
|
|
// Check whether the backedge-taken count can be losslessly casted to
|
|
|
|
// the addrec's type. The count is always unsigned.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *CastedMaxBECount =
|
2009-05-01 04:47:05 +08:00
|
|
|
getTruncateOrZeroExtend(MaxBECount, Start->getType());
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *RecastedMaxBECount =
|
2009-05-18 23:58:39 +08:00
|
|
|
getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
|
|
|
|
if (MaxBECount == RecastedMaxBECount) {
|
2009-08-14 05:58:54 +08:00
|
|
|
const Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
|
2009-05-01 04:47:05 +08:00
|
|
|
// Check whether Start+Step*MaxBECount has no unsigned overflow.
|
2010-02-25 03:31:06 +08:00
|
|
|
const SCEV *ZMul = getMulExpr(CastedMaxBECount, Step);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Add = getAddExpr(Start, ZMul);
|
|
|
|
const SCEV *OperandExtendedAdd =
|
2009-05-18 23:58:39 +08:00
|
|
|
getAddExpr(getZeroExtendExpr(Start, WideTy),
|
|
|
|
getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
|
|
|
|
getZeroExtendExpr(Step, WideTy)));
|
2011-03-15 08:37:00 +08:00
|
|
|
if (getZeroExtendExpr(Add, WideTy) == OperandExtendedAdd) {
|
|
|
|
// Cache knowledge of AR NUW, which is propagated to this AddRec.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
|
2009-04-30 06:28:28 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getZeroExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-04-28 04:16:15 +08:00
|
|
|
// Similar to above, only this time treat the step value as signed.
|
|
|
|
// This covers loops that count down.
|
2010-02-25 03:31:06 +08:00
|
|
|
const SCEV *SMul = getMulExpr(CastedMaxBECount, Step);
|
2009-04-30 06:28:28 +08:00
|
|
|
Add = getAddExpr(Start, SMul);
|
2009-05-18 23:58:39 +08:00
|
|
|
OperandExtendedAdd =
|
|
|
|
getAddExpr(getZeroExtendExpr(Start, WideTy),
|
|
|
|
getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
|
|
|
|
getSignExtendExpr(Step, WideTy)));
|
2011-03-15 08:37:00 +08:00
|
|
|
if (getZeroExtendExpr(Add, WideTy) == OperandExtendedAdd) {
|
|
|
|
// Cache knowledge of AR NW, which is propagated to this AddRec.
|
|
|
|
// Negative step causes unsigned wrap, but it still can't self-wrap.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
|
2009-04-30 06:28:28 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If the backedge is guarded by a comparison with the pre-inc value
|
|
|
|
// the addrec is safe. Also, if the entry is guarded by a comparison
|
|
|
|
// with the start value and the backedge is guarded by a comparison
|
|
|
|
// with the post-inc value, the addrec is safe.
|
|
|
|
if (isKnownPositive(Step)) {
|
|
|
|
const SCEV *N = getConstant(APInt::getMinValue(BitWidth) -
|
|
|
|
getUnsignedRange(Step).getUnsignedMax());
|
|
|
|
if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT, AR, N) ||
|
2010-04-12 03:27:13 +08:00
|
|
|
(isLoopEntryGuardedByCond(L, ICmpInst::ICMP_ULT, Start, N) &&
|
2009-07-14 05:35:55 +08:00
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT,
|
2011-03-15 08:37:00 +08:00
|
|
|
AR->getPostIncExpr(*this), N))) {
|
|
|
|
// Cache knowledge of AR NUW, which is propagated to this AddRec.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNUW);
|
2009-07-14 05:35:55 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getZeroExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-07-14 05:35:55 +08:00
|
|
|
} else if (isKnownNegative(Step)) {
|
|
|
|
const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
|
|
|
|
getSignedRange(Step).getSignedMin());
|
2010-05-04 09:11:15 +08:00
|
|
|
if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT, AR, N) ||
|
|
|
|
(isLoopEntryGuardedByCond(L, ICmpInst::ICMP_UGT, Start, N) &&
|
2009-07-14 05:35:55 +08:00
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT,
|
2011-03-15 08:37:00 +08:00
|
|
|
AR->getPostIncExpr(*this), N))) {
|
|
|
|
// Cache knowledge of AR NW, which is propagated to this AddRec.
|
|
|
|
// Negative step causes unsigned wrap, but it still can't self-wrap.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNW);
|
|
|
|
// Return the expression with the addrec on the outside.
|
2009-07-14 05:35:55 +08:00
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-04-28 04:16:15 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-07-14 04:55:53 +08:00
|
|
|
// The cast wasn't folded; create an explicit cast node.
|
|
|
|
// Recompute the insert position, as it may have been invalidated.
|
2009-06-28 05:21:31 +08:00
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
2010-03-19 02:49:47 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVZeroExtendExpr(ID.Intern(SCEVAllocator),
|
|
|
|
Op, Ty);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getSignExtendExpr(const SCEV *Op,
|
2009-07-14 06:05:32 +08:00
|
|
|
const Type *Ty) {
|
2009-04-21 09:07:12 +08:00
|
|
|
assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
|
2009-04-21 08:55:22 +08:00
|
|
|
"This is not an extending conversion!");
|
2009-05-02 00:44:18 +08:00
|
|
|
assert(isSCEVable(Ty) &&
|
|
|
|
"This is not a conversion to a SCEVable type!");
|
|
|
|
Ty = getEffectiveSCEVType(Ty);
|
2009-04-21 08:55:22 +08:00
|
|
|
|
2009-07-01 04:13:32 +08:00
|
|
|
// Fold if the operand is constant.
|
2010-06-25 00:47:03 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
|
|
|
|
return getConstant(
|
|
|
|
cast<ConstantInt>(ConstantExpr::getSExt(SC->getValue(),
|
|
|
|
getEffectiveSCEVType(Ty))));
|
2007-06-15 22:38:12 +08:00
|
|
|
|
2009-04-23 00:20:48 +08:00
|
|
|
// sext(sext(x)) --> sext(x)
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVSignExtendExpr *SS = dyn_cast<SCEVSignExtendExpr>(Op))
|
2009-04-23 00:20:48 +08:00
|
|
|
return getSignExtendExpr(SS->getOperand(), Ty);
|
|
|
|
|
2011-01-19 23:56:12 +08:00
|
|
|
// sext(zext(x)) --> zext(x)
|
|
|
|
if (const SCEVZeroExtendExpr *SZ = dyn_cast<SCEVZeroExtendExpr>(Op))
|
|
|
|
return getZeroExtendExpr(SZ->getOperand(), Ty);
|
|
|
|
|
2009-07-14 04:55:53 +08:00
|
|
|
// Before doing any expensive analysis, check to see if we've already
|
|
|
|
// computed a SCEV for this Op and Ty.
|
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scSignExtend);
|
|
|
|
ID.AddPointer(Op);
|
|
|
|
ID.AddPointer(Ty);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
|
|
|
|
2011-01-23 06:06:21 +08:00
|
|
|
// If the input value is provably positive, build a zext instead.
|
|
|
|
if (isKnownNonNegative(Op))
|
|
|
|
return getZeroExtendExpr(Op, Ty);
|
|
|
|
|
2011-01-23 14:20:19 +08:00
|
|
|
// sext(trunc(x)) --> sext(x) or x or trunc(x)
|
|
|
|
if (const SCEVTruncateExpr *ST = dyn_cast<SCEVTruncateExpr>(Op)) {
|
|
|
|
// It's possible the bits taken off by the truncate were all sign bits. If
|
|
|
|
// so, we should be able to simplify this further.
|
|
|
|
const SCEV *X = ST->getOperand();
|
|
|
|
ConstantRange CR = getSignedRange(X);
|
|
|
|
unsigned TruncBits = getTypeSizeInBits(ST->getType());
|
|
|
|
unsigned NewBits = getTypeSizeInBits(Ty);
|
|
|
|
if (CR.truncate(TruncBits).signExtend(NewBits).contains(
|
2011-01-24 04:06:05 +08:00
|
|
|
CR.sextOrTrunc(NewBits)))
|
|
|
|
return getTruncateOrSignExtend(X, Ty);
|
2011-01-23 14:20:19 +08:00
|
|
|
}
|
|
|
|
|
2009-04-28 04:16:15 +08:00
|
|
|
// If the input value is a chrec scev, and we can prove that the value
|
2007-06-15 22:38:12 +08:00
|
|
|
// did not overflow the old, smaller, value, we can sign extend all of the
|
2009-04-28 04:16:15 +08:00
|
|
|
// operands (often constants). This allows analysis of something like
|
2007-06-15 22:38:12 +08:00
|
|
|
// this: for (signed char X = 0; X < 100; ++X) { int Y = X; }
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op))
|
2009-04-28 04:16:15 +08:00
|
|
|
if (AR->isAffine()) {
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *Start = AR->getStart();
|
|
|
|
const SCEV *Step = AR->getStepRecurrence(*this);
|
|
|
|
unsigned BitWidth = getTypeSizeInBits(AR->getType());
|
|
|
|
const Loop *L = AR->getLoop();
|
|
|
|
|
2009-07-25 09:22:26 +08:00
|
|
|
// If we have special knowledge that this addrec won't overflow,
|
|
|
|
// we don't need to do any further analysis.
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AR->getNoWrapFlags(SCEV::FlagNSW))
|
2009-07-25 09:22:26 +08:00
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, SCEV::FlagNSW);
|
2009-07-25 09:22:26 +08:00
|
|
|
|
2009-04-28 04:16:15 +08:00
|
|
|
// Check whether the backedge-taken count is SCEVCouldNotCompute.
|
|
|
|
// Note that this serves two purposes: It filters out loops that are
|
|
|
|
// simply not analyzable, and it covers the case where this code is
|
|
|
|
// being called from within backedge-taken count analysis, such that
|
|
|
|
// attempting to ask for the backedge-taken count would likely result
|
|
|
|
// in infinite recursion. In the later case, the analysis code will
|
|
|
|
// cope with a conservative value, and it will take care to purge
|
|
|
|
// that value once it has finished.
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *MaxBECount = getMaxBackedgeTakenCount(L);
|
2009-05-01 04:47:05 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(MaxBECount)) {
|
2009-04-29 09:54:20 +08:00
|
|
|
// Manually compute the final value for AR, checking for
|
2009-04-30 06:28:28 +08:00
|
|
|
// overflow.
|
2009-04-28 04:16:15 +08:00
|
|
|
|
|
|
|
// Check whether the backedge-taken count can be losslessly casted to
|
2009-04-30 06:28:28 +08:00
|
|
|
// the addrec's type. The count is always unsigned.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *CastedMaxBECount =
|
2009-05-01 04:47:05 +08:00
|
|
|
getTruncateOrZeroExtend(MaxBECount, Start->getType());
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *RecastedMaxBECount =
|
2009-05-18 23:58:39 +08:00
|
|
|
getTruncateOrZeroExtend(CastedMaxBECount, MaxBECount->getType());
|
|
|
|
if (MaxBECount == RecastedMaxBECount) {
|
2009-08-14 05:58:54 +08:00
|
|
|
const Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
|
2009-05-01 04:47:05 +08:00
|
|
|
// Check whether Start+Step*MaxBECount has no signed overflow.
|
2010-02-25 03:31:06 +08:00
|
|
|
const SCEV *SMul = getMulExpr(CastedMaxBECount, Step);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Add = getAddExpr(Start, SMul);
|
|
|
|
const SCEV *OperandExtendedAdd =
|
2009-05-18 23:58:39 +08:00
|
|
|
getAddExpr(getSignExtendExpr(Start, WideTy),
|
|
|
|
getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
|
|
|
|
getSignExtendExpr(Step, WideTy)));
|
2011-03-15 08:37:00 +08:00
|
|
|
if (getSignExtendExpr(Add, WideTy) == OperandExtendedAdd) {
|
|
|
|
// Cache knowledge of AR NSW, which is propagated to this AddRec.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
|
2009-04-30 06:28:28 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-07-17 01:34:36 +08:00
|
|
|
// Similar to above, only this time treat the step value as unsigned.
|
|
|
|
// This covers loops that count up with an unsigned step.
|
2010-02-25 03:31:06 +08:00
|
|
|
const SCEV *UMul = getMulExpr(CastedMaxBECount, Step);
|
2009-07-17 01:34:36 +08:00
|
|
|
Add = getAddExpr(Start, UMul);
|
|
|
|
OperandExtendedAdd =
|
2009-07-26 00:03:30 +08:00
|
|
|
getAddExpr(getSignExtendExpr(Start, WideTy),
|
2009-07-17 01:34:36 +08:00
|
|
|
getMulExpr(getZeroExtendExpr(CastedMaxBECount, WideTy),
|
|
|
|
getZeroExtendExpr(Step, WideTy)));
|
2011-03-15 08:37:00 +08:00
|
|
|
if (getSignExtendExpr(Add, WideTy) == OperandExtendedAdd) {
|
|
|
|
// Cache knowledge of AR NSW, which is propagated to this AddRec.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
|
2009-07-17 01:34:36 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getZeroExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If the backedge is guarded by a comparison with the pre-inc value
|
|
|
|
// the addrec is safe. Also, if the entry is guarded by a comparison
|
|
|
|
// with the start value and the backedge is guarded by a comparison
|
|
|
|
// with the post-inc value, the addrec is safe.
|
|
|
|
if (isKnownPositive(Step)) {
|
|
|
|
const SCEV *N = getConstant(APInt::getSignedMinValue(BitWidth) -
|
|
|
|
getSignedRange(Step).getSignedMax());
|
|
|
|
if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SLT, AR, N) ||
|
2010-04-12 03:27:13 +08:00
|
|
|
(isLoopEntryGuardedByCond(L, ICmpInst::ICMP_SLT, Start, N) &&
|
2009-07-14 05:35:55 +08:00
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SLT,
|
2011-03-15 08:37:00 +08:00
|
|
|
AR->getPostIncExpr(*this), N))) {
|
|
|
|
// Cache knowledge of AR NSW, which is propagated to this AddRec.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
|
2009-07-14 05:35:55 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-07-14 05:35:55 +08:00
|
|
|
} else if (isKnownNegative(Step)) {
|
|
|
|
const SCEV *N = getConstant(APInt::getSignedMaxValue(BitWidth) -
|
|
|
|
getSignedRange(Step).getSignedMin());
|
|
|
|
if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SGT, AR, N) ||
|
2010-04-12 03:27:13 +08:00
|
|
|
(isLoopEntryGuardedByCond(L, ICmpInst::ICMP_SGT, Start, N) &&
|
2009-07-14 05:35:55 +08:00
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SGT,
|
2011-03-15 08:37:00 +08:00
|
|
|
AR->getPostIncExpr(*this), N))) {
|
|
|
|
// Cache knowledge of AR NSW, which is propagated to this AddRec.
|
|
|
|
const_cast<SCEVAddRecExpr *>(AR)->setNoWrapFlags(SCEV::FlagNSW);
|
2009-07-14 05:35:55 +08:00
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
2011-03-15 08:37:00 +08:00
|
|
|
L, AR->getNoWrapFlags());
|
|
|
|
}
|
2009-04-28 04:16:15 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-06-15 22:38:12 +08:00
|
|
|
|
2009-07-14 04:55:53 +08:00
|
|
|
// The cast wasn't folded; create an explicit cast node.
|
|
|
|
// Recompute the insert position, as it may have been invalidated.
|
2009-06-28 05:21:31 +08:00
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
2010-03-19 02:49:47 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVSignExtendExpr(ID.Intern(SCEVAllocator),
|
|
|
|
Op, Ty);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2007-06-15 22:38:12 +08:00
|
|
|
}
|
|
|
|
|
2009-06-13 23:56:47 +08:00
|
|
|
/// getAnyExtendExpr - Return a SCEV for the given operand extended with
|
|
|
|
/// unspecified bits out to the given type.
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getAnyExtendExpr(const SCEV *Op,
|
2009-08-19 00:46:41 +08:00
|
|
|
const Type *Ty) {
|
2009-06-13 23:56:47 +08:00
|
|
|
assert(getTypeSizeInBits(Op->getType()) < getTypeSizeInBits(Ty) &&
|
|
|
|
"This is not an extending conversion!");
|
|
|
|
assert(isSCEVable(Ty) &&
|
|
|
|
"This is not a conversion to a SCEVable type!");
|
|
|
|
Ty = getEffectiveSCEVType(Ty);
|
|
|
|
|
|
|
|
// Sign-extend negative constants.
|
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
|
|
|
|
if (SC->getValue()->getValue().isNegative())
|
|
|
|
return getSignExtendExpr(Op, Ty);
|
|
|
|
|
|
|
|
// Peel off a truncate cast.
|
|
|
|
if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Op)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewOp = T->getOperand();
|
2009-06-13 23:56:47 +08:00
|
|
|
if (getTypeSizeInBits(NewOp->getType()) < getTypeSizeInBits(Ty))
|
|
|
|
return getAnyExtendExpr(NewOp, Ty);
|
|
|
|
return getTruncateOrNoop(NewOp, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Next try a zext cast. If the cast is folded, use it.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ZExt = getZeroExtendExpr(Op, Ty);
|
2009-06-13 23:56:47 +08:00
|
|
|
if (!isa<SCEVZeroExtendExpr>(ZExt))
|
|
|
|
return ZExt;
|
|
|
|
|
|
|
|
// Next try a sext cast. If the cast is folded, use it.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SExt = getSignExtendExpr(Op, Ty);
|
2009-06-13 23:56:47 +08:00
|
|
|
if (!isa<SCEVSignExtendExpr>(SExt))
|
|
|
|
return SExt;
|
|
|
|
|
2010-01-21 10:09:26 +08:00
|
|
|
// Force the cast to be folded into the operands of an addrec.
|
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Op)) {
|
|
|
|
SmallVector<const SCEV *, 4> Ops;
|
|
|
|
for (SCEVAddRecExpr::op_iterator I = AR->op_begin(), E = AR->op_end();
|
|
|
|
I != E; ++I)
|
|
|
|
Ops.push_back(getAnyExtendExpr(*I, Ty));
|
2011-03-15 08:37:00 +08:00
|
|
|
return getAddRecExpr(Ops, AR->getLoop(), SCEV::FlagNW);
|
2010-01-21 10:09:26 +08:00
|
|
|
}
|
|
|
|
|
2010-07-16 04:02:11 +08:00
|
|
|
// As a special case, fold anyext(undef) to undef. We don't want to
|
|
|
|
// know too much about SCEVUnknowns, but this special case is handy
|
|
|
|
// and harmless.
|
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(Op))
|
|
|
|
if (isa<UndefValue>(U->getValue()))
|
|
|
|
return getSCEV(UndefValue::get(Ty));
|
|
|
|
|
2009-06-13 23:56:47 +08:00
|
|
|
// If the expression is obviously signed, use the sext cast value.
|
|
|
|
if (isa<SCEVSMaxExpr>(Op))
|
|
|
|
return SExt;
|
|
|
|
|
|
|
|
// Absent any other information, use the zext cast value.
|
|
|
|
return ZExt;
|
|
|
|
}
|
|
|
|
|
2009-06-15 06:58:51 +08:00
|
|
|
/// CollectAddOperandsWithScales - Process the given Ops list, which is
|
|
|
|
/// a list of operands to be added under the given scale, update the given
|
|
|
|
/// map. This is a helper function for getAddRecExpr. As an example of
|
|
|
|
/// what it does, given a sequence of operands that would form an add
|
|
|
|
/// expression like this:
|
|
|
|
///
|
|
|
|
/// m + n + 13 + (A * (o + p + (B * q + m + 29))) + r + (-1 * r)
|
|
|
|
///
|
|
|
|
/// where A and B are constants, update the map with these values:
|
|
|
|
///
|
|
|
|
/// (m, 1+A*B), (n, 1), (o, A), (p, A), (q, A*B), (r, 0)
|
|
|
|
///
|
|
|
|
/// and add 13 + A*B*29 to AccumulatedConstant.
|
|
|
|
/// This will allow getAddRecExpr to produce this:
|
|
|
|
///
|
|
|
|
/// 13+A*B*29 + n + (m * (1+A*B)) + ((o + p) * A) + (q * A*B)
|
|
|
|
///
|
|
|
|
/// This form often exposes folding opportunities that are hidden in
|
|
|
|
/// the original operand list.
|
|
|
|
///
|
|
|
|
/// Return true iff it appears that any interesting folding opportunities
|
|
|
|
/// may be exposed. This helps getAddRecExpr short-circuit extra work in
|
|
|
|
/// the common case where no interesting opportunities are present, and
|
|
|
|
/// is also used as a check to avoid infinite recursion.
|
|
|
|
///
|
|
|
|
static bool
|
2009-07-08 01:06:11 +08:00
|
|
|
CollectAddOperandsWithScales(DenseMap<const SCEV *, APInt> &M,
|
|
|
|
SmallVector<const SCEV *, 8> &NewOps,
|
2009-06-15 06:58:51 +08:00
|
|
|
APInt &AccumulatedConstant,
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEV *const *Ops, size_t NumOperands,
|
2009-06-15 06:58:51 +08:00
|
|
|
const APInt &Scale,
|
|
|
|
ScalarEvolution &SE) {
|
|
|
|
bool Interesting = false;
|
|
|
|
|
2010-06-19 03:12:32 +08:00
|
|
|
// Iterate over the add operands. They are sorted, with constants first.
|
|
|
|
unsigned i = 0;
|
|
|
|
while (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
|
|
|
|
++i;
|
|
|
|
// Pull a buried constant out to the outside.
|
|
|
|
if (Scale != 1 || AccumulatedConstant != 0 || C->getValue()->isZero())
|
|
|
|
Interesting = true;
|
|
|
|
AccumulatedConstant += Scale * C->getValue()->getValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Next comes everything else. We're especially interested in multiplies
|
|
|
|
// here, but they're in the middle, so just visit the rest with one loop.
|
|
|
|
for (; i != NumOperands; ++i) {
|
2009-06-15 06:58:51 +08:00
|
|
|
const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[i]);
|
|
|
|
if (Mul && isa<SCEVConstant>(Mul->getOperand(0))) {
|
|
|
|
APInt NewScale =
|
|
|
|
Scale * cast<SCEVConstant>(Mul->getOperand(0))->getValue()->getValue();
|
|
|
|
if (Mul->getNumOperands() == 2 && isa<SCEVAddExpr>(Mul->getOperand(1))) {
|
|
|
|
// A multiplication of a constant with another add; recurse.
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEVAddExpr *Add = cast<SCEVAddExpr>(Mul->getOperand(1));
|
2009-06-15 06:58:51 +08:00
|
|
|
Interesting |=
|
|
|
|
CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
|
2010-03-18 09:17:13 +08:00
|
|
|
Add->op_begin(), Add->getNumOperands(),
|
2009-06-15 06:58:51 +08:00
|
|
|
NewScale, SE);
|
|
|
|
} else {
|
|
|
|
// A multiplication of a constant with some other value. Update
|
|
|
|
// the map.
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> MulOps(Mul->op_begin()+1, Mul->op_end());
|
|
|
|
const SCEV *Key = SE.getMulExpr(MulOps);
|
|
|
|
std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
|
2009-06-30 02:25:52 +08:00
|
|
|
M.insert(std::make_pair(Key, NewScale));
|
2009-06-15 06:58:51 +08:00
|
|
|
if (Pair.second) {
|
|
|
|
NewOps.push_back(Pair.first->first);
|
|
|
|
} else {
|
|
|
|
Pair.first->second += NewScale;
|
|
|
|
// The map already had an entry for this value, which may indicate
|
|
|
|
// a folding opportunity.
|
|
|
|
Interesting = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// An ordinary operand. Update the map.
|
2009-07-08 01:06:11 +08:00
|
|
|
std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
|
2009-06-30 02:25:52 +08:00
|
|
|
M.insert(std::make_pair(Ops[i], Scale));
|
2009-06-15 06:58:51 +08:00
|
|
|
if (Pair.second) {
|
|
|
|
NewOps.push_back(Pair.first->first);
|
|
|
|
} else {
|
|
|
|
Pair.first->second += Scale;
|
|
|
|
// The map already had an entry for this value, which may indicate
|
|
|
|
// a folding opportunity.
|
|
|
|
Interesting = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Interesting;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct APIntCompare {
|
|
|
|
bool operator()(const APInt &LHS, const APInt &RHS) const {
|
|
|
|
return LHS.ult(RHS);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2009-05-25 07:45:28 +08:00
|
|
|
/// getAddExpr - Get a canonical add expression, or something simpler if
|
|
|
|
/// possible.
|
2009-10-09 08:10:36 +08:00
|
|
|
const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::NoWrapFlags Flags) {
|
|
|
|
assert(!(Flags & ~(SCEV::FlagNUW | SCEV::FlagNSW)) &&
|
|
|
|
"only nuw or nsw allowed");
|
2004-04-03 04:23:17 +08:00
|
|
|
assert(!Ops.empty() && "Cannot get empty add!");
|
2004-04-08 00:16:11 +08:00
|
|
|
if (Ops.size() == 1) return Ops[0];
|
2009-05-18 23:44:58 +08:00
|
|
|
#ifndef NDEBUG
|
2010-06-19 03:09:27 +08:00
|
|
|
const Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
|
2009-05-18 23:44:58 +08:00
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
2010-06-19 03:09:27 +08:00
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
|
2009-05-18 23:44:58 +08:00
|
|
|
"SCEVAddExpr operand types don't match!");
|
|
|
|
#endif
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
// If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
|
2011-03-15 08:37:00 +08:00
|
|
|
// And vice-versa.
|
|
|
|
int SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
|
|
|
|
SCEV::NoWrapFlags SignOrUnsignWrap = maskFlags(Flags, SignOrUnsignMask);
|
|
|
|
if (SignOrUnsignWrap && (SignOrUnsignWrap != SignOrUnsignMask)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
bool All = true;
|
2010-08-17 00:27:53 +08:00
|
|
|
for (SmallVectorImpl<const SCEV *>::const_iterator I = Ops.begin(),
|
|
|
|
E = Ops.end(); I != E; ++I)
|
|
|
|
if (!isKnownNonNegative(*I)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
All = false;
|
|
|
|
break;
|
|
|
|
}
|
2011-03-15 08:37:00 +08:00
|
|
|
if (All) Flags = setFlags(Flags, (SCEV::NoWrapFlags)SignOrUnsignMask);
|
2010-01-21 10:09:26 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Sort by complexity, this groups all similar expression types together.
|
2009-05-07 22:39:04 +08:00
|
|
|
GroupByComplexity(Ops, LI);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// If there are any constants, fold them together.
|
|
|
|
unsigned Idx = 0;
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
|
2004-04-03 04:23:17 +08:00
|
|
|
++Idx;
|
2004-04-08 00:16:11 +08:00
|
|
|
assert(Idx < Ops.size());
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// We found two constants, fold them together!
|
2009-06-15 06:47:23 +08:00
|
|
|
Ops[0] = getConstant(LHSC->getValue()->getValue() +
|
|
|
|
RHSC->getValue()->getValue());
|
2009-06-15 06:53:57 +08:00
|
|
|
if (Ops.size() == 2) return Ops[0];
|
2008-02-20 14:48:22 +08:00
|
|
|
Ops.erase(Ops.begin()+1); // Erase the folded element
|
|
|
|
LHSC = cast<SCEVConstant>(Ops[0]);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If we are left with a constant zero being added, strip it off.
|
2010-04-13 07:08:18 +08:00
|
|
|
if (LHSC->getValue()->isZero()) {
|
2004-04-03 04:23:17 +08:00
|
|
|
Ops.erase(Ops.begin());
|
|
|
|
--Idx;
|
|
|
|
}
|
|
|
|
|
2010-04-13 07:08:18 +08:00
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2010-08-28 05:39:59 +08:00
|
|
|
// Okay, check to see if the same value occurs in the operand list more than
|
|
|
|
// once. If so, merge them together into an multiply expression. Since we
|
|
|
|
// sorted the list, these values are required to be adjacent.
|
2004-04-03 04:23:17 +08:00
|
|
|
const Type *Ty = Ops[0]->getType();
|
2010-08-12 22:46:54 +08:00
|
|
|
bool FoundMatch = false;
|
2010-08-28 05:39:59 +08:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e-1; ++i)
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Ops[i] == Ops[i+1]) { // X + Y + Y --> X + Y*2
|
2010-08-28 05:39:59 +08:00
|
|
|
// Scan ahead to count how many equal operands there are.
|
|
|
|
unsigned Count = 2;
|
|
|
|
while (i+Count != e && Ops[i+Count] == Ops[i])
|
|
|
|
++Count;
|
|
|
|
// Merge the values into a multiply.
|
|
|
|
const SCEV *Scale = getConstant(Ty, Count);
|
|
|
|
const SCEV *Mul = getMulExpr(Scale, Ops[i]);
|
|
|
|
if (Ops.size() == Count)
|
2004-04-03 04:23:17 +08:00
|
|
|
return Mul;
|
2010-08-12 22:46:54 +08:00
|
|
|
Ops[i] = Mul;
|
2010-08-28 05:39:59 +08:00
|
|
|
Ops.erase(Ops.begin()+i+1, Ops.begin()+i+Count);
|
2010-08-28 08:39:27 +08:00
|
|
|
--i; e -= Count - 1;
|
2010-08-12 22:46:54 +08:00
|
|
|
FoundMatch = true;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2010-08-12 22:46:54 +08:00
|
|
|
if (FoundMatch)
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddExpr(Ops, Flags);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-05-09 05:03:19 +08:00
|
|
|
// Check for truncates. If all the operands are truncated from the same
|
|
|
|
// type, see if factoring out the truncate would permit the result to be
|
|
|
|
// folded. eg., trunc(x) + m*trunc(n) --> trunc(x + trunc(m)*n)
|
|
|
|
// if the contents of the resulting outer trunc fold to something simple.
|
|
|
|
for (; Idx < Ops.size() && isa<SCEVTruncateExpr>(Ops[Idx]); ++Idx) {
|
|
|
|
const SCEVTruncateExpr *Trunc = cast<SCEVTruncateExpr>(Ops[Idx]);
|
|
|
|
const Type *DstType = Trunc->getType();
|
|
|
|
const Type *SrcType = Trunc->getOperand()->getType();
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 8> LargeOps;
|
2009-05-09 05:03:19 +08:00
|
|
|
bool Ok = true;
|
|
|
|
// Check all the operands to see if they can be represented in the
|
|
|
|
// source type of the truncate.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
|
|
|
|
if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(Ops[i])) {
|
|
|
|
if (T->getOperand()->getType() != SrcType) {
|
|
|
|
Ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LargeOps.push_back(T->getOperand());
|
|
|
|
} else if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
|
2010-04-23 09:51:29 +08:00
|
|
|
LargeOps.push_back(getAnyExtendExpr(C, SrcType));
|
2009-05-09 05:03:19 +08:00
|
|
|
} else if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(Ops[i])) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 8> LargeMulOps;
|
2009-05-09 05:03:19 +08:00
|
|
|
for (unsigned j = 0, f = M->getNumOperands(); j != f && Ok; ++j) {
|
|
|
|
if (const SCEVTruncateExpr *T =
|
|
|
|
dyn_cast<SCEVTruncateExpr>(M->getOperand(j))) {
|
|
|
|
if (T->getOperand()->getType() != SrcType) {
|
|
|
|
Ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
LargeMulOps.push_back(T->getOperand());
|
|
|
|
} else if (const SCEVConstant *C =
|
|
|
|
dyn_cast<SCEVConstant>(M->getOperand(j))) {
|
2010-04-23 09:51:29 +08:00
|
|
|
LargeMulOps.push_back(getAnyExtendExpr(C, SrcType));
|
2009-05-09 05:03:19 +08:00
|
|
|
} else {
|
|
|
|
Ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Ok)
|
|
|
|
LargeOps.push_back(getMulExpr(LargeMulOps));
|
|
|
|
} else {
|
|
|
|
Ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Ok) {
|
|
|
|
// Evaluate the expression in the larger type.
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *Fold = getAddExpr(LargeOps, Flags);
|
2009-05-09 05:03:19 +08:00
|
|
|
// If it folds to something simple, use it. Otherwise, don't.
|
|
|
|
if (isa<SCEVConstant>(Fold) || isa<SCEVUnknown>(Fold))
|
|
|
|
return getTruncateExpr(Fold, DstType);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Skip past any other cast SCEVs.
|
2007-06-19 03:30:09 +08:00
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
// If there are add operands they would be next.
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Idx < Ops.size()) {
|
|
|
|
bool DeletedAdd = false;
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[Idx])) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If we have an add, expand the add operands onto the end of the operands
|
|
|
|
// list.
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
2010-06-22 03:47:52 +08:00
|
|
|
Ops.append(Add->op_begin(), Add->op_end());
|
2004-04-03 04:23:17 +08:00
|
|
|
DeletedAdd = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we deleted at least one add, we added operands to the end of the list,
|
|
|
|
// and they are not necessarily sorted. Recurse to resort and resimplify
|
2010-03-02 01:49:51 +08:00
|
|
|
// any operands we just acquired.
|
2004-04-03 04:23:17 +08:00
|
|
|
if (DeletedAdd)
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Skip over the add expression until we get to a multiply.
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
|
|
|
|
++Idx;
|
|
|
|
|
2009-06-15 06:58:51 +08:00
|
|
|
// Check to see if there are any folding opportunities present with
|
|
|
|
// operands multiplied by constant values.
|
|
|
|
if (Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx])) {
|
|
|
|
uint64_t BitWidth = getTypeSizeInBits(Ty);
|
2009-07-08 01:06:11 +08:00
|
|
|
DenseMap<const SCEV *, APInt> M;
|
|
|
|
SmallVector<const SCEV *, 8> NewOps;
|
2009-06-15 06:58:51 +08:00
|
|
|
APInt AccumulatedConstant(BitWidth, 0);
|
|
|
|
if (CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
|
2010-03-18 09:17:13 +08:00
|
|
|
Ops.data(), Ops.size(),
|
|
|
|
APInt(BitWidth, 1), *this)) {
|
2009-06-15 06:58:51 +08:00
|
|
|
// Some interesting folding opportunity is present, so its worthwhile to
|
|
|
|
// re-generate the operands list. Group the operands by constant scale,
|
|
|
|
// to avoid multiplying by the same constant scale multiple times.
|
2009-07-08 01:06:11 +08:00
|
|
|
std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare> MulOpLists;
|
2010-08-17 00:30:01 +08:00
|
|
|
for (SmallVector<const SCEV *, 8>::const_iterator I = NewOps.begin(),
|
2009-06-15 06:58:51 +08:00
|
|
|
E = NewOps.end(); I != E; ++I)
|
|
|
|
MulOpLists[M.find(*I)->second].push_back(*I);
|
|
|
|
// Re-generate the operands list.
|
|
|
|
Ops.clear();
|
|
|
|
if (AccumulatedConstant != 0)
|
|
|
|
Ops.push_back(getConstant(AccumulatedConstant));
|
2009-06-24 12:48:43 +08:00
|
|
|
for (std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare>::iterator
|
|
|
|
I = MulOpLists.begin(), E = MulOpLists.end(); I != E; ++I)
|
2009-06-15 06:58:51 +08:00
|
|
|
if (I->first != 0)
|
2009-06-24 12:48:43 +08:00
|
|
|
Ops.push_back(getMulExpr(getConstant(I->first),
|
|
|
|
getAddExpr(I->second)));
|
2009-06-15 06:58:51 +08:00
|
|
|
if (Ops.empty())
|
2010-05-04 06:09:21 +08:00
|
|
|
return getConstant(Ty, 0);
|
2009-06-15 06:58:51 +08:00
|
|
|
if (Ops.size() == 1)
|
|
|
|
return Ops[0];
|
|
|
|
return getAddExpr(Ops);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// If we are adding something to a multiply expression, make sure the
|
|
|
|
// something is not already an operand of the multiply. If so, merge it into
|
|
|
|
// the multiply.
|
|
|
|
for (; Idx < Ops.size() && isa<SCEVMulExpr>(Ops[Idx]); ++Idx) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVMulExpr *Mul = cast<SCEVMulExpr>(Ops[Idx]);
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned MulOp = 0, e = Mul->getNumOperands(); MulOp != e; ++MulOp) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEV *MulOpSCEV = Mul->getOperand(MulOp);
|
2010-08-12 22:52:55 +08:00
|
|
|
if (isa<SCEVConstant>(MulOpSCEV))
|
|
|
|
continue;
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned AddOp = 0, e = Ops.size(); AddOp != e; ++AddOp)
|
2010-08-12 22:52:55 +08:00
|
|
|
if (MulOpSCEV == Ops[AddOp]) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// Fold W + X + (X * Y * Z) --> W + (X * ((Y*Z)+1))
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *InnerMul = Mul->getOperand(MulOp == 0);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Mul->getNumOperands() != 2) {
|
|
|
|
// If the multiply has more than two operands, we must get the
|
|
|
|
// Y*Z term.
|
2010-08-17 00:57:24 +08:00
|
|
|
SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
|
|
|
|
Mul->op_begin()+MulOp);
|
|
|
|
MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
|
2007-10-23 02:31:58 +08:00
|
|
|
InnerMul = getMulExpr(MulOps);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2010-05-04 06:09:21 +08:00
|
|
|
const SCEV *One = getConstant(Ty, 1);
|
2010-08-14 04:17:14 +08:00
|
|
|
const SCEV *AddOne = getAddExpr(One, InnerMul);
|
2010-08-12 22:52:55 +08:00
|
|
|
const SCEV *OuterMul = getMulExpr(AddOne, MulOpSCEV);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Ops.size() == 2) return OuterMul;
|
|
|
|
if (AddOp < Idx) {
|
|
|
|
Ops.erase(Ops.begin()+AddOp);
|
|
|
|
Ops.erase(Ops.begin()+Idx-1);
|
|
|
|
} else {
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
Ops.erase(Ops.begin()+AddOp-1);
|
|
|
|
}
|
|
|
|
Ops.push_back(OuterMul);
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Check this multiply against other multiplies being added together.
|
|
|
|
for (unsigned OtherMulIdx = Idx+1;
|
|
|
|
OtherMulIdx < Ops.size() && isa<SCEVMulExpr>(Ops[OtherMulIdx]);
|
|
|
|
++OtherMulIdx) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVMulExpr *OtherMul = cast<SCEVMulExpr>(Ops[OtherMulIdx]);
|
2004-04-03 04:23:17 +08:00
|
|
|
// If MulOp occurs in OtherMul, we can fold the two multiplies
|
|
|
|
// together.
|
|
|
|
for (unsigned OMulOp = 0, e = OtherMul->getNumOperands();
|
|
|
|
OMulOp != e; ++OMulOp)
|
|
|
|
if (OtherMul->getOperand(OMulOp) == MulOpSCEV) {
|
|
|
|
// Fold X + (A*B*C) + (A*D*E) --> X + (A*(B*C+D*E))
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *InnerMul1 = Mul->getOperand(MulOp == 0);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Mul->getNumOperands() != 2) {
|
2009-06-24 12:48:43 +08:00
|
|
|
SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
|
2010-08-17 00:57:24 +08:00
|
|
|
Mul->op_begin()+MulOp);
|
|
|
|
MulOps.append(Mul->op_begin()+MulOp+1, Mul->op_end());
|
2007-10-23 02:31:58 +08:00
|
|
|
InnerMul1 = getMulExpr(MulOps);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *InnerMul2 = OtherMul->getOperand(OMulOp == 0);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (OtherMul->getNumOperands() != 2) {
|
2009-06-24 12:48:43 +08:00
|
|
|
SmallVector<const SCEV *, 4> MulOps(OtherMul->op_begin(),
|
2010-08-17 00:57:24 +08:00
|
|
|
OtherMul->op_begin()+OMulOp);
|
|
|
|
MulOps.append(OtherMul->op_begin()+OMulOp+1, OtherMul->op_end());
|
2007-10-23 02:31:58 +08:00
|
|
|
InnerMul2 = getMulExpr(MulOps);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *InnerMulSum = getAddExpr(InnerMul1,InnerMul2);
|
|
|
|
const SCEV *OuterMul = getMulExpr(MulOpSCEV, InnerMulSum);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Ops.size() == 2) return OuterMul;
|
2010-09-01 06:50:31 +08:00
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
Ops.erase(Ops.begin()+OtherMulIdx-1);
|
|
|
|
Ops.push_back(OuterMul);
|
|
|
|
return getAddExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there are any add recurrences in the operands list, see if any other
|
|
|
|
// added values are loop invariant. If so, we can fold them into the
|
|
|
|
// recurrence.
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
// Scan over all recurrences, trying to fold loop invariants into them.
|
|
|
|
for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
|
|
|
|
// Scan all of the other operands to this add and add them to the vector if
|
|
|
|
// they are loop invariant w.r.t. the recurrence.
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 8> LIOps;
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
|
2010-04-13 07:08:18 +08:00
|
|
|
const Loop *AddRecLoop = AddRec->getLoop();
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2010-11-18 05:23:15 +08:00
|
|
|
if (isLoopInvariant(Ops[i], AddRecLoop)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
LIOps.push_back(Ops[i]);
|
|
|
|
Ops.erase(Ops.begin()+i);
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we found some loop invariants, fold them into the recurrence.
|
|
|
|
if (!LIOps.empty()) {
|
2008-09-15 01:21:12 +08:00
|
|
|
// NLI + LI + {Start,+,Step} --> NLI + {LI+Start,+,Step}
|
2004-04-03 04:23:17 +08:00
|
|
|
LIOps.push_back(AddRec->getStart());
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
|
2009-12-18 11:57:04 +08:00
|
|
|
AddRec->op_end());
|
2007-10-23 02:31:58 +08:00
|
|
|
AddRecOps[0] = getAddExpr(LIOps);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2010-06-30 15:16:37 +08:00
|
|
|
// Build the new addrec. Propagate the NUW and NSW flags if both the
|
2011-01-11 17:02:09 +08:00
|
|
|
// outer add and the inner addrec are guaranteed to have no overflow.
|
2011-03-15 08:37:00 +08:00
|
|
|
// Always propagate NW.
|
|
|
|
Flags = AddRec->getNoWrapFlags(setFlags(Flags, SCEV::FlagNW));
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *NewRec = getAddRecExpr(AddRecOps, AddRecLoop, Flags);
|
2009-12-19 02:45:31 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// If all of the other operands were loop invariant, we are done.
|
|
|
|
if (Ops.size() == 1) return NewRec;
|
|
|
|
|
|
|
|
// Otherwise, add the folded AddRec by the non-liv parts.
|
|
|
|
for (unsigned i = 0;; ++i)
|
|
|
|
if (Ops[i] == AddRec) {
|
|
|
|
Ops[i] = NewRec;
|
|
|
|
break;
|
|
|
|
}
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, if there weren't any loop invariants to be folded, check to see if
|
|
|
|
// there are multiple AddRec's with the same loop induction variable being
|
|
|
|
// added together. If so, we can fold them.
|
|
|
|
for (unsigned OtherIdx = Idx+1;
|
2010-08-28 04:45:56 +08:00
|
|
|
OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
|
|
|
|
++OtherIdx)
|
|
|
|
if (AddRecLoop == cast<SCEVAddRecExpr>(Ops[OtherIdx])->getLoop()) {
|
|
|
|
// Other + {A,+,B}<L> + {C,+,D}<L> --> Other + {A+C,+,B+D}<L>
|
|
|
|
SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
|
|
|
|
AddRec->op_end());
|
|
|
|
for (; OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
|
|
|
|
++OtherIdx)
|
2010-08-29 22:53:34 +08:00
|
|
|
if (const SCEVAddRecExpr *OtherAddRec =
|
2010-08-28 04:45:56 +08:00
|
|
|
dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]))
|
2010-08-29 22:53:34 +08:00
|
|
|
if (OtherAddRec->getLoop() == AddRecLoop) {
|
|
|
|
for (unsigned i = 0, e = OtherAddRec->getNumOperands();
|
|
|
|
i != e; ++i) {
|
2010-08-28 04:45:56 +08:00
|
|
|
if (i >= AddRecOps.size()) {
|
2010-08-29 22:53:34 +08:00
|
|
|
AddRecOps.append(OtherAddRec->op_begin()+i,
|
|
|
|
OtherAddRec->op_end());
|
2010-08-28 04:45:56 +08:00
|
|
|
break;
|
|
|
|
}
|
2010-08-29 22:53:34 +08:00
|
|
|
AddRecOps[i] = getAddExpr(AddRecOps[i],
|
|
|
|
OtherAddRec->getOperand(i));
|
2010-08-28 04:45:56 +08:00
|
|
|
}
|
|
|
|
Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2011-03-15 00:50:06 +08:00
|
|
|
// Step size has changed, so we cannot guarantee no self-wraparound.
|
|
|
|
Ops[Idx] = getAddRecExpr(AddRecOps, AddRecLoop, SCEV::FlagAnyWrap);
|
2010-08-28 04:45:56 +08:00
|
|
|
return getAddExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise couldn't fold anything into this recurrence. Move onto the
|
|
|
|
// next one.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, it looks like we really DO need an add expr. Check to see if we
|
|
|
|
// already have one, otherwise create a new one.
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scAddExpr);
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
ID.AddPointer(Ops[i]);
|
|
|
|
void *IP = 0;
|
2010-01-21 10:09:26 +08:00
|
|
|
SCEVAddExpr *S =
|
|
|
|
static_cast<SCEVAddExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
|
|
|
|
if (!S) {
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
|
|
|
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
2010-03-19 02:49:47 +08:00
|
|
|
S = new (SCEVAllocator) SCEVAddExpr(ID.Intern(SCEVAllocator),
|
|
|
|
O, Ops.size());
|
2010-01-21 10:09:26 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
}
|
2011-03-15 00:50:06 +08:00
|
|
|
S->setNoWrapFlags(Flags);
|
2009-06-28 05:21:31 +08:00
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-05-25 07:45:28 +08:00
|
|
|
/// getMulExpr - Get a canonical multiply expression, or something simpler if
|
|
|
|
/// possible.
|
2009-10-09 08:10:36 +08:00
|
|
|
const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::NoWrapFlags Flags) {
|
|
|
|
assert(Flags == maskFlags(Flags, SCEV::FlagNUW | SCEV::FlagNSW) &&
|
|
|
|
"only nuw or nsw allowed");
|
2004-04-03 04:23:17 +08:00
|
|
|
assert(!Ops.empty() && "Cannot get empty mul!");
|
2010-01-21 10:09:26 +08:00
|
|
|
if (Ops.size() == 1) return Ops[0];
|
2009-05-18 23:44:58 +08:00
|
|
|
#ifndef NDEBUG
|
2010-08-17 00:13:54 +08:00
|
|
|
const Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
|
2009-05-18 23:44:58 +08:00
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
2010-08-17 00:13:54 +08:00
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
|
2009-05-18 23:44:58 +08:00
|
|
|
"SCEVMulExpr operand types don't match!");
|
|
|
|
#endif
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
// If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
|
2011-03-15 08:37:00 +08:00
|
|
|
// And vice-versa.
|
|
|
|
int SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
|
|
|
|
SCEV::NoWrapFlags SignOrUnsignWrap = maskFlags(Flags, SignOrUnsignMask);
|
|
|
|
if (SignOrUnsignWrap && (SignOrUnsignWrap != SignOrUnsignMask)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
bool All = true;
|
2010-08-17 00:27:53 +08:00
|
|
|
for (SmallVectorImpl<const SCEV *>::const_iterator I = Ops.begin(),
|
|
|
|
E = Ops.end(); I != E; ++I)
|
|
|
|
if (!isKnownNonNegative(*I)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
All = false;
|
|
|
|
break;
|
|
|
|
}
|
2011-03-15 08:37:00 +08:00
|
|
|
if (All) Flags = setFlags(Flags, (SCEV::NoWrapFlags)SignOrUnsignMask);
|
2010-01-21 10:09:26 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Sort by complexity, this groups all similar expression types together.
|
2009-05-07 22:39:04 +08:00
|
|
|
GroupByComplexity(Ops, LI);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// If there are any constants, fold them together.
|
|
|
|
unsigned Idx = 0;
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// C1*(C2+V) -> C1*C2 + C1*V
|
|
|
|
if (Ops.size() == 2)
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1]))
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Add->getNumOperands() == 2 &&
|
|
|
|
isa<SCEVConstant>(Add->getOperand(0)))
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddExpr(getMulExpr(LHSC, Add->getOperand(0)),
|
|
|
|
getMulExpr(LHSC, Add->getOperand(1)));
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
++Idx;
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// We found two constants, fold them together!
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt *Fold = ConstantInt::get(getContext(),
|
|
|
|
LHSC->getValue()->getValue() *
|
2008-02-20 14:48:22 +08:00
|
|
|
RHSC->getValue()->getValue());
|
|
|
|
Ops[0] = getConstant(Fold);
|
|
|
|
Ops.erase(Ops.begin()+1); // Erase the folded element
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
LHSC = cast<SCEVConstant>(Ops[0]);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If we are left with a constant one being multiplied, strip it off.
|
|
|
|
if (cast<SCEVConstant>(Ops[0])->getValue()->equalsInt(1)) {
|
|
|
|
Ops.erase(Ops.begin());
|
|
|
|
--Idx;
|
2007-03-02 08:28:52 +08:00
|
|
|
} else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If we have a multiply of zero, it will always be zero.
|
|
|
|
return Ops[0];
|
2010-01-21 10:09:26 +08:00
|
|
|
} else if (Ops[0]->isAllOnesValue()) {
|
|
|
|
// If we have a mul by -1 of an add, try distributing the -1 among the
|
|
|
|
// add operands.
|
2011-03-15 00:50:06 +08:00
|
|
|
if (Ops.size() == 2) {
|
2010-01-21 10:09:26 +08:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(Ops[1])) {
|
|
|
|
SmallVector<const SCEV *, 4> NewOps;
|
|
|
|
bool AnyFolded = false;
|
2011-03-15 00:50:06 +08:00
|
|
|
for (SCEVAddRecExpr::op_iterator I = Add->op_begin(),
|
|
|
|
E = Add->op_end(); I != E; ++I) {
|
2010-01-21 10:09:26 +08:00
|
|
|
const SCEV *Mul = getMulExpr(Ops[0], *I);
|
|
|
|
if (!isa<SCEVMulExpr>(Mul)) AnyFolded = true;
|
|
|
|
NewOps.push_back(Mul);
|
|
|
|
}
|
|
|
|
if (AnyFolded)
|
|
|
|
return getAddExpr(NewOps);
|
|
|
|
}
|
2011-03-15 01:38:54 +08:00
|
|
|
else if (const SCEVAddRecExpr *
|
|
|
|
AddRec = dyn_cast<SCEVAddRecExpr>(Ops[1])) {
|
|
|
|
// Negation preserves a recurrence's no self-wrap property.
|
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
|
|
|
for (SCEVAddRecExpr::op_iterator I = AddRec->op_begin(),
|
|
|
|
E = AddRec->op_end(); I != E; ++I) {
|
|
|
|
Operands.push_back(getMulExpr(Ops[0], *I));
|
|
|
|
}
|
|
|
|
return getAddRecExpr(Operands, AddRec->getLoop(),
|
|
|
|
AddRec->getNoWrapFlags(SCEV::FlagNW));
|
|
|
|
}
|
2011-03-15 00:50:06 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2010-04-14 00:49:23 +08:00
|
|
|
|
|
|
|
if (Ops.size() == 1)
|
|
|
|
return Ops[0];
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Skip over the add expression until we get to a multiply.
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
// If there are mul operands inline them all into this expression.
|
|
|
|
if (Idx < Ops.size()) {
|
|
|
|
bool DeletedMul = false;
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(Ops[Idx])) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If we have an mul, expand the mul operands onto the end of the operands
|
|
|
|
// list.
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
2010-06-22 03:47:52 +08:00
|
|
|
Ops.append(Mul->op_begin(), Mul->op_end());
|
2004-04-03 04:23:17 +08:00
|
|
|
DeletedMul = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we deleted at least one mul, we added operands to the end of the list,
|
|
|
|
// and they are not necessarily sorted. Recurse to resort and resimplify
|
2010-03-02 01:49:51 +08:00
|
|
|
// any operands we just acquired.
|
2004-04-03 04:23:17 +08:00
|
|
|
if (DeletedMul)
|
2007-10-23 02:31:58 +08:00
|
|
|
return getMulExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If there are any add recurrences in the operands list, see if any other
|
|
|
|
// added values are loop invariant. If so, we can fold them into the
|
|
|
|
// recurrence.
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scAddRecExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
// Scan over all recurrences, trying to fold loop invariants into them.
|
|
|
|
for (; Idx < Ops.size() && isa<SCEVAddRecExpr>(Ops[Idx]); ++Idx) {
|
|
|
|
// Scan all of the other operands to this mul and add them to the vector if
|
|
|
|
// they are loop invariant w.r.t. the recurrence.
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 8> LIOps;
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *AddRec = cast<SCEVAddRecExpr>(Ops[Idx]);
|
2010-08-29 22:55:19 +08:00
|
|
|
const Loop *AddRecLoop = AddRec->getLoop();
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
2010-11-18 05:23:15 +08:00
|
|
|
if (isLoopInvariant(Ops[i], AddRecLoop)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
LIOps.push_back(Ops[i]);
|
|
|
|
Ops.erase(Ops.begin()+i);
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we found some loop invariants, fold them into the recurrence.
|
|
|
|
if (!LIOps.empty()) {
|
2008-09-15 01:21:12 +08:00
|
|
|
// NLI * LI * {Start,+,Step} --> NLI * {LI*Start,+,LI*Step}
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> NewOps;
|
2004-04-03 04:23:17 +08:00
|
|
|
NewOps.reserve(AddRec->getNumOperands());
|
2010-06-18 07:34:09 +08:00
|
|
|
const SCEV *Scale = getMulExpr(LIOps);
|
|
|
|
for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
|
|
|
|
NewOps.push_back(getMulExpr(Scale, AddRec->getOperand(i)));
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2010-06-30 15:16:37 +08:00
|
|
|
// Build the new addrec. Propagate the NUW and NSW flags if both the
|
|
|
|
// outer mul and the inner addrec are guaranteed to have no overflow.
|
2011-03-15 00:50:06 +08:00
|
|
|
//
|
|
|
|
// No self-wrap cannot be guaranteed after changing the step size, but
|
|
|
|
// will be infered if either NUW or NSW is true.
|
|
|
|
Flags = AddRec->getNoWrapFlags(clearFlags(Flags, SCEV::FlagNW));
|
|
|
|
const SCEV *NewRec = getAddRecExpr(NewOps, AddRecLoop, Flags);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// If all of the other operands were loop invariant, we are done.
|
|
|
|
if (Ops.size() == 1) return NewRec;
|
|
|
|
|
|
|
|
// Otherwise, multiply the folded AddRec by the non-liv parts.
|
|
|
|
for (unsigned i = 0;; ++i)
|
|
|
|
if (Ops[i] == AddRec) {
|
|
|
|
Ops[i] = NewRec;
|
|
|
|
break;
|
|
|
|
}
|
2007-10-23 02:31:58 +08:00
|
|
|
return getMulExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, if there weren't any loop invariants to be folded, check to see if
|
|
|
|
// there are multiple AddRec's with the same loop induction variable being
|
|
|
|
// multiplied together. If so, we can fold them.
|
|
|
|
for (unsigned OtherIdx = Idx+1;
|
2010-09-01 06:52:12 +08:00
|
|
|
OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
|
|
|
|
++OtherIdx)
|
|
|
|
if (AddRecLoop == cast<SCEVAddRecExpr>(Ops[OtherIdx])->getLoop()) {
|
|
|
|
// F * G, where F = {A,+,B}<L> and G = {C,+,D}<L> -->
|
|
|
|
// {A*C,+,F*D + G*B + B*D}<L>
|
|
|
|
for (; OtherIdx != Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);
|
|
|
|
++OtherIdx)
|
|
|
|
if (const SCEVAddRecExpr *OtherAddRec =
|
|
|
|
dyn_cast<SCEVAddRecExpr>(Ops[OtherIdx]))
|
|
|
|
if (OtherAddRec->getLoop() == AddRecLoop) {
|
|
|
|
const SCEVAddRecExpr *F = AddRec, *G = OtherAddRec;
|
|
|
|
const SCEV *NewStart = getMulExpr(F->getStart(), G->getStart());
|
|
|
|
const SCEV *B = F->getStepRecurrence(*this);
|
|
|
|
const SCEV *D = G->getStepRecurrence(*this);
|
|
|
|
const SCEV *NewStep = getAddExpr(getMulExpr(F, D),
|
|
|
|
getMulExpr(G, B),
|
|
|
|
getMulExpr(B, D));
|
|
|
|
const SCEV *NewAddRec = getAddRecExpr(NewStart, NewStep,
|
2011-03-15 00:50:06 +08:00
|
|
|
F->getLoop(),
|
|
|
|
SCEV::FlagAnyWrap);
|
2010-09-01 06:52:12 +08:00
|
|
|
if (Ops.size() == 2) return NewAddRec;
|
|
|
|
Ops[Idx] = AddRec = cast<SCEVAddRecExpr>(NewAddRec);
|
|
|
|
Ops.erase(Ops.begin() + OtherIdx); --OtherIdx;
|
|
|
|
}
|
|
|
|
return getMulExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise couldn't fold anything into this recurrence. Move onto the
|
|
|
|
// next one.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, it looks like we really DO need an mul expr. Check to see if we
|
|
|
|
// already have one, otherwise create a new one.
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scMulExpr);
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
ID.AddPointer(Ops[i]);
|
|
|
|
void *IP = 0;
|
2010-01-21 10:09:26 +08:00
|
|
|
SCEVMulExpr *S =
|
|
|
|
static_cast<SCEVMulExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
|
|
|
|
if (!S) {
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
|
|
|
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
2010-03-19 02:49:47 +08:00
|
|
|
S = new (SCEVAllocator) SCEVMulExpr(ID.Intern(SCEVAllocator),
|
|
|
|
O, Ops.size());
|
2010-01-21 10:09:26 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
}
|
2011-03-15 00:50:06 +08:00
|
|
|
S->setNoWrapFlags(Flags);
|
2009-06-28 05:21:31 +08:00
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-08-08 06:55:26 +08:00
|
|
|
/// getUDivExpr - Get a canonical unsigned division expression, or something
|
|
|
|
/// simpler if possible.
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getUDivExpr(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-05-18 23:44:58 +08:00
|
|
|
assert(getEffectiveSCEVType(LHS->getType()) ==
|
|
|
|
getEffectiveSCEVType(RHS->getType()) &&
|
|
|
|
"SCEVUDivExpr operand types don't match!");
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
if (RHSC->getValue()->equalsInt(1))
|
2009-08-21 00:42:55 +08:00
|
|
|
return LHS; // X udiv 1 --> x
|
2010-04-22 09:35:11 +08:00
|
|
|
// If the denominator is zero, the result of the udiv is undefined. Don't
|
|
|
|
// try to analyze it, because the resolution chosen here may differ from
|
|
|
|
// the resolution chosen in other parts of the compiler.
|
|
|
|
if (!RHSC->getValue()->isZero()) {
|
|
|
|
// Determine if the division can be folded into the operands of
|
|
|
|
// its operands.
|
|
|
|
// TODO: Generalize this to non-constants by using known-bits information.
|
|
|
|
const Type *Ty = LHS->getType();
|
|
|
|
unsigned LZ = RHSC->getValue()->getValue().countLeadingZeros();
|
2010-08-05 03:52:50 +08:00
|
|
|
unsigned MaxShiftAmt = getTypeSizeInBits(Ty) - LZ - 1;
|
2010-04-22 09:35:11 +08:00
|
|
|
// For non-power-of-two values, effectively round the value up to the
|
|
|
|
// nearest power of two.
|
|
|
|
if (!RHSC->getValue()->getValue().isPowerOf2())
|
|
|
|
++MaxShiftAmt;
|
|
|
|
const IntegerType *ExtTy =
|
|
|
|
IntegerType::get(getContext(), getTypeSizeInBits(Ty) + MaxShiftAmt);
|
|
|
|
// {X,+,N}/C --> {X/C,+,N/C} if safe and N/C can be folded.
|
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
|
|
|
|
if (const SCEVConstant *Step =
|
|
|
|
dyn_cast<SCEVConstant>(AR->getStepRecurrence(*this)))
|
|
|
|
if (!Step->getValue()->getValue()
|
|
|
|
.urem(RHSC->getValue()->getValue()) &&
|
|
|
|
getZeroExtendExpr(AR, ExtTy) ==
|
|
|
|
getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
|
|
|
|
getZeroExtendExpr(Step, ExtTy),
|
2011-03-15 00:50:06 +08:00
|
|
|
AR->getLoop(), SCEV::FlagAnyWrap)) {
|
2010-04-22 09:35:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
|
|
|
for (unsigned i = 0, e = AR->getNumOperands(); i != e; ++i)
|
|
|
|
Operands.push_back(getUDivExpr(AR->getOperand(i), RHS));
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddRecExpr(Operands, AR->getLoop(),
|
2011-03-15 08:37:00 +08:00
|
|
|
SCEV::FlagNW);
|
2009-05-09 04:18:49 +08:00
|
|
|
}
|
2010-04-22 09:35:11 +08:00
|
|
|
// (A*B)/C --> A*(B/C) if safe and B/C can be folded.
|
|
|
|
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
|
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
|
|
|
for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i)
|
|
|
|
Operands.push_back(getZeroExtendExpr(M->getOperand(i), ExtTy));
|
|
|
|
if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
|
|
|
|
// Find an operand that's safely divisible.
|
|
|
|
for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
|
|
|
|
const SCEV *Op = M->getOperand(i);
|
|
|
|
const SCEV *Div = getUDivExpr(Op, RHSC);
|
|
|
|
if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
|
|
|
|
Operands = SmallVector<const SCEV *, 4>(M->op_begin(),
|
|
|
|
M->op_end());
|
|
|
|
Operands[i] = Div;
|
|
|
|
return getMulExpr(Operands);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// (A+B)/C --> (A/C + B/C) if safe and A/C and B/C can be folded.
|
|
|
|
if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(LHS)) {
|
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
|
|
|
for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i)
|
|
|
|
Operands.push_back(getZeroExtendExpr(A->getOperand(i), ExtTy));
|
|
|
|
if (getZeroExtendExpr(A, ExtTy) == getAddExpr(Operands)) {
|
|
|
|
Operands.clear();
|
|
|
|
for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i) {
|
|
|
|
const SCEV *Op = getUDivExpr(A->getOperand(i), RHS);
|
|
|
|
if (isa<SCEVUDivExpr>(Op) ||
|
|
|
|
getMulExpr(Op, RHS) != A->getOperand(i))
|
|
|
|
break;
|
|
|
|
Operands.push_back(Op);
|
|
|
|
}
|
|
|
|
if (Operands.size() == A->getNumOperands())
|
|
|
|
return getAddExpr(Operands);
|
2009-05-09 04:18:49 +08:00
|
|
|
}
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2010-04-22 09:35:11 +08:00
|
|
|
// Fold if both operands are constant.
|
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
|
|
|
|
Constant *LHSCV = LHSC->getValue();
|
|
|
|
Constant *RHSCV = RHSC->getValue();
|
|
|
|
return getConstant(cast<ConstantInt>(ConstantExpr::getUDiv(LHSCV,
|
|
|
|
RHSCV)));
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scUDivExpr);
|
|
|
|
ID.AddPointer(LHS);
|
|
|
|
ID.AddPointer(RHS);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
2010-03-19 02:49:47 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVUDivExpr(ID.Intern(SCEVAllocator),
|
|
|
|
LHS, RHS);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-05-25 07:45:28 +08:00
|
|
|
/// getAddRecExpr - Get an add recurrence expression for the specified loop.
|
|
|
|
/// Simplify the expression as much as possible.
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *ScalarEvolution::getAddRecExpr(const SCEV *Start, const SCEV *Step,
|
|
|
|
const Loop *L,
|
|
|
|
SCEV::NoWrapFlags Flags) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
2004-04-03 04:23:17 +08:00
|
|
|
Operands.push_back(Start);
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *StepChrec = dyn_cast<SCEVAddRecExpr>(Step))
|
2004-04-03 04:23:17 +08:00
|
|
|
if (StepChrec->getLoop() == L) {
|
2010-06-22 03:47:52 +08:00
|
|
|
Operands.append(StepChrec->op_begin(), StepChrec->op_end());
|
2011-03-15 08:37:00 +08:00
|
|
|
return getAddRecExpr(Operands, L, maskFlags(Flags, SCEV::FlagNW));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Operands.push_back(Step);
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddRecExpr(Operands, L, Flags);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-05-25 07:45:28 +08:00
|
|
|
/// getAddRecExpr - Get an add recurrence expression for the specified loop.
|
|
|
|
/// Simplify the expression as much as possible.
|
2009-06-24 12:48:43 +08:00
|
|
|
const SCEV *
|
2009-07-08 01:06:11 +08:00
|
|
|
ScalarEvolution::getAddRecExpr(SmallVectorImpl<const SCEV *> &Operands,
|
2011-03-15 00:50:06 +08:00
|
|
|
const Loop *L, SCEV::NoWrapFlags Flags) {
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Operands.size() == 1) return Operands[0];
|
2009-05-18 23:44:58 +08:00
|
|
|
#ifndef NDEBUG
|
2010-08-17 00:13:54 +08:00
|
|
|
const Type *ETy = getEffectiveSCEVType(Operands[0]->getType());
|
2009-05-18 23:44:58 +08:00
|
|
|
for (unsigned i = 1, e = Operands.size(); i != e; ++i)
|
2010-08-17 00:13:54 +08:00
|
|
|
assert(getEffectiveSCEVType(Operands[i]->getType()) == ETy &&
|
2009-05-18 23:44:58 +08:00
|
|
|
"SCEVAddRecExpr operand types don't match!");
|
2010-11-18 04:48:38 +08:00
|
|
|
for (unsigned i = 0, e = Operands.size(); i != e; ++i)
|
2010-11-18 05:23:15 +08:00
|
|
|
assert(isLoopInvariant(Operands[i], L) &&
|
2010-11-18 04:48:38 +08:00
|
|
|
"SCEVAddRecExpr operand is not loop-invariant!");
|
2009-05-18 23:44:58 +08:00
|
|
|
#endif
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2008-06-19 00:23:07 +08:00
|
|
|
if (Operands.back()->isZero()) {
|
|
|
|
Operands.pop_back();
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddRecExpr(Operands, L, SCEV::FlagAnyWrap); // {X,+,0} --> X
|
2008-06-19 00:23:07 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2010-02-20 02:49:22 +08:00
|
|
|
// It's tempting to want to call getMaxBackedgeTakenCount count here and
|
|
|
|
// use that information to infer NUW and NSW flags. However, computing a
|
|
|
|
// BE count requires calling getAddRecExpr, so we may not yet have a
|
|
|
|
// meaningful BE count at this point (and if we don't, we'd be stuck
|
|
|
|
// with a SCEVCouldNotCompute as the cached BE count).
|
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
// If FlagNSW is true and all the operands are non-negative, infer FlagNUW.
|
2011-03-15 08:37:00 +08:00
|
|
|
// And vice-versa.
|
|
|
|
int SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
|
|
|
|
SCEV::NoWrapFlags SignOrUnsignWrap = maskFlags(Flags, SignOrUnsignMask);
|
|
|
|
if (SignOrUnsignWrap && (SignOrUnsignWrap != SignOrUnsignMask)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
bool All = true;
|
2010-08-17 00:27:53 +08:00
|
|
|
for (SmallVectorImpl<const SCEV *>::const_iterator I = Operands.begin(),
|
|
|
|
E = Operands.end(); I != E; ++I)
|
|
|
|
if (!isKnownNonNegative(*I)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
All = false;
|
|
|
|
break;
|
|
|
|
}
|
2011-03-15 08:37:00 +08:00
|
|
|
if (All) Flags = setFlags(Flags, (SCEV::NoWrapFlags)SignOrUnsignMask);
|
2010-01-21 10:09:26 +08:00
|
|
|
}
|
|
|
|
|
2008-08-09 02:33:12 +08:00
|
|
|
// Canonicalize nested AddRecs in by nesting them in order of loop depth.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *NestedAR = dyn_cast<SCEVAddRecExpr>(Operands[0])) {
|
2009-12-18 09:14:11 +08:00
|
|
|
const Loop *NestedLoop = NestedAR->getLoop();
|
2010-08-14 04:23:25 +08:00
|
|
|
if (L->contains(NestedLoop) ?
|
2010-01-21 10:09:26 +08:00
|
|
|
(L->getLoopDepth() < NestedLoop->getLoopDepth()) :
|
2010-08-14 04:23:25 +08:00
|
|
|
(!NestedLoop->contains(L) &&
|
2010-01-21 10:09:26 +08:00
|
|
|
DT->dominates(L->getHeader(), NestedLoop->getHeader()))) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> NestedOperands(NestedAR->op_begin(),
|
2009-12-18 09:14:11 +08:00
|
|
|
NestedAR->op_end());
|
2008-08-09 02:33:12 +08:00
|
|
|
Operands[0] = NestedAR->getStart();
|
2009-06-27 06:36:20 +08:00
|
|
|
// AddRecs require their operands be loop-invariant with respect to their
|
|
|
|
// loops. Don't perform this transformation if it would break this
|
|
|
|
// requirement.
|
|
|
|
bool AllInvariant = true;
|
|
|
|
for (unsigned i = 0, e = Operands.size(); i != e; ++i)
|
2010-11-18 05:23:15 +08:00
|
|
|
if (!isLoopInvariant(Operands[i], L)) {
|
2009-06-27 06:36:20 +08:00
|
|
|
AllInvariant = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (AllInvariant) {
|
2011-03-15 00:50:06 +08:00
|
|
|
// Create a recurrence for the outer loop with the same step size.
|
|
|
|
//
|
|
|
|
// The outer recurrence keeps its NW flag but only keeps NUW/NSW if the
|
|
|
|
// inner recurrence has the same property.
|
2011-03-15 08:37:00 +08:00
|
|
|
SCEV::NoWrapFlags OuterFlags =
|
|
|
|
maskFlags(Flags, SCEV::FlagNW | NestedAR->getNoWrapFlags());
|
2011-03-15 00:50:06 +08:00
|
|
|
|
|
|
|
NestedOperands[0] = getAddRecExpr(Operands, L, OuterFlags);
|
2009-06-27 06:36:20 +08:00
|
|
|
AllInvariant = true;
|
|
|
|
for (unsigned i = 0, e = NestedOperands.size(); i != e; ++i)
|
2010-11-18 05:23:15 +08:00
|
|
|
if (!isLoopInvariant(NestedOperands[i], NestedLoop)) {
|
2009-06-27 06:36:20 +08:00
|
|
|
AllInvariant = false;
|
|
|
|
break;
|
|
|
|
}
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AllInvariant) {
|
2009-06-27 06:36:20 +08:00
|
|
|
// Ok, both add recurrences are valid after the transformation.
|
2011-03-15 00:50:06 +08:00
|
|
|
//
|
|
|
|
// The inner recurrence keeps its NW flag but only keeps NUW/NSW if
|
|
|
|
// the outer recurrence has the same property.
|
2011-03-15 08:37:00 +08:00
|
|
|
SCEV::NoWrapFlags InnerFlags =
|
|
|
|
maskFlags(NestedAR->getNoWrapFlags(), SCEV::FlagNW | Flags);
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddRecExpr(NestedOperands, NestedLoop, InnerFlags);
|
|
|
|
}
|
2009-06-27 06:36:20 +08:00
|
|
|
}
|
|
|
|
// Reset Operands to its original state.
|
|
|
|
Operands[0] = NestedAR;
|
2008-08-09 02:33:12 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-20 06:27:22 +08:00
|
|
|
// Okay, it looks like we really DO need an addrec expr. Check to see if we
|
|
|
|
// already have one, otherwise create a new one.
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scAddRecExpr);
|
|
|
|
for (unsigned i = 0, e = Operands.size(); i != e; ++i)
|
|
|
|
ID.AddPointer(Operands[i]);
|
|
|
|
ID.AddPointer(L);
|
|
|
|
void *IP = 0;
|
2010-01-21 10:09:26 +08:00
|
|
|
SCEVAddRecExpr *S =
|
|
|
|
static_cast<SCEVAddRecExpr *>(UniqueSCEVs.FindNodeOrInsertPos(ID, IP));
|
|
|
|
if (!S) {
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Operands.size());
|
|
|
|
std::uninitialized_copy(Operands.begin(), Operands.end(), O);
|
2010-03-19 02:49:47 +08:00
|
|
|
S = new (SCEVAllocator) SCEVAddRecExpr(ID.Intern(SCEVAllocator),
|
|
|
|
O, Operands.size(), L);
|
2010-01-21 10:09:26 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
}
|
2011-03-15 00:50:06 +08:00
|
|
|
S->setNoWrapFlags(Flags);
|
2009-06-28 05:21:31 +08:00
|
|
|
return S;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getSMaxExpr(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 2> Ops;
|
2007-11-26 06:41:31 +08:00
|
|
|
Ops.push_back(LHS);
|
|
|
|
Ops.push_back(RHS);
|
|
|
|
return getSMaxExpr(Ops);
|
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getSMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
|
2007-11-26 06:41:31 +08:00
|
|
|
assert(!Ops.empty() && "Cannot get empty smax!");
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
2009-05-18 23:44:58 +08:00
|
|
|
#ifndef NDEBUG
|
2010-08-17 00:13:54 +08:00
|
|
|
const Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
|
2009-05-18 23:44:58 +08:00
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
2010-08-17 00:13:54 +08:00
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
|
2009-05-18 23:44:58 +08:00
|
|
|
"SCEVSMaxExpr operand types don't match!");
|
|
|
|
#endif
|
2007-11-26 06:41:31 +08:00
|
|
|
|
|
|
|
// Sort by complexity, this groups all similar expression types together.
|
2009-05-07 22:39:04 +08:00
|
|
|
GroupByComplexity(Ops, LI);
|
2007-11-26 06:41:31 +08:00
|
|
|
|
|
|
|
// If there are any constants, fold them together.
|
|
|
|
unsigned Idx = 0;
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
|
2007-11-26 06:41:31 +08:00
|
|
|
++Idx;
|
|
|
|
assert(Idx < Ops.size());
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
|
2007-11-26 06:41:31 +08:00
|
|
|
// We found two constants, fold them together!
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt *Fold = ConstantInt::get(getContext(),
|
2007-11-26 06:41:31 +08:00
|
|
|
APIntOps::smax(LHSC->getValue()->getValue(),
|
|
|
|
RHSC->getValue()->getValue()));
|
2008-02-20 14:48:22 +08:00
|
|
|
Ops[0] = getConstant(Fold);
|
|
|
|
Ops.erase(Ops.begin()+1); // Erase the folded element
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
LHSC = cast<SCEVConstant>(Ops[0]);
|
2007-11-26 06:41:31 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 22:46:22 +08:00
|
|
|
// If we are left with a constant minimum-int, strip it off.
|
2007-11-26 06:41:31 +08:00
|
|
|
if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(true)) {
|
|
|
|
Ops.erase(Ops.begin());
|
|
|
|
--Idx;
|
2009-06-24 22:46:22 +08:00
|
|
|
} else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(true)) {
|
|
|
|
// If we have an smax with a constant maximum-int, it will always be
|
|
|
|
// maximum-int.
|
|
|
|
return Ops[0];
|
2007-11-26 06:41:31 +08:00
|
|
|
}
|
|
|
|
|
2010-04-14 00:49:23 +08:00
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
}
|
2007-11-26 06:41:31 +08:00
|
|
|
|
|
|
|
// Find the first SMax
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scSMaxExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
// Check to see if one of the operands is an SMax. If so, expand its operands
|
|
|
|
// onto our operand list, and recurse to simplify.
|
|
|
|
if (Idx < Ops.size()) {
|
|
|
|
bool DeletedSMax = false;
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(Ops[Idx])) {
|
2007-11-26 06:41:31 +08:00
|
|
|
Ops.erase(Ops.begin()+Idx);
|
2010-06-22 03:47:52 +08:00
|
|
|
Ops.append(SMax->op_begin(), SMax->op_end());
|
2007-11-26 06:41:31 +08:00
|
|
|
DeletedSMax = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DeletedSMax)
|
|
|
|
return getSMaxExpr(Ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, check to see if the same value occurs in the operand list twice. If
|
|
|
|
// so, delete one. Since we sorted the list, these values are required to
|
|
|
|
// be adjacent.
|
|
|
|
for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
|
2010-04-14 00:51:03 +08:00
|
|
|
// X smax Y smax Y --> X smax Y
|
|
|
|
// X smax Y --> X, if X is always greater than Y
|
|
|
|
if (Ops[i] == Ops[i+1] ||
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_SGE, Ops[i], Ops[i+1])) {
|
|
|
|
Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
|
|
|
|
--i; --e;
|
|
|
|
} else if (isKnownPredicate(ICmpInst::ICMP_SLE, Ops[i], Ops[i+1])) {
|
2007-11-26 06:41:31 +08:00
|
|
|
Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
|
|
|
|
assert(!Ops.empty() && "Reduced smax down to nothing!");
|
|
|
|
|
2008-02-20 14:48:22 +08:00
|
|
|
// Okay, it looks like we really DO need an smax expr. Check to see if we
|
2007-11-26 06:41:31 +08:00
|
|
|
// already have one, otherwise create a new one.
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scSMaxExpr);
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
ID.AddPointer(Ops[i]);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
|
|
|
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
2010-03-19 02:49:47 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVSMaxExpr(ID.Intern(SCEVAllocator),
|
|
|
|
O, Ops.size());
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2007-11-26 06:41:31 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getUMaxExpr(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 2> Ops;
|
2008-02-20 14:48:22 +08:00
|
|
|
Ops.push_back(LHS);
|
|
|
|
Ops.push_back(RHS);
|
|
|
|
return getUMaxExpr(Ops);
|
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getUMaxExpr(SmallVectorImpl<const SCEV *> &Ops) {
|
2008-02-20 14:48:22 +08:00
|
|
|
assert(!Ops.empty() && "Cannot get empty umax!");
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
2009-05-18 23:44:58 +08:00
|
|
|
#ifndef NDEBUG
|
2010-08-17 00:13:54 +08:00
|
|
|
const Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
|
2009-05-18 23:44:58 +08:00
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
2010-08-17 00:13:54 +08:00
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) == ETy &&
|
2009-05-18 23:44:58 +08:00
|
|
|
"SCEVUMaxExpr operand types don't match!");
|
|
|
|
#endif
|
2008-02-20 14:48:22 +08:00
|
|
|
|
|
|
|
// Sort by complexity, this groups all similar expression types together.
|
2009-05-07 22:39:04 +08:00
|
|
|
GroupByComplexity(Ops, LI);
|
2008-02-20 14:48:22 +08:00
|
|
|
|
|
|
|
// If there are any constants, fold them together.
|
|
|
|
unsigned Idx = 0;
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(Ops[0])) {
|
2008-02-20 14:48:22 +08:00
|
|
|
++Idx;
|
|
|
|
assert(Idx < Ops.size());
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(Ops[Idx])) {
|
2008-02-20 14:48:22 +08:00
|
|
|
// We found two constants, fold them together!
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt *Fold = ConstantInt::get(getContext(),
|
2008-02-20 14:48:22 +08:00
|
|
|
APIntOps::umax(LHSC->getValue()->getValue(),
|
|
|
|
RHSC->getValue()->getValue()));
|
|
|
|
Ops[0] = getConstant(Fold);
|
|
|
|
Ops.erase(Ops.begin()+1); // Erase the folded element
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
LHSC = cast<SCEVConstant>(Ops[0]);
|
|
|
|
}
|
|
|
|
|
2009-06-24 22:46:22 +08:00
|
|
|
// If we are left with a constant minimum-int, strip it off.
|
2008-02-20 14:48:22 +08:00
|
|
|
if (cast<SCEVConstant>(Ops[0])->getValue()->isMinValue(false)) {
|
|
|
|
Ops.erase(Ops.begin());
|
|
|
|
--Idx;
|
2009-06-24 22:46:22 +08:00
|
|
|
} else if (cast<SCEVConstant>(Ops[0])->getValue()->isMaxValue(false)) {
|
|
|
|
// If we have an umax with a constant maximum-int, it will always be
|
|
|
|
// maximum-int.
|
|
|
|
return Ops[0];
|
2008-02-20 14:48:22 +08:00
|
|
|
}
|
|
|
|
|
2010-04-14 00:49:23 +08:00
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
}
|
2008-02-20 14:48:22 +08:00
|
|
|
|
|
|
|
// Find the first UMax
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scUMaxExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
// Check to see if one of the operands is a UMax. If so, expand its operands
|
|
|
|
// onto our operand list, and recurse to simplify.
|
|
|
|
if (Idx < Ops.size()) {
|
|
|
|
bool DeletedUMax = false;
|
2009-05-05 06:02:23 +08:00
|
|
|
while (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(Ops[Idx])) {
|
2008-02-20 14:48:22 +08:00
|
|
|
Ops.erase(Ops.begin()+Idx);
|
2010-06-22 03:47:52 +08:00
|
|
|
Ops.append(UMax->op_begin(), UMax->op_end());
|
2008-02-20 14:48:22 +08:00
|
|
|
DeletedUMax = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DeletedUMax)
|
|
|
|
return getUMaxExpr(Ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, check to see if the same value occurs in the operand list twice. If
|
|
|
|
// so, delete one. Since we sorted the list, these values are required to
|
|
|
|
// be adjacent.
|
|
|
|
for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
|
2010-04-14 00:51:03 +08:00
|
|
|
// X umax Y umax Y --> X umax Y
|
|
|
|
// X umax Y --> X, if X is always greater than Y
|
|
|
|
if (Ops[i] == Ops[i+1] ||
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_UGE, Ops[i], Ops[i+1])) {
|
|
|
|
Ops.erase(Ops.begin()+i+1, Ops.begin()+i+2);
|
|
|
|
--i; --e;
|
|
|
|
} else if (isKnownPredicate(ICmpInst::ICMP_ULE, Ops[i], Ops[i+1])) {
|
2008-02-20 14:48:22 +08:00
|
|
|
Ops.erase(Ops.begin()+i, Ops.begin()+i+1);
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
|
|
|
|
assert(!Ops.empty() && "Reduced umax down to nothing!");
|
|
|
|
|
|
|
|
// Okay, it looks like we really DO need a umax expr. Check to see if we
|
|
|
|
// already have one, otherwise create a new one.
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scUMaxExpr);
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
ID.AddPointer(Ops[i]);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
2010-03-18 09:17:13 +08:00
|
|
|
const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
|
|
|
|
std::uninitialized_copy(Ops.begin(), Ops.end(), O);
|
2010-03-19 02:49:47 +08:00
|
|
|
SCEV *S = new (SCEVAllocator) SCEVUMaxExpr(ID.Intern(SCEVAllocator),
|
|
|
|
O, Ops.size());
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2008-02-20 14:48:22 +08:00
|
|
|
}
|
|
|
|
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getSMinExpr(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-06-22 11:18:45 +08:00
|
|
|
// ~smax(~x, ~y) == smin(x, y).
|
|
|
|
return getNotSCEV(getSMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
|
|
|
|
}
|
|
|
|
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getUMinExpr(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-06-22 11:18:45 +08:00
|
|
|
// ~umax(~x, ~y) == umin(x, y)
|
|
|
|
return getNotSCEV(getUMaxExpr(getNotSCEV(LHS), getNotSCEV(RHS)));
|
|
|
|
}
|
|
|
|
|
2010-02-02 02:27:38 +08:00
|
|
|
const SCEV *ScalarEvolution::getSizeOfExpr(const Type *AllocTy) {
|
2010-04-13 07:03:26 +08:00
|
|
|
// If we have TargetData, we can bypass creating a target-independent
|
|
|
|
// constant expression and then folding it back into a ConstantInt.
|
|
|
|
// This is just a compile-time optimization.
|
|
|
|
if (TD)
|
|
|
|
return getConstant(TD->getIntPtrType(getContext()),
|
|
|
|
TD->getTypeAllocSize(AllocTy));
|
|
|
|
|
2010-02-02 02:27:38 +08:00
|
|
|
Constant *C = ConstantExpr::getSizeOf(AllocTy);
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
|
2010-05-29 00:12:08 +08:00
|
|
|
if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
|
|
|
|
C = Folded;
|
2010-02-02 02:27:38 +08:00
|
|
|
const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(AllocTy));
|
|
|
|
return getTruncateOrZeroExtend(getSCEV(C), Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
const SCEV *ScalarEvolution::getAlignOfExpr(const Type *AllocTy) {
|
|
|
|
Constant *C = ConstantExpr::getAlignOf(AllocTy);
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
|
2010-05-29 00:12:08 +08:00
|
|
|
if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
|
|
|
|
C = Folded;
|
2010-02-02 02:27:38 +08:00
|
|
|
const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(AllocTy));
|
|
|
|
return getTruncateOrZeroExtend(getSCEV(C), Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
const SCEV *ScalarEvolution::getOffsetOfExpr(const StructType *STy,
|
|
|
|
unsigned FieldNo) {
|
2010-04-13 07:03:26 +08:00
|
|
|
// If we have TargetData, we can bypass creating a target-independent
|
|
|
|
// constant expression and then folding it back into a ConstantInt.
|
|
|
|
// This is just a compile-time optimization.
|
|
|
|
if (TD)
|
|
|
|
return getConstant(TD->getIntPtrType(getContext()),
|
|
|
|
TD->getStructLayout(STy)->getElementOffset(FieldNo));
|
|
|
|
|
2010-01-28 10:15:55 +08:00
|
|
|
Constant *C = ConstantExpr::getOffsetOf(STy, FieldNo);
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
|
2010-05-29 00:12:08 +08:00
|
|
|
if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
|
|
|
|
C = Folded;
|
2009-08-19 00:46:41 +08:00
|
|
|
const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(STy));
|
2010-01-28 10:15:55 +08:00
|
|
|
return getTruncateOrZeroExtend(getSCEV(C), Ty);
|
2009-08-19 00:46:41 +08:00
|
|
|
}
|
|
|
|
|
2010-02-02 02:27:38 +08:00
|
|
|
const SCEV *ScalarEvolution::getOffsetOfExpr(const Type *CTy,
|
|
|
|
Constant *FieldNo) {
|
|
|
|
Constant *C = ConstantExpr::getOffsetOf(CTy, FieldNo);
|
2010-01-28 10:15:55 +08:00
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
|
2010-05-29 00:12:08 +08:00
|
|
|
if (Constant *Folded = ConstantFoldConstantExpression(CE, TD))
|
|
|
|
C = Folded;
|
2010-02-02 02:27:38 +08:00
|
|
|
const Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(CTy));
|
2010-01-28 10:15:55 +08:00
|
|
|
return getTruncateOrZeroExtend(getSCEV(C), Ty);
|
2009-08-19 00:46:41 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getUnknown(Value *V) {
|
2009-06-24 08:54:57 +08:00
|
|
|
// Don't attempt to do anything other than create a SCEVUnknown object
|
|
|
|
// here. createSCEV only calls getUnknown after checking for all other
|
|
|
|
// interesting possibilities, and any other code that calls getUnknown
|
|
|
|
// is doing so in order to hide a value from SCEV canonicalization.
|
|
|
|
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scUnknown);
|
|
|
|
ID.AddPointer(V);
|
|
|
|
void *IP = 0;
|
2010-08-03 07:49:30 +08:00
|
|
|
if (SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) {
|
|
|
|
assert(cast<SCEVUnknown>(S)->getValue() == V &&
|
|
|
|
"Stale SCEVUnknown in uniquing map!");
|
|
|
|
return S;
|
|
|
|
}
|
|
|
|
SCEV *S = new (SCEVAllocator) SCEVUnknown(ID.Intern(SCEVAllocator), V, this,
|
|
|
|
FirstUnknown);
|
|
|
|
FirstUnknown = cast<SCEVUnknown>(S);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
return S;
|
2004-04-15 23:07:24 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Basic SCEV Analysis and PHI Idiom Recognition Code
|
|
|
|
//
|
|
|
|
|
2009-04-21 09:07:12 +08:00
|
|
|
/// isSCEVable - Test if values of the given type are analyzable within
|
|
|
|
/// the SCEV framework. This primarily includes integer types, and it
|
|
|
|
/// can optionally include pointer types if the ScalarEvolution class
|
|
|
|
/// has access to target-specific information.
|
2009-04-22 07:15:49 +08:00
|
|
|
bool ScalarEvolution::isSCEVable(const Type *Ty) const {
|
2009-08-19 00:46:41 +08:00
|
|
|
// Integers and pointers are always SCEVable.
|
2010-02-16 19:11:14 +08:00
|
|
|
return Ty->isIntegerTy() || Ty->isPointerTy();
|
2009-04-21 09:07:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getTypeSizeInBits - Return the size in bits of the specified type,
|
|
|
|
/// for which isSCEVable must return true.
|
2009-04-22 07:15:49 +08:00
|
|
|
uint64_t ScalarEvolution::getTypeSizeInBits(const Type *Ty) const {
|
2009-04-21 09:07:12 +08:00
|
|
|
assert(isSCEVable(Ty) && "Type is not SCEVable!");
|
|
|
|
|
|
|
|
// If we have a TargetData, use it!
|
|
|
|
if (TD)
|
|
|
|
return TD->getTypeSizeInBits(Ty);
|
|
|
|
|
2009-08-19 00:46:41 +08:00
|
|
|
// Integer types have fixed sizes.
|
2010-02-16 00:12:20 +08:00
|
|
|
if (Ty->isIntegerTy())
|
2009-08-19 00:46:41 +08:00
|
|
|
return Ty->getPrimitiveSizeInBits();
|
|
|
|
|
|
|
|
// The only other support type is pointer. Without TargetData, conservatively
|
|
|
|
// assume pointers are 64-bit.
|
2010-02-16 19:11:14 +08:00
|
|
|
assert(Ty->isPointerTy() && "isSCEVable permitted a non-SCEVable type!");
|
2009-08-19 00:46:41 +08:00
|
|
|
return 64;
|
2009-04-21 09:07:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getEffectiveSCEVType - Return a type with the same bitwidth as
|
|
|
|
/// the given type and which represents how SCEV will treat the given
|
|
|
|
/// type, for which isSCEVable must return true. For pointer types,
|
|
|
|
/// this is the pointer-sized integer type.
|
2009-04-22 07:15:49 +08:00
|
|
|
const Type *ScalarEvolution::getEffectiveSCEVType(const Type *Ty) const {
|
2009-04-21 09:07:12 +08:00
|
|
|
assert(isSCEVable(Ty) && "Type is not SCEVable!");
|
|
|
|
|
2010-02-16 00:12:20 +08:00
|
|
|
if (Ty->isIntegerTy())
|
2009-04-21 09:07:12 +08:00
|
|
|
return Ty;
|
|
|
|
|
2009-08-19 00:46:41 +08:00
|
|
|
// The only other support type is pointer.
|
2010-02-16 19:11:14 +08:00
|
|
|
assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
|
2009-08-19 00:46:41 +08:00
|
|
|
if (TD) return TD->getIntPtrType(getContext());
|
|
|
|
|
|
|
|
// Without TargetData, conservatively assume pointers are 64-bit.
|
|
|
|
return Type::getInt64Ty(getContext());
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getCouldNotCompute() {
|
2009-06-28 05:21:31 +08:00
|
|
|
return &CouldNotCompute;
|
2009-04-19 01:58:19 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
/// getSCEV - Return an existing SCEV if it exists, otherwise analyze the
|
|
|
|
/// expression and create a new one.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getSCEV(Value *V) {
|
2009-04-21 09:07:12 +08:00
|
|
|
assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMapType::const_iterator I = ValueExprMap.find(V);
|
|
|
|
if (I != ValueExprMap.end()) return I->second;
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *S = createSCEV(V);
|
2010-08-17 00:31:39 +08:00
|
|
|
|
|
|
|
// The process of creating a SCEV for V may have caused other SCEVs
|
|
|
|
// to have been created, so it's necessary to insert the new entry
|
|
|
|
// from scratch, rather than trying to remember the insert position
|
|
|
|
// above.
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap.insert(std::make_pair(SCEVCallbackVH(V, this), S));
|
2004-04-03 04:23:17 +08:00
|
|
|
return S;
|
|
|
|
}
|
|
|
|
|
2009-04-16 11:18:22 +08:00
|
|
|
/// getNegativeSCEV - Return a SCEV corresponding to -V = -1*V
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getNegativeSCEV(const SCEV *V) {
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
|
2009-07-13 12:09:18 +08:00
|
|
|
return getConstant(
|
2009-07-30 02:55:55 +08:00
|
|
|
cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue())));
|
2009-04-16 11:18:22 +08:00
|
|
|
|
|
|
|
const Type *Ty = V->getType();
|
2009-04-22 07:15:49 +08:00
|
|
|
Ty = getEffectiveSCEVType(Ty);
|
2009-07-14 04:58:05 +08:00
|
|
|
return getMulExpr(V,
|
2009-08-01 04:28:14 +08:00
|
|
|
getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty))));
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getNotSCEV - Return a SCEV corresponding to ~V = -1-V
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getNotSCEV(const SCEV *V) {
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V))
|
2009-07-14 04:58:05 +08:00
|
|
|
return getConstant(
|
2009-07-30 02:55:55 +08:00
|
|
|
cast<ConstantInt>(ConstantExpr::getNot(VC->getValue())));
|
2009-04-16 11:18:22 +08:00
|
|
|
|
|
|
|
const Type *Ty = V->getType();
|
2009-04-22 07:15:49 +08:00
|
|
|
Ty = getEffectiveSCEVType(Ty);
|
2009-07-14 04:58:05 +08:00
|
|
|
const SCEV *AllOnes =
|
2009-08-01 04:28:14 +08:00
|
|
|
getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty)));
|
2009-04-16 11:18:22 +08:00
|
|
|
return getMinusSCEV(AllOnes, V);
|
|
|
|
}
|
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
/// getMinusSCEV - Return LHS-RHS. Minus is represented in SCEV as A+B*-1.
|
|
|
|
///
|
|
|
|
/// FIXME: prohibit FlagNUW here, as soon as getMinusSCEVForExitTest goes.
|
2011-01-10 06:26:35 +08:00
|
|
|
const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS, const SCEV *RHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::NoWrapFlags Flags) {
|
2010-07-21 00:53:00 +08:00
|
|
|
// Fast path: X - X --> 0.
|
|
|
|
if (LHS == RHS)
|
|
|
|
return getConstant(LHS->getType(), 0);
|
|
|
|
|
2009-04-16 11:18:22 +08:00
|
|
|
// X - Y --> X + -Y
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddExpr(LHS, getNegativeSCEV(RHS), Flags);
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getTruncateOrZeroExtend - Return a SCEV corresponding to a conversion of the
|
|
|
|
/// input value to the specified type. If the type must be extended, it is zero
|
|
|
|
/// extended.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
2011-01-10 06:26:35 +08:00
|
|
|
ScalarEvolution::getTruncateOrZeroExtend(const SCEV *V, const Type *Ty) {
|
2009-04-16 11:18:22 +08:00
|
|
|
const Type *SrcTy = V->getType();
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2009-04-16 11:18:22 +08:00
|
|
|
"Cannot truncate or zero extend with non-integer arguments!");
|
2009-04-21 09:07:12 +08:00
|
|
|
if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
|
2009-04-16 11:18:22 +08:00
|
|
|
return V; // No conversion
|
2009-04-21 09:07:12 +08:00
|
|
|
if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getTruncateExpr(V, Ty);
|
|
|
|
return getZeroExtendExpr(V, Ty);
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// getTruncateOrSignExtend - Return a SCEV corresponding to a conversion of the
|
|
|
|
/// input value to the specified type. If the type must be extended, it is sign
|
|
|
|
/// extended.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getTruncateOrSignExtend(const SCEV *V,
|
2009-04-23 13:15:08 +08:00
|
|
|
const Type *Ty) {
|
2009-04-16 11:18:22 +08:00
|
|
|
const Type *SrcTy = V->getType();
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2009-04-16 11:18:22 +08:00
|
|
|
"Cannot truncate or zero extend with non-integer arguments!");
|
2009-04-21 09:07:12 +08:00
|
|
|
if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
|
2009-04-16 11:18:22 +08:00
|
|
|
return V; // No conversion
|
2009-04-21 09:07:12 +08:00
|
|
|
if (getTypeSizeInBits(SrcTy) > getTypeSizeInBits(Ty))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getTruncateExpr(V, Ty);
|
|
|
|
return getSignExtendExpr(V, Ty);
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
|
|
|
|
2009-05-13 11:46:30 +08:00
|
|
|
/// getNoopOrZeroExtend - Return a SCEV corresponding to a conversion of the
|
|
|
|
/// input value to the specified type. If the type must be extended, it is zero
|
|
|
|
/// extended. The conversion must not be narrowing.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getNoopOrZeroExtend(const SCEV *V, const Type *Ty) {
|
2009-05-13 11:46:30 +08:00
|
|
|
const Type *SrcTy = V->getType();
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2009-05-13 11:46:30 +08:00
|
|
|
"Cannot noop or zero extend with non-integer arguments!");
|
|
|
|
assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
|
|
|
|
"getNoopOrZeroExtend cannot truncate!");
|
|
|
|
if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
|
|
|
|
return V; // No conversion
|
|
|
|
return getZeroExtendExpr(V, Ty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getNoopOrSignExtend - Return a SCEV corresponding to a conversion of the
|
|
|
|
/// input value to the specified type. If the type must be extended, it is sign
|
|
|
|
/// extended. The conversion must not be narrowing.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getNoopOrSignExtend(const SCEV *V, const Type *Ty) {
|
2009-05-13 11:46:30 +08:00
|
|
|
const Type *SrcTy = V->getType();
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2009-05-13 11:46:30 +08:00
|
|
|
"Cannot noop or sign extend with non-integer arguments!");
|
|
|
|
assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
|
|
|
|
"getNoopOrSignExtend cannot truncate!");
|
|
|
|
if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
|
|
|
|
return V; // No conversion
|
|
|
|
return getSignExtendExpr(V, Ty);
|
|
|
|
}
|
|
|
|
|
2009-06-13 23:56:47 +08:00
|
|
|
/// getNoopOrAnyExtend - Return a SCEV corresponding to a conversion of
|
|
|
|
/// the input value to the specified type. If the type must be extended,
|
|
|
|
/// it is extended with unspecified bits. The conversion must not be
|
|
|
|
/// narrowing.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getNoopOrAnyExtend(const SCEV *V, const Type *Ty) {
|
2009-06-13 23:56:47 +08:00
|
|
|
const Type *SrcTy = V->getType();
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2009-06-13 23:56:47 +08:00
|
|
|
"Cannot noop or any extend with non-integer arguments!");
|
|
|
|
assert(getTypeSizeInBits(SrcTy) <= getTypeSizeInBits(Ty) &&
|
|
|
|
"getNoopOrAnyExtend cannot truncate!");
|
|
|
|
if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
|
|
|
|
return V; // No conversion
|
|
|
|
return getAnyExtendExpr(V, Ty);
|
|
|
|
}
|
|
|
|
|
2009-05-13 11:46:30 +08:00
|
|
|
/// getTruncateOrNoop - Return a SCEV corresponding to a conversion of the
|
|
|
|
/// input value to the specified type. The conversion must not be widening.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::getTruncateOrNoop(const SCEV *V, const Type *Ty) {
|
2009-05-13 11:46:30 +08:00
|
|
|
const Type *SrcTy = V->getType();
|
2010-02-16 19:11:14 +08:00
|
|
|
assert((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
|
|
|
|
(Ty->isIntegerTy() || Ty->isPointerTy()) &&
|
2009-05-13 11:46:30 +08:00
|
|
|
"Cannot truncate or noop with non-integer arguments!");
|
|
|
|
assert(getTypeSizeInBits(SrcTy) >= getTypeSizeInBits(Ty) &&
|
|
|
|
"getTruncateOrNoop cannot extend!");
|
|
|
|
if (getTypeSizeInBits(SrcTy) == getTypeSizeInBits(Ty))
|
|
|
|
return V; // No conversion
|
|
|
|
return getTruncateExpr(V, Ty);
|
|
|
|
}
|
|
|
|
|
2009-06-22 08:31:57 +08:00
|
|
|
/// getUMaxFromMismatchedTypes - Promote the operands to the wider of
|
|
|
|
/// the types using zero-extension, and then perform a umax operation
|
|
|
|
/// with them.
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getUMaxFromMismatchedTypes(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *PromotedLHS = LHS;
|
|
|
|
const SCEV *PromotedRHS = RHS;
|
2009-06-22 08:31:57 +08:00
|
|
|
|
|
|
|
if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
|
|
|
|
PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
|
|
|
|
else
|
|
|
|
PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
|
|
|
|
|
|
|
|
return getUMaxExpr(PromotedLHS, PromotedRHS);
|
|
|
|
}
|
|
|
|
|
2009-06-22 23:03:27 +08:00
|
|
|
/// getUMinFromMismatchedTypes - Promote the operands to the wider of
|
|
|
|
/// the types using zero-extension, and then perform a umin operation
|
|
|
|
/// with them.
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getUMinFromMismatchedTypes(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *PromotedLHS = LHS;
|
|
|
|
const SCEV *PromotedRHS = RHS;
|
2009-06-22 23:03:27 +08:00
|
|
|
|
|
|
|
if (getTypeSizeInBits(LHS->getType()) > getTypeSizeInBits(RHS->getType()))
|
|
|
|
PromotedRHS = getZeroExtendExpr(RHS, LHS->getType());
|
|
|
|
else
|
|
|
|
PromotedLHS = getNoopOrZeroExtend(LHS, RHS->getType());
|
|
|
|
|
|
|
|
return getUMinExpr(PromotedLHS, PromotedRHS);
|
|
|
|
}
|
|
|
|
|
2009-07-25 09:13:03 +08:00
|
|
|
/// PushDefUseChildren - Push users of the given Instruction
|
|
|
|
/// onto the given Worklist.
|
|
|
|
static void
|
|
|
|
PushDefUseChildren(Instruction *I,
|
|
|
|
SmallVectorImpl<Instruction *> &Worklist) {
|
|
|
|
// Push the def-use children onto the Worklist stack.
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), UE = I->use_end();
|
|
|
|
UI != UE; ++UI)
|
2010-07-22 21:36:47 +08:00
|
|
|
Worklist.push_back(cast<Instruction>(*UI));
|
2009-07-25 09:13:03 +08:00
|
|
|
}
|
2005-02-13 12:37:18 +08:00
|
|
|
|
2009-07-25 09:13:03 +08:00
|
|
|
/// ForgetSymbolicValue - This looks up computed SCEV values for all
|
|
|
|
/// instructions that depend on the given instruction and removes them from
|
2010-08-28 02:55:03 +08:00
|
|
|
/// the ValueExprMapType map if they reference SymName. This is used during PHI
|
2009-07-25 09:13:03 +08:00
|
|
|
/// resolution.
|
|
|
|
void
|
2010-02-25 14:57:05 +08:00
|
|
|
ScalarEvolution::ForgetSymbolicName(Instruction *PN, const SCEV *SymName) {
|
2009-07-25 09:13:03 +08:00
|
|
|
SmallVector<Instruction *, 16> Worklist;
|
2010-02-25 14:57:05 +08:00
|
|
|
PushDefUseChildren(PN, Worklist);
|
2009-07-25 09:13:03 +08:00
|
|
|
|
|
|
|
SmallPtrSet<Instruction *, 8> Visited;
|
2010-02-25 14:57:05 +08:00
|
|
|
Visited.insert(PN);
|
2009-07-25 09:13:03 +08:00
|
|
|
while (!Worklist.empty()) {
|
2010-02-25 14:57:05 +08:00
|
|
|
Instruction *I = Worklist.pop_back_val();
|
2009-07-25 09:13:03 +08:00
|
|
|
if (!Visited.insert(I)) continue;
|
|
|
|
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMapType::iterator It =
|
|
|
|
ValueExprMap.find(static_cast<Value *>(I));
|
|
|
|
if (It != ValueExprMap.end()) {
|
2010-11-17 10:44:44 +08:00
|
|
|
const SCEV *Old = It->second;
|
|
|
|
|
2009-07-25 09:13:03 +08:00
|
|
|
// Short-circuit the def-use traversal if the symbolic name
|
|
|
|
// ceases to appear in expressions.
|
2010-11-18 06:27:42 +08:00
|
|
|
if (Old != SymName && !hasOperand(Old, SymName))
|
2009-07-25 09:13:03 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// SCEVUnknown for a PHI either means that it has an unrecognized
|
2010-02-25 14:57:05 +08:00
|
|
|
// structure, it's a PHI that's in the progress of being computed
|
|
|
|
// by createNodeForPHI, or it's a single-value PHI. In the first case,
|
|
|
|
// additional loop trip count information isn't going to change anything.
|
|
|
|
// In the second case, createNodeForPHI will perform the necessary
|
|
|
|
// updates on its own when it gets to that point. In the third, we do
|
|
|
|
// want to forget the SCEVUnknown.
|
|
|
|
if (!isa<PHINode>(I) ||
|
2010-11-17 10:44:44 +08:00
|
|
|
!isa<SCEVUnknown>(Old) ||
|
|
|
|
(I != PN && Old == SymName)) {
|
2010-11-18 07:28:48 +08:00
|
|
|
forgetMemoizedResults(Old);
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap.erase(It);
|
2009-09-01 05:15:23 +08:00
|
|
|
}
|
2009-07-25 09:13:03 +08:00
|
|
|
}
|
2005-02-13 12:37:18 +08:00
|
|
|
|
2009-07-25 09:13:03 +08:00
|
|
|
PushDefUseChildren(I, Worklist);
|
|
|
|
}
|
2005-02-13 12:37:18 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
/// createNodeForPHI - PHI nodes have two cases. Either the PHI node exists in
|
|
|
|
/// a loop header, making it a potential recurrence, or it doesn't.
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::createNodeForPHI(PHINode *PN) {
|
2010-04-12 15:49:36 +08:00
|
|
|
if (const Loop *L = LI->getLoopFor(PN->getParent()))
|
|
|
|
if (L->getHeader() == PN->getParent()) {
|
|
|
|
// The loop may have multiple entrances or multiple exits; we can analyze
|
|
|
|
// this phi as an addrec if it has a unique entry value and a unique
|
|
|
|
// backedge value.
|
|
|
|
Value *BEValueV = 0, *StartValueV = 0;
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
Value *V = PN->getIncomingValue(i);
|
|
|
|
if (L->contains(PN->getIncomingBlock(i))) {
|
|
|
|
if (!BEValueV) {
|
|
|
|
BEValueV = V;
|
|
|
|
} else if (BEValueV != V) {
|
|
|
|
BEValueV = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!StartValueV) {
|
|
|
|
StartValueV = V;
|
|
|
|
} else if (StartValueV != V) {
|
|
|
|
StartValueV = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (BEValueV && StartValueV) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// While we are analyzing this PHI node, handle its value symbolically.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SymbolicName = getUnknown(PN);
|
2010-08-28 02:55:03 +08:00
|
|
|
assert(ValueExprMap.find(PN) == ValueExprMap.end() &&
|
2004-04-03 04:23:17 +08:00
|
|
|
"PHI node already processed?");
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap.insert(std::make_pair(SCEVCallbackVH(PN, this), SymbolicName));
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// Using this symbolic name for the PHI, analyze the value coming around
|
|
|
|
// the back-edge.
|
2009-07-25 09:13:03 +08:00
|
|
|
const SCEV *BEValue = getSCEV(BEValueV);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// NOTE: If BEValue is loop invariant, we know that the PHI node just
|
|
|
|
// has a special value for the first iteration of the loop.
|
|
|
|
|
|
|
|
// If the value coming around the backedge is an add with the symbolic
|
|
|
|
// value we just inserted, then we found a simple induction variable!
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(BEValue)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If there is a single occurrence of the symbolic value, replace it
|
|
|
|
// with a recurrence.
|
|
|
|
unsigned FoundIndex = Add->getNumOperands();
|
|
|
|
for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
|
|
|
|
if (Add->getOperand(i) == SymbolicName)
|
|
|
|
if (FoundIndex == e) {
|
|
|
|
FoundIndex = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FoundIndex != Add->getNumOperands()) {
|
|
|
|
// Create an add with everything but the specified operand.
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 8> Ops;
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = Add->getNumOperands(); i != e; ++i)
|
|
|
|
if (i != FoundIndex)
|
|
|
|
Ops.push_back(Add->getOperand(i));
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Accum = getAddExpr(Ops);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// This is not a valid addrec if the step amount is varying each
|
|
|
|
// loop iteration, but is not itself an addrec in this loop.
|
2010-11-18 05:23:15 +08:00
|
|
|
if (isLoopInvariant(Accum, L) ||
|
2004-04-03 04:23:17 +08:00
|
|
|
(isa<SCEVAddRecExpr>(Accum) &&
|
|
|
|
cast<SCEVAddRecExpr>(Accum)->getLoop() == L)) {
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
|
2010-01-21 10:09:26 +08:00
|
|
|
|
|
|
|
// If the increment doesn't overflow, then neither the addrec nor
|
|
|
|
// the post-increment will overflow.
|
|
|
|
if (const AddOperator *OBO = dyn_cast<AddOperator>(BEValueV)) {
|
|
|
|
if (OBO->hasNoUnsignedWrap())
|
2011-03-15 00:50:06 +08:00
|
|
|
Flags = setFlags(Flags, SCEV::FlagNUW);
|
2010-01-21 10:09:26 +08:00
|
|
|
if (OBO->hasNoSignedWrap())
|
2011-03-15 00:50:06 +08:00
|
|
|
Flags = setFlags(Flags, SCEV::FlagNSW);
|
2011-03-10 01:23:39 +08:00
|
|
|
} else if (const GEPOperator *GEP =
|
2011-03-15 00:50:06 +08:00
|
|
|
dyn_cast<GEPOperator>(BEValueV)) {
|
|
|
|
// If the increment is an inbounds GEP, then we know the address
|
|
|
|
// space cannot be wrapped around. We cannot make any guarantee
|
|
|
|
// about signed or unsigned overflow because pointers are
|
|
|
|
// unsigned but we may have a negative index from the base
|
|
|
|
// pointer.
|
|
|
|
if (GEP->isInBounds())
|
2011-03-15 08:37:00 +08:00
|
|
|
Flags = setFlags(Flags, SCEV::FlagNW);
|
2010-01-21 10:09:26 +08:00
|
|
|
}
|
|
|
|
|
2010-04-12 15:49:36 +08:00
|
|
|
const SCEV *StartVal = getSCEV(StartValueV);
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *PHISCEV = getAddRecExpr(StartVal, Accum, L, Flags);
|
2010-01-21 10:09:26 +08:00
|
|
|
|
|
|
|
// Since the no-wrap flags are on the increment, they apply to the
|
|
|
|
// post-incremented value as well.
|
2010-11-18 05:23:15 +08:00
|
|
|
if (isLoopInvariant(Accum, L))
|
2010-01-21 10:09:26 +08:00
|
|
|
(void)getAddRecExpr(getAddExpr(StartVal, Accum),
|
2011-03-15 00:50:06 +08:00
|
|
|
Accum, L, Flags);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2006-04-27 02:34:07 +08:00
|
|
|
// Okay, for the entire analysis of this edge we assumed the PHI
|
2009-07-25 09:13:03 +08:00
|
|
|
// to be symbolic. We now need to go back and purge all of the
|
|
|
|
// entries for the scalars that use the symbolic expression.
|
|
|
|
ForgetSymbolicName(PN, SymbolicName);
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
|
2006-04-27 02:34:07 +08:00
|
|
|
return PHISCEV;
|
|
|
|
}
|
|
|
|
}
|
2009-05-05 06:02:23 +08:00
|
|
|
} else if (const SCEVAddRecExpr *AddRec =
|
|
|
|
dyn_cast<SCEVAddRecExpr>(BEValue)) {
|
2006-04-27 02:34:07 +08:00
|
|
|
// Otherwise, this could be a loop like this:
|
|
|
|
// i = 0; for (j = 1; ..; ++j) { .... i = j; }
|
|
|
|
// In this case, j = {1,+,1} and BEValue is j.
|
|
|
|
// Because the other in-value of i (0) fits the evolution of BEValue
|
|
|
|
// i really is an addrec evolution.
|
|
|
|
if (AddRec->getLoop() == L && AddRec->isAffine()) {
|
2010-04-12 15:49:36 +08:00
|
|
|
const SCEV *StartVal = getSCEV(StartValueV);
|
2006-04-27 02:34:07 +08:00
|
|
|
|
|
|
|
// If StartVal = j.start - j.stride, we can use StartVal as the
|
|
|
|
// initial step of the addrec evolution.
|
2009-04-22 07:15:49 +08:00
|
|
|
if (StartVal == getMinusSCEV(AddRec->getOperand(0),
|
2010-04-12 07:44:58 +08:00
|
|
|
AddRec->getOperand(1))) {
|
2011-03-15 00:50:06 +08:00
|
|
|
// FIXME: For constant StartVal, we should be able to infer
|
|
|
|
// no-wrap flags.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *PHISCEV =
|
2011-03-15 00:50:06 +08:00
|
|
|
getAddRecExpr(StartVal, AddRec->getOperand(1), L,
|
|
|
|
SCEV::FlagAnyWrap);
|
2006-04-27 02:34:07 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Okay, for the entire analysis of this edge we assumed the PHI
|
2009-07-25 09:13:03 +08:00
|
|
|
// to be symbolic. We now need to go back and purge all of the
|
|
|
|
// entries for the scalars that use the symbolic expression.
|
|
|
|
ForgetSymbolicName(PN, SymbolicName);
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
|
2004-04-03 04:23:17 +08:00
|
|
|
return PHISCEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-04-12 15:49:36 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2010-02-25 14:57:05 +08:00
|
|
|
// If the PHI has a single incoming value, follow that value, unless the
|
|
|
|
// PHI's incoming blocks are in a different loop, in which case doing so
|
|
|
|
// risks breaking LCSSA form. Instcombine would normally zap these, but
|
|
|
|
// it doesn't have DominatorTree information, so it may miss cases.
|
2010-11-19 03:59:41 +08:00
|
|
|
if (Value *V = SimplifyInstruction(PN, TD, DT))
|
|
|
|
if (LI->replacementPreservesLCSSAForm(PN, V))
|
2010-02-25 14:57:05 +08:00
|
|
|
return getSCEV(V);
|
2010-11-18 04:49:12 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// If it's not a loop phi, we can't handle it yet.
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUnknown(PN);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-05-09 04:26:55 +08:00
|
|
|
/// createNodeForGEP - Expand GEP instructions into add and multiply
|
|
|
|
/// operations. This allows them to be analyzed by regular SCEV code.
|
|
|
|
///
|
2009-12-18 10:09:29 +08:00
|
|
|
const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
|
2009-05-09 04:26:55 +08:00
|
|
|
|
2010-06-30 15:16:37 +08:00
|
|
|
// Don't blindly transfer the inbounds flag from the GEP instruction to the
|
|
|
|
// Add expression, because the Instruction may be guarded by control flow
|
|
|
|
// and the no-overflow bits may not be valid for the expression in any
|
2010-07-01 01:27:11 +08:00
|
|
|
// context.
|
2011-02-13 11:14:49 +08:00
|
|
|
bool isInBounds = GEP->isInBounds();
|
2010-06-29 09:41:41 +08:00
|
|
|
|
2009-08-19 00:46:41 +08:00
|
|
|
const Type *IntPtrTy = getEffectiveSCEVType(GEP->getType());
|
2009-05-09 04:36:47 +08:00
|
|
|
Value *Base = GEP->getOperand(0);
|
2009-05-09 08:14:52 +08:00
|
|
|
// Don't attempt to analyze GEPs over unsized objects.
|
|
|
|
if (!cast<PointerType>(Base->getType())->getElementType()->isSized())
|
|
|
|
return getUnknown(GEP);
|
2010-05-04 06:09:21 +08:00
|
|
|
const SCEV *TotalOffset = getConstant(IntPtrTy, 0);
|
2009-05-09 04:36:47 +08:00
|
|
|
gep_type_iterator GTI = gep_type_begin(GEP);
|
2010-08-02 14:00:15 +08:00
|
|
|
for (GetElementPtrInst::op_iterator I = llvm::next(GEP->op_begin()),
|
2009-05-09 04:36:47 +08:00
|
|
|
E = GEP->op_end();
|
2009-05-09 04:26:55 +08:00
|
|
|
I != E; ++I) {
|
|
|
|
Value *Index = *I;
|
|
|
|
// Compute the (potentially symbolic) offset in bytes for this index.
|
|
|
|
if (const StructType *STy = dyn_cast<StructType>(*GTI++)) {
|
|
|
|
// For a struct, add the member offset.
|
|
|
|
unsigned FieldNo = cast<ConstantInt>(Index)->getZExtValue();
|
2010-06-30 15:16:37 +08:00
|
|
|
const SCEV *FieldOffset = getOffsetOfExpr(STy, FieldNo);
|
|
|
|
|
|
|
|
// Add the field offset to the running total offset.
|
2010-07-01 01:27:11 +08:00
|
|
|
TotalOffset = getAddExpr(TotalOffset, FieldOffset);
|
2009-05-09 04:26:55 +08:00
|
|
|
} else {
|
|
|
|
// For an array, add the element offset, explicitly scaled.
|
2010-06-30 15:16:37 +08:00
|
|
|
const SCEV *ElementSize = getSizeOfExpr(*GTI);
|
|
|
|
const SCEV *IndexS = getSCEV(Index);
|
2010-03-02 01:49:51 +08:00
|
|
|
// Getelementptr indices are signed.
|
2010-06-30 15:16:37 +08:00
|
|
|
IndexS = getTruncateOrSignExtend(IndexS, IntPtrTy);
|
|
|
|
|
|
|
|
// Multiply the index by the element size to compute the element offset.
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *LocalOffset = getMulExpr(IndexS, ElementSize,
|
|
|
|
isInBounds ? SCEV::FlagNSW :
|
|
|
|
SCEV::FlagAnyWrap);
|
2010-06-30 15:16:37 +08:00
|
|
|
|
|
|
|
// Add the element offset to the running total offset.
|
2010-07-01 01:27:11 +08:00
|
|
|
TotalOffset = getAddExpr(TotalOffset, LocalOffset);
|
2009-05-09 04:26:55 +08:00
|
|
|
}
|
|
|
|
}
|
2010-06-30 15:16:37 +08:00
|
|
|
|
|
|
|
// Get the SCEV for the GEP base.
|
|
|
|
const SCEV *BaseS = getSCEV(Base);
|
|
|
|
|
|
|
|
// Add the total offset from all the GEP indices to the base.
|
2011-03-15 00:50:06 +08:00
|
|
|
return getAddExpr(BaseS, TotalOffset,
|
|
|
|
isInBounds ? SCEV::FlagNSW : SCEV::FlagAnyWrap);
|
2009-05-09 04:26:55 +08:00
|
|
|
}
|
|
|
|
|
2007-11-22 15:59:40 +08:00
|
|
|
/// GetMinTrailingZeros - Determine the minimum number of zero bits that S is
|
|
|
|
/// guaranteed to end in (at every loop iteration). It is, at the same time,
|
|
|
|
/// the minimum number of times S is divisible by 2. For example, given {4,+,8}
|
|
|
|
/// it returns 2. If S is guaranteed to be 0, it returns the bitwidth of S.
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t
|
2009-07-08 01:06:11 +08:00
|
|
|
ScalarEvolution::GetMinTrailingZeros(const SCEV *S) {
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
|
2007-11-24 06:36:49 +08:00
|
|
|
return C->getValue()->getValue().countTrailingZeros();
|
teach scev to analyze X*4|1 like X*4+c. This allows us to produce:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
instead of:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
for a testcase.
llvm-svn: 32463
2006-12-12 10:26:09 +08:00
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVTruncateExpr *T = dyn_cast<SCEVTruncateExpr>(S))
|
2009-06-20 07:29:04 +08:00
|
|
|
return std::min(GetMinTrailingZeros(T->getOperand()),
|
|
|
|
(uint32_t)getTypeSizeInBits(T->getType()));
|
2007-11-22 15:59:40 +08:00
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVZeroExtendExpr *E = dyn_cast<SCEVZeroExtendExpr>(S)) {
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
|
|
|
|
return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
|
|
|
|
getTypeSizeInBits(E->getType()) : OpRes;
|
2007-11-22 15:59:40 +08:00
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVSignExtendExpr *E = dyn_cast<SCEVSignExtendExpr>(S)) {
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t OpRes = GetMinTrailingZeros(E->getOperand());
|
|
|
|
return OpRes == getTypeSizeInBits(E->getOperand()->getType()) ?
|
|
|
|
getTypeSizeInBits(E->getType()) : OpRes;
|
2007-11-22 15:59:40 +08:00
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddExpr *A = dyn_cast<SCEVAddExpr>(S)) {
|
2007-11-22 15:59:40 +08:00
|
|
|
// The result is the min of all operands results.
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
|
2007-11-22 15:59:40 +08:00
|
|
|
for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
|
2009-06-20 07:29:04 +08:00
|
|
|
MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
|
2007-11-22 15:59:40 +08:00
|
|
|
return MinOpRes;
|
teach scev to analyze X*4|1 like X*4+c. This allows us to produce:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
instead of:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
for a testcase.
llvm-svn: 32463
2006-12-12 10:26:09 +08:00
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
|
2007-11-22 15:59:40 +08:00
|
|
|
// The result is the sum of all operands results.
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t SumOpRes = GetMinTrailingZeros(M->getOperand(0));
|
|
|
|
uint32_t BitWidth = getTypeSizeInBits(M->getType());
|
2007-11-22 15:59:40 +08:00
|
|
|
for (unsigned i = 1, e = M->getNumOperands();
|
|
|
|
SumOpRes != BitWidth && i != e; ++i)
|
2009-06-20 07:29:04 +08:00
|
|
|
SumOpRes = std::min(SumOpRes + GetMinTrailingZeros(M->getOperand(i)),
|
2007-11-22 15:59:40 +08:00
|
|
|
BitWidth);
|
|
|
|
return SumOpRes;
|
teach scev to analyze X*4|1 like X*4+c. This allows us to produce:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
instead of:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
for a testcase.
llvm-svn: 32463
2006-12-12 10:26:09 +08:00
|
|
|
}
|
2007-11-22 15:59:40 +08:00
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(S)) {
|
2007-11-22 15:59:40 +08:00
|
|
|
// The result is the min of all operands results.
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t MinOpRes = GetMinTrailingZeros(A->getOperand(0));
|
2007-11-22 15:59:40 +08:00
|
|
|
for (unsigned i = 1, e = A->getNumOperands(); MinOpRes && i != e; ++i)
|
2009-06-20 07:29:04 +08:00
|
|
|
MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(A->getOperand(i)));
|
2007-11-22 15:59:40 +08:00
|
|
|
return MinOpRes;
|
teach scev to analyze X*4|1 like X*4+c. This allows us to produce:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
instead of:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
for a testcase.
llvm-svn: 32463
2006-12-12 10:26:09 +08:00
|
|
|
}
|
2007-11-22 15:59:40 +08:00
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVSMaxExpr *M = dyn_cast<SCEVSMaxExpr>(S)) {
|
2007-11-26 06:41:31 +08:00
|
|
|
// The result is the min of all operands results.
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
|
2007-11-26 06:41:31 +08:00
|
|
|
for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
|
2009-06-20 07:29:04 +08:00
|
|
|
MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
|
2007-11-26 06:41:31 +08:00
|
|
|
return MinOpRes;
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVUMaxExpr *M = dyn_cast<SCEVUMaxExpr>(S)) {
|
2008-02-20 14:48:22 +08:00
|
|
|
// The result is the min of all operands results.
|
2009-06-20 07:29:04 +08:00
|
|
|
uint32_t MinOpRes = GetMinTrailingZeros(M->getOperand(0));
|
2008-02-20 14:48:22 +08:00
|
|
|
for (unsigned i = 1, e = M->getNumOperands(); MinOpRes && i != e; ++i)
|
2009-06-20 07:29:04 +08:00
|
|
|
MinOpRes = std::min(MinOpRes, GetMinTrailingZeros(M->getOperand(i)));
|
2008-02-20 14:48:22 +08:00
|
|
|
return MinOpRes;
|
|
|
|
}
|
|
|
|
|
2009-06-20 07:29:04 +08:00
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
|
|
|
|
// For a SCEVUnknown, ask ValueTracking.
|
|
|
|
unsigned BitWidth = getTypeSizeInBits(U->getType());
|
|
|
|
APInt Mask = APInt::getAllOnesValue(BitWidth);
|
|
|
|
APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
|
|
|
|
ComputeMaskedBits(U->getValue(), Mask, Zeros, Ones);
|
|
|
|
return Zeros.countTrailingOnes();
|
|
|
|
}
|
|
|
|
|
|
|
|
// SCEVUDivExpr
|
2007-11-22 15:59:40 +08:00
|
|
|
return 0;
|
teach scev to analyze X*4|1 like X*4+c. This allows us to produce:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
instead of:
LBB1_1: #bb
movdqa (%esi), %xmm2
movaps %xmm2, %xmm3
punpcklbw %xmm0, %xmm3
movaps %xmm3, %xmm4
punpcklwd %xmm0, %xmm4
cvtdq2ps %xmm4, %xmm4
mulps %xmm1, %xmm4
movaps %xmm4, (%edi)
leal 1(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 2(,%eax,4), %ebx
shll $4, %ebx
punpckhbw %xmm0, %xmm2
movaps %xmm2, %xmm3
punpcklwd %xmm0, %xmm3
cvtdq2ps %xmm3, %xmm3
mulps %xmm1, %xmm3
movaps %xmm3, (%edx,%ebx)
leal 3(,%eax,4), %ebx
shll $4, %ebx
punpckhwd %xmm0, %xmm2
cvtdq2ps %xmm2, %xmm2
mulps %xmm1, %xmm2
movaps %xmm2, (%edx,%ebx)
addl $64, %edi
incl %eax
addl $16, %esi
cmpl %ecx, %eax
jne LBB1_1 #bb
for a testcase.
llvm-svn: 32463
2006-12-12 10:26:09 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
/// getUnsignedRange - Determine the unsigned range for a particular SCEV.
|
|
|
|
///
|
|
|
|
ConstantRange
|
|
|
|
ScalarEvolution::getUnsignedRange(const SCEV *S) {
|
2010-11-17 10:44:44 +08:00
|
|
|
// See if we've computed this range already.
|
|
|
|
DenseMap<const SCEV *, ConstantRange>::iterator I = UnsignedRanges.find(S);
|
|
|
|
if (I != UnsignedRanges.end())
|
|
|
|
return I->second;
|
2009-06-20 07:29:04 +08:00
|
|
|
|
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(C, ConstantRange(C->getValue()->getValue()));
|
2009-07-14 05:35:55 +08:00
|
|
|
|
2010-01-27 03:19:05 +08:00
|
|
|
unsigned BitWidth = getTypeSizeInBits(S->getType());
|
|
|
|
ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
|
|
|
|
|
|
|
|
// If the value has known zeros, the maximum unsigned value will have those
|
|
|
|
// known zeros as well.
|
|
|
|
uint32_t TZ = GetMinTrailingZeros(S);
|
|
|
|
if (TZ != 0)
|
|
|
|
ConservativeResult =
|
|
|
|
ConstantRange(APInt::getMinValue(BitWidth),
|
|
|
|
APInt::getMaxValue(BitWidth).lshr(TZ).shl(TZ) + 1);
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(Add->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = Add->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.add(getUnsignedRange(Add->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(Add, ConservativeResult.intersectWith(X));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(Mul->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = Mul->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.multiply(getUnsignedRange(Mul->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(Mul, ConservativeResult.intersectWith(X));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
2009-06-20 07:29:04 +08:00
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(SMax->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = SMax->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.smax(getUnsignedRange(SMax->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(SMax, ConservativeResult.intersectWith(X));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(UMax->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = UMax->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.umax(getUnsignedRange(UMax->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(UMax, ConservativeResult.intersectWith(X));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(UDiv->getLHS());
|
|
|
|
ConstantRange Y = getUnsignedRange(UDiv->getRHS());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(UDiv, ConservativeResult.intersectWith(X.udiv(Y)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(ZExt->getOperand());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(ZExt,
|
|
|
|
ConservativeResult.intersectWith(X.zeroExtend(BitWidth)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(SExt->getOperand());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(SExt,
|
|
|
|
ConservativeResult.intersectWith(X.signExtend(BitWidth)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(Trunc->getOperand());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(Trunc,
|
|
|
|
ConservativeResult.intersectWith(X.truncate(BitWidth)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
// If there's no unsigned wrap, the value will never be less than its
|
|
|
|
// initial value.
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AddRec->getNoWrapFlags(SCEV::FlagNUW))
|
2010-01-21 10:09:26 +08:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(AddRec->getStart()))
|
2010-04-13 07:08:18 +08:00
|
|
|
if (!C->getValue()->isZero())
|
2010-04-12 06:12:18 +08:00
|
|
|
ConservativeResult =
|
2010-06-30 14:58:35 +08:00
|
|
|
ConservativeResult.intersectWith(
|
|
|
|
ConstantRange(C->getValue()->getValue(), APInt(BitWidth, 0)));
|
2009-07-14 05:35:55 +08:00
|
|
|
|
|
|
|
// TODO: non-affine addrec
|
2010-01-27 03:19:05 +08:00
|
|
|
if (AddRec->isAffine()) {
|
2009-07-14 05:35:55 +08:00
|
|
|
const Type *Ty = AddRec->getType();
|
|
|
|
const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
|
2010-01-27 03:19:05 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(MaxBECount) &&
|
|
|
|
getTypeSizeInBits(MaxBECount->getType()) <= BitWidth) {
|
2009-07-14 05:35:55 +08:00
|
|
|
MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
|
|
|
|
|
|
|
|
const SCEV *Start = AddRec->getStart();
|
2010-04-12 15:39:33 +08:00
|
|
|
const SCEV *Step = AddRec->getStepRecurrence(*this);
|
2009-07-14 05:35:55 +08:00
|
|
|
|
2010-04-12 15:39:33 +08:00
|
|
|
ConstantRange StartRange = getUnsignedRange(Start);
|
|
|
|
ConstantRange StepRange = getSignedRange(Step);
|
|
|
|
ConstantRange MaxBECountRange = getUnsignedRange(MaxBECount);
|
|
|
|
ConstantRange EndRange =
|
|
|
|
StartRange.add(MaxBECountRange.multiply(StepRange));
|
|
|
|
|
|
|
|
// Check for overflow. This must be done with ConstantRange arithmetic
|
|
|
|
// because we could be called from within the ScalarEvolution overflow
|
|
|
|
// checking code.
|
|
|
|
ConstantRange ExtStartRange = StartRange.zextOrTrunc(BitWidth*2+1);
|
|
|
|
ConstantRange ExtStepRange = StepRange.sextOrTrunc(BitWidth*2+1);
|
|
|
|
ConstantRange ExtMaxBECountRange =
|
|
|
|
MaxBECountRange.zextOrTrunc(BitWidth*2+1);
|
|
|
|
ConstantRange ExtEndRange = EndRange.zextOrTrunc(BitWidth*2+1);
|
|
|
|
if (ExtStartRange.add(ExtMaxBECountRange.multiply(ExtStepRange)) !=
|
|
|
|
ExtEndRange)
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(AddRec, ConservativeResult);
|
2009-07-14 05:35:55 +08:00
|
|
|
|
|
|
|
APInt Min = APIntOps::umin(StartRange.getUnsignedMin(),
|
|
|
|
EndRange.getUnsignedMin());
|
|
|
|
APInt Max = APIntOps::umax(StartRange.getUnsignedMax(),
|
|
|
|
EndRange.getUnsignedMax());
|
|
|
|
if (Min.isMinValue() && Max.isMaxValue())
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(AddRec, ConservativeResult);
|
|
|
|
return setUnsignedRange(AddRec,
|
|
|
|
ConservativeResult.intersectWith(ConstantRange(Min, Max+1)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
}
|
2010-01-21 10:09:26 +08:00
|
|
|
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(AddRec, ConservativeResult);
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
|
|
|
|
// For a SCEVUnknown, ask ValueTracking.
|
|
|
|
APInt Mask = APInt::getAllOnesValue(BitWidth);
|
|
|
|
APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
|
|
|
|
ComputeMaskedBits(U->getValue(), Mask, Zeros, Ones, TD);
|
2009-07-21 06:34:18 +08:00
|
|
|
if (Ones == ~Zeros + 1)
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(U, ConservativeResult);
|
|
|
|
return setUnsignedRange(U,
|
|
|
|
ConservativeResult.intersectWith(ConstantRange(Ones, ~Zeros + 1)));
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
2010-11-18 04:23:08 +08:00
|
|
|
return setUnsignedRange(S, ConservativeResult);
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
/// getSignedRange - Determine the signed range for a particular SCEV.
|
|
|
|
///
|
|
|
|
ConstantRange
|
|
|
|
ScalarEvolution::getSignedRange(const SCEV *S) {
|
2011-01-25 01:54:18 +08:00
|
|
|
// See if we've computed this range already.
|
2010-11-17 10:44:44 +08:00
|
|
|
DenseMap<const SCEV *, ConstantRange>::iterator I = SignedRanges.find(S);
|
|
|
|
if (I != SignedRanges.end())
|
|
|
|
return I->second;
|
2009-07-11 00:42:52 +08:00
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(C, ConstantRange(C->getValue()->getValue()));
|
2009-07-14 05:35:55 +08:00
|
|
|
|
2010-01-26 12:40:18 +08:00
|
|
|
unsigned BitWidth = getTypeSizeInBits(S->getType());
|
|
|
|
ConstantRange ConservativeResult(BitWidth, /*isFullSet=*/true);
|
|
|
|
|
|
|
|
// If the value has known zeros, the maximum signed value will have those
|
|
|
|
// known zeros as well.
|
|
|
|
uint32_t TZ = GetMinTrailingZeros(S);
|
|
|
|
if (TZ != 0)
|
|
|
|
ConservativeResult =
|
|
|
|
ConstantRange(APInt::getSignedMinValue(BitWidth),
|
|
|
|
APInt::getSignedMaxValue(BitWidth).ashr(TZ).shl(TZ) + 1);
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(Add->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = Add->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.add(getSignedRange(Add->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(Add, ConservativeResult.intersectWith(X));
|
2009-07-11 00:42:52 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVMulExpr *Mul = dyn_cast<SCEVMulExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(Mul->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = Mul->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.multiply(getSignedRange(Mul->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(Mul, ConservativeResult.intersectWith(X));
|
2009-07-11 00:42:52 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVSMaxExpr *SMax = dyn_cast<SCEVSMaxExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(SMax->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = SMax->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.smax(getSignedRange(SMax->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(SMax, ConservativeResult.intersectWith(X));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
2009-07-12 04:38:25 +08:00
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVUMaxExpr *UMax = dyn_cast<SCEVUMaxExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(UMax->getOperand(0));
|
|
|
|
for (unsigned i = 1, e = UMax->getNumOperands(); i != e; ++i)
|
|
|
|
X = X.umax(getSignedRange(UMax->getOperand(i)));
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(UMax, ConservativeResult.intersectWith(X));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(UDiv->getLHS());
|
|
|
|
ConstantRange Y = getSignedRange(UDiv->getRHS());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(UDiv, ConservativeResult.intersectWith(X.udiv(Y)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(ZExt->getOperand());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(ZExt,
|
|
|
|
ConservativeResult.intersectWith(X.zeroExtend(BitWidth)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(SExt->getOperand());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(SExt,
|
|
|
|
ConservativeResult.intersectWith(X.signExtend(BitWidth)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(Trunc->getOperand());
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(Trunc,
|
|
|
|
ConservativeResult.intersectWith(X.truncate(BitWidth)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
// If there's no signed wrap, and all the operands have the same sign or
|
|
|
|
// zero, the value won't ever change sign.
|
2011-03-15 00:50:06 +08:00
|
|
|
if (AddRec->getNoWrapFlags(SCEV::FlagNSW)) {
|
2010-01-21 10:09:26 +08:00
|
|
|
bool AllNonNeg = true;
|
|
|
|
bool AllNonPos = true;
|
|
|
|
for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
|
|
|
|
if (!isKnownNonNegative(AddRec->getOperand(i))) AllNonNeg = false;
|
|
|
|
if (!isKnownNonPositive(AddRec->getOperand(i))) AllNonPos = false;
|
|
|
|
}
|
|
|
|
if (AllNonNeg)
|
2010-01-26 12:40:18 +08:00
|
|
|
ConservativeResult = ConservativeResult.intersectWith(
|
|
|
|
ConstantRange(APInt(BitWidth, 0),
|
|
|
|
APInt::getSignedMinValue(BitWidth)));
|
2010-01-21 10:09:26 +08:00
|
|
|
else if (AllNonPos)
|
2010-01-26 12:40:18 +08:00
|
|
|
ConservativeResult = ConservativeResult.intersectWith(
|
|
|
|
ConstantRange(APInt::getSignedMinValue(BitWidth),
|
|
|
|
APInt(BitWidth, 1)));
|
2010-01-21 10:09:26 +08:00
|
|
|
}
|
2009-07-14 05:35:55 +08:00
|
|
|
|
|
|
|
// TODO: non-affine addrec
|
2010-01-27 03:19:05 +08:00
|
|
|
if (AddRec->isAffine()) {
|
2009-07-14 05:35:55 +08:00
|
|
|
const Type *Ty = AddRec->getType();
|
|
|
|
const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
|
2010-01-27 03:19:05 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(MaxBECount) &&
|
|
|
|
getTypeSizeInBits(MaxBECount->getType()) <= BitWidth) {
|
2009-07-14 05:35:55 +08:00
|
|
|
MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
|
|
|
|
|
|
|
|
const SCEV *Start = AddRec->getStart();
|
2010-04-12 15:39:33 +08:00
|
|
|
const SCEV *Step = AddRec->getStepRecurrence(*this);
|
2009-07-14 05:35:55 +08:00
|
|
|
|
2010-04-12 15:39:33 +08:00
|
|
|
ConstantRange StartRange = getSignedRange(Start);
|
|
|
|
ConstantRange StepRange = getSignedRange(Step);
|
|
|
|
ConstantRange MaxBECountRange = getUnsignedRange(MaxBECount);
|
|
|
|
ConstantRange EndRange =
|
|
|
|
StartRange.add(MaxBECountRange.multiply(StepRange));
|
|
|
|
|
|
|
|
// Check for overflow. This must be done with ConstantRange arithmetic
|
|
|
|
// because we could be called from within the ScalarEvolution overflow
|
|
|
|
// checking code.
|
|
|
|
ConstantRange ExtStartRange = StartRange.sextOrTrunc(BitWidth*2+1);
|
|
|
|
ConstantRange ExtStepRange = StepRange.sextOrTrunc(BitWidth*2+1);
|
|
|
|
ConstantRange ExtMaxBECountRange =
|
|
|
|
MaxBECountRange.zextOrTrunc(BitWidth*2+1);
|
|
|
|
ConstantRange ExtEndRange = EndRange.sextOrTrunc(BitWidth*2+1);
|
|
|
|
if (ExtStartRange.add(ExtMaxBECountRange.multiply(ExtStepRange)) !=
|
|
|
|
ExtEndRange)
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(AddRec, ConservativeResult);
|
2009-07-14 05:35:55 +08:00
|
|
|
|
|
|
|
APInt Min = APIntOps::smin(StartRange.getSignedMin(),
|
|
|
|
EndRange.getSignedMin());
|
|
|
|
APInt Max = APIntOps::smax(StartRange.getSignedMax(),
|
|
|
|
EndRange.getSignedMax());
|
|
|
|
if (Min.isMinSignedValue() && Max.isMaxSignedValue())
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(AddRec, ConservativeResult);
|
|
|
|
return setSignedRange(AddRec,
|
|
|
|
ConservativeResult.intersectWith(ConstantRange(Min, Max+1)));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
2009-06-24 09:05:09 +08:00
|
|
|
}
|
2010-01-21 10:09:26 +08:00
|
|
|
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(AddRec, ConservativeResult);
|
2009-06-24 09:05:09 +08:00
|
|
|
}
|
|
|
|
|
2009-06-20 07:29:04 +08:00
|
|
|
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(S)) {
|
|
|
|
// For a SCEVUnknown, ask ValueTracking.
|
2010-02-16 00:12:20 +08:00
|
|
|
if (!U->getValue()->getType()->isIntegerTy() && !TD)
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(U, ConservativeResult);
|
2009-07-14 05:35:55 +08:00
|
|
|
unsigned NS = ComputeNumSignBits(U->getValue(), TD);
|
|
|
|
if (NS == 1)
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(U, ConservativeResult);
|
|
|
|
return setSignedRange(U, ConservativeResult.intersectWith(
|
2009-07-14 05:35:55 +08:00
|
|
|
ConstantRange(APInt::getSignedMinValue(BitWidth).ashr(NS - 1),
|
2010-11-18 04:23:08 +08:00
|
|
|
APInt::getSignedMaxValue(BitWidth).ashr(NS - 1)+1)));
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
2010-11-18 04:23:08 +08:00
|
|
|
return setSignedRange(S, ConservativeResult);
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
/// createSCEV - We know that there is no SCEV for the specified value.
|
|
|
|
/// Analyze the expression.
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::createSCEV(Value *V) {
|
2009-04-21 09:07:12 +08:00
|
|
|
if (!isSCEVable(V->getType()))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUnknown(V);
|
2009-04-16 11:18:22 +08:00
|
|
|
|
2008-06-23 03:56:46 +08:00
|
|
|
unsigned Opcode = Instruction::UserOp1;
|
2010-03-10 07:46:50 +08:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(V)) {
|
2008-06-23 03:56:46 +08:00
|
|
|
Opcode = I->getOpcode();
|
2010-03-10 07:46:50 +08:00
|
|
|
|
|
|
|
// Don't attempt to analyze instructions in blocks that aren't
|
|
|
|
// reachable. Such instructions don't matter, and they aren't required
|
|
|
|
// to obey basic rules for definitions dominating uses which this
|
|
|
|
// analysis depends on.
|
|
|
|
if (!DT->isReachableFromEntry(I->getParent()))
|
|
|
|
return getUnknown(V);
|
|
|
|
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
|
2008-06-23 03:56:46 +08:00
|
|
|
Opcode = CE->getOpcode();
|
2009-06-24 08:54:57 +08:00
|
|
|
else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
|
|
|
|
return getConstant(CI);
|
|
|
|
else if (isa<ConstantPointerNull>(V))
|
2010-05-04 06:09:21 +08:00
|
|
|
return getConstant(V->getType(), 0);
|
2009-08-26 01:49:57 +08:00
|
|
|
else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
|
|
|
|
return GA->mayBeOverridden() ? getUnknown(V) : getSCEV(GA->getAliasee());
|
2008-06-23 03:56:46 +08:00
|
|
|
else
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUnknown(V);
|
2007-11-26 06:41:31 +08:00
|
|
|
|
2009-07-18 04:47:02 +08:00
|
|
|
Operator *U = cast<Operator>(V);
|
2008-06-23 03:56:46 +08:00
|
|
|
switch (Opcode) {
|
2010-08-17 00:03:49 +08:00
|
|
|
case Instruction::Add: {
|
|
|
|
// The simple thing to do would be to just call getSCEV on both operands
|
|
|
|
// and call getAddExpr with the result. However if we're looking at a
|
|
|
|
// bunch of things all added together, this can be quite inefficient,
|
|
|
|
// because it leads to N-1 getAddExpr calls for N ultimate operands.
|
|
|
|
// Instead, gather up all the operands and make a single getAddExpr call.
|
|
|
|
// LLVM IR canonical form means we need only traverse the left operands.
|
|
|
|
SmallVector<const SCEV *, 4> AddOps;
|
|
|
|
AddOps.push_back(getSCEV(U->getOperand(1)));
|
2010-09-01 06:53:17 +08:00
|
|
|
for (Value *Op = U->getOperand(0); ; Op = U->getOperand(0)) {
|
|
|
|
unsigned Opcode = Op->getValueID() - Value::InstructionVal;
|
|
|
|
if (Opcode != Instruction::Add && Opcode != Instruction::Sub)
|
|
|
|
break;
|
2010-08-17 00:03:49 +08:00
|
|
|
U = cast<Operator>(Op);
|
2010-09-01 06:53:17 +08:00
|
|
|
const SCEV *Op1 = getSCEV(U->getOperand(1));
|
|
|
|
if (Opcode == Instruction::Sub)
|
|
|
|
AddOps.push_back(getNegativeSCEV(Op1));
|
|
|
|
else
|
|
|
|
AddOps.push_back(Op1);
|
2010-08-17 00:03:49 +08:00
|
|
|
}
|
|
|
|
AddOps.push_back(getSCEV(U->getOperand(0)));
|
|
|
|
return getAddExpr(AddOps);
|
|
|
|
}
|
|
|
|
case Instruction::Mul: {
|
|
|
|
// See the Add code above.
|
|
|
|
SmallVector<const SCEV *, 4> MulOps;
|
|
|
|
MulOps.push_back(getSCEV(U->getOperand(1)));
|
|
|
|
for (Value *Op = U->getOperand(0);
|
2011-03-10 01:23:39 +08:00
|
|
|
Op->getValueID() == Instruction::Mul + Value::InstructionVal;
|
2010-08-17 00:03:49 +08:00
|
|
|
Op = U->getOperand(0)) {
|
|
|
|
U = cast<Operator>(Op);
|
|
|
|
MulOps.push_back(getSCEV(U->getOperand(1)));
|
|
|
|
}
|
|
|
|
MulOps.push_back(getSCEV(U->getOperand(0)));
|
|
|
|
return getMulExpr(MulOps);
|
|
|
|
}
|
2008-06-23 03:56:46 +08:00
|
|
|
case Instruction::UDiv:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUDivExpr(getSCEV(U->getOperand(0)),
|
|
|
|
getSCEV(U->getOperand(1)));
|
2008-06-23 03:56:46 +08:00
|
|
|
case Instruction::Sub:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getMinusSCEV(getSCEV(U->getOperand(0)),
|
|
|
|
getSCEV(U->getOperand(1)));
|
2009-04-21 10:26:00 +08:00
|
|
|
case Instruction::And:
|
|
|
|
// For an expression like x&255 that merely masks off the high bits,
|
|
|
|
// use zext(trunc(x)) as the SCEV expression.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
|
2009-04-26 01:05:40 +08:00
|
|
|
if (CI->isNullValue())
|
|
|
|
return getSCEV(U->getOperand(1));
|
2009-04-27 09:41:10 +08:00
|
|
|
if (CI->isAllOnesValue())
|
|
|
|
return getSCEV(U->getOperand(0));
|
2009-04-21 10:26:00 +08:00
|
|
|
const APInt &A = CI->getValue();
|
2009-06-17 03:52:01 +08:00
|
|
|
|
|
|
|
// Instcombine's ShrinkDemandedConstant may strip bits out of
|
|
|
|
// constants, obscuring what would otherwise be a low-bits mask.
|
|
|
|
// Use ComputeMaskedBits to compute what ShrinkDemandedConstant
|
|
|
|
// knew about to reconstruct a low-bits mask value.
|
|
|
|
unsigned LZ = A.countLeadingZeros();
|
|
|
|
unsigned BitWidth = A.getBitWidth();
|
|
|
|
APInt AllOnes = APInt::getAllOnesValue(BitWidth);
|
|
|
|
APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
|
|
|
|
ComputeMaskedBits(U->getOperand(0), AllOnes, KnownZero, KnownOne, TD);
|
|
|
|
|
|
|
|
APInt EffectiveMask = APInt::getLowBitsSet(BitWidth, BitWidth - LZ);
|
|
|
|
|
2009-06-18 07:54:37 +08:00
|
|
|
if (LZ != 0 && !((~A & ~KnownZero) & EffectiveMask))
|
2009-04-21 10:26:00 +08:00
|
|
|
return
|
2009-04-22 07:15:49 +08:00
|
|
|
getZeroExtendExpr(getTruncateExpr(getSCEV(U->getOperand(0)),
|
2009-08-14 05:58:54 +08:00
|
|
|
IntegerType::get(getContext(), BitWidth - LZ)),
|
2009-04-22 07:15:49 +08:00
|
|
|
U->getType());
|
2009-04-21 10:26:00 +08:00
|
|
|
}
|
|
|
|
break;
|
2009-06-17 03:52:01 +08:00
|
|
|
|
2008-06-23 03:56:46 +08:00
|
|
|
case Instruction::Or:
|
|
|
|
// If the RHS of the Or is a constant, we may have something like:
|
|
|
|
// X*4+1 which got turned into X*4|1. Handle this as an Add so loop
|
|
|
|
// optimizations will transparently handle this case.
|
|
|
|
//
|
|
|
|
// In order for this transformation to be safe, the LHS must be of the
|
|
|
|
// form X*(2^n) and the Or constant must be less than 2^n.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *LHS = getSCEV(U->getOperand(0));
|
2008-06-23 03:56:46 +08:00
|
|
|
const APInt &CIVal = CI->getValue();
|
2009-06-20 07:29:04 +08:00
|
|
|
if (GetMinTrailingZeros(LHS) >=
|
2009-09-18 02:05:20 +08:00
|
|
|
(CIVal.getBitWidth() - CIVal.countLeadingZeros())) {
|
|
|
|
// Build a plain add SCEV.
|
|
|
|
const SCEV *S = getAddExpr(LHS, getSCEV(CI));
|
|
|
|
// If the LHS of the add was an addrec and it has no-wrap flags,
|
|
|
|
// transfer the no-wrap flags, since an or won't introduce a wrap.
|
|
|
|
if (const SCEVAddRecExpr *NewAR = dyn_cast<SCEVAddRecExpr>(S)) {
|
|
|
|
const SCEVAddRecExpr *OldAR = cast<SCEVAddRecExpr>(LHS);
|
2011-03-15 00:50:06 +08:00
|
|
|
const_cast<SCEVAddRecExpr *>(NewAR)->setNoWrapFlags(
|
|
|
|
OldAR->getNoWrapFlags());
|
2009-09-18 02:05:20 +08:00
|
|
|
}
|
|
|
|
return S;
|
|
|
|
}
|
2008-06-23 03:56:46 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Instruction::Xor:
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
|
2008-07-07 14:15:49 +08:00
|
|
|
// If the RHS of the xor is a signbit, then this is just an add.
|
|
|
|
// Instcombine turns add of signbit into xor as a strength reduction step.
|
2008-06-23 03:56:46 +08:00
|
|
|
if (CI->getValue().isSignBit())
|
2009-04-22 07:15:49 +08:00
|
|
|
return getAddExpr(getSCEV(U->getOperand(0)),
|
|
|
|
getSCEV(U->getOperand(1)));
|
2008-07-07 14:15:49 +08:00
|
|
|
|
|
|
|
// If the RHS of xor is -1, then this is a not operation.
|
2009-05-19 00:17:44 +08:00
|
|
|
if (CI->isAllOnesValue())
|
2009-04-22 07:15:49 +08:00
|
|
|
return getNotSCEV(getSCEV(U->getOperand(0)));
|
2009-05-19 00:29:04 +08:00
|
|
|
|
|
|
|
// Model xor(and(x, C), C) as and(~x, C), if C is a low-bits mask.
|
|
|
|
// This is a variant of the check for xor with -1, and it handles
|
|
|
|
// the case where instcombine has trimmed non-demanded bits out
|
|
|
|
// of an xor with -1.
|
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(U->getOperand(0)))
|
|
|
|
if (ConstantInt *LCI = dyn_cast<ConstantInt>(BO->getOperand(1)))
|
|
|
|
if (BO->getOpcode() == Instruction::And &&
|
|
|
|
LCI->getValue() == CI->getValue())
|
|
|
|
if (const SCEVZeroExtendExpr *Z =
|
2009-06-17 09:22:39 +08:00
|
|
|
dyn_cast<SCEVZeroExtendExpr>(getSCEV(U->getOperand(0)))) {
|
2009-06-18 08:00:20 +08:00
|
|
|
const Type *UTy = U->getType();
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Z0 = Z->getOperand();
|
2009-06-18 08:00:20 +08:00
|
|
|
const Type *Z0Ty = Z0->getType();
|
|
|
|
unsigned Z0TySize = getTypeSizeInBits(Z0Ty);
|
|
|
|
|
2010-03-02 01:49:51 +08:00
|
|
|
// If C is a low-bits mask, the zero extend is serving to
|
2009-06-18 08:00:20 +08:00
|
|
|
// mask off the high bits. Complement the operand and
|
|
|
|
// re-apply the zext.
|
|
|
|
if (APIntOps::isMask(Z0TySize, CI->getValue()))
|
|
|
|
return getZeroExtendExpr(getNotSCEV(Z0), UTy);
|
|
|
|
|
|
|
|
// If C is a single bit, it may be in the sign-bit position
|
|
|
|
// before the zero-extend. In this case, represent the xor
|
|
|
|
// using an add, which is equivalent, and re-apply the zext.
|
2010-12-07 16:25:19 +08:00
|
|
|
APInt Trunc = CI->getValue().trunc(Z0TySize);
|
|
|
|
if (Trunc.zext(getTypeSizeInBits(UTy)) == CI->getValue() &&
|
2009-06-18 08:00:20 +08:00
|
|
|
Trunc.isSignBit())
|
|
|
|
return getZeroExtendExpr(getAddExpr(Z0, getConstant(Trunc)),
|
|
|
|
UTy);
|
2009-06-17 09:22:39 +08:00
|
|
|
}
|
2008-06-23 03:56:46 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Instruction::Shl:
|
|
|
|
// Turn shift left of a constant amount into a multiply.
|
|
|
|
if (ConstantInt *SA = dyn_cast<ConstantInt>(U->getOperand(1))) {
|
2010-02-02 02:27:38 +08:00
|
|
|
uint32_t BitWidth = cast<IntegerType>(U->getType())->getBitWidth();
|
2010-04-22 09:35:11 +08:00
|
|
|
|
|
|
|
// If the shift count is not less than the bitwidth, the result of
|
|
|
|
// the shift is undefined. Don't try to analyze it, because the
|
|
|
|
// resolution chosen here may differ from the resolution chosen in
|
|
|
|
// other parts of the compiler.
|
|
|
|
if (SA->getValue().uge(BitWidth))
|
|
|
|
break;
|
|
|
|
|
2009-07-25 07:12:02 +08:00
|
|
|
Constant *X = ConstantInt::get(getContext(),
|
2010-04-22 09:35:11 +08:00
|
|
|
APInt(BitWidth, 1).shl(SA->getZExtValue()));
|
2009-04-22 07:15:49 +08:00
|
|
|
return getMulExpr(getSCEV(U->getOperand(0)), getSCEV(X));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2008-06-23 03:56:46 +08:00
|
|
|
break;
|
|
|
|
|
2008-07-07 14:15:49 +08:00
|
|
|
case Instruction::LShr:
|
2009-01-13 17:18:58 +08:00
|
|
|
// Turn logical shift right of a constant into a unsigned divide.
|
2008-07-07 14:15:49 +08:00
|
|
|
if (ConstantInt *SA = dyn_cast<ConstantInt>(U->getOperand(1))) {
|
2010-02-02 02:27:38 +08:00
|
|
|
uint32_t BitWidth = cast<IntegerType>(U->getType())->getBitWidth();
|
2010-04-22 09:35:11 +08:00
|
|
|
|
|
|
|
// If the shift count is not less than the bitwidth, the result of
|
|
|
|
// the shift is undefined. Don't try to analyze it, because the
|
|
|
|
// resolution chosen here may differ from the resolution chosen in
|
|
|
|
// other parts of the compiler.
|
|
|
|
if (SA->getValue().uge(BitWidth))
|
|
|
|
break;
|
|
|
|
|
2009-07-25 07:12:02 +08:00
|
|
|
Constant *X = ConstantInt::get(getContext(),
|
2010-04-22 09:35:11 +08:00
|
|
|
APInt(BitWidth, 1).shl(SA->getZExtValue()));
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUDivExpr(getSCEV(U->getOperand(0)), getSCEV(X));
|
2008-07-07 14:15:49 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2009-04-21 10:26:00 +08:00
|
|
|
case Instruction::AShr:
|
|
|
|
// For a two-shift sext-inreg, use sext(trunc(x)) as the SCEV expression.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1)))
|
2010-04-22 09:35:11 +08:00
|
|
|
if (Operator *L = dyn_cast<Operator>(U->getOperand(0)))
|
2009-04-21 10:26:00 +08:00
|
|
|
if (L->getOpcode() == Instruction::Shl &&
|
|
|
|
L->getOperand(1) == U->getOperand(1)) {
|
2010-04-22 09:35:11 +08:00
|
|
|
uint64_t BitWidth = getTypeSizeInBits(U->getType());
|
|
|
|
|
|
|
|
// If the shift count is not less than the bitwidth, the result of
|
|
|
|
// the shift is undefined. Don't try to analyze it, because the
|
|
|
|
// resolution chosen here may differ from the resolution chosen in
|
|
|
|
// other parts of the compiler.
|
|
|
|
if (CI->getValue().uge(BitWidth))
|
|
|
|
break;
|
|
|
|
|
2009-04-26 01:05:40 +08:00
|
|
|
uint64_t Amt = BitWidth - CI->getZExtValue();
|
|
|
|
if (Amt == BitWidth)
|
|
|
|
return getSCEV(L->getOperand(0)); // shift by zero --> noop
|
2009-04-21 10:26:00 +08:00
|
|
|
return
|
2009-04-22 07:15:49 +08:00
|
|
|
getSignExtendExpr(getTruncateExpr(getSCEV(L->getOperand(0)),
|
2010-04-22 09:35:11 +08:00
|
|
|
IntegerType::get(getContext(),
|
|
|
|
Amt)),
|
|
|
|
U->getType());
|
2009-04-21 10:26:00 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2008-06-23 03:56:46 +08:00
|
|
|
case Instruction::Trunc:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getTruncateExpr(getSCEV(U->getOperand(0)), U->getType());
|
2008-06-23 03:56:46 +08:00
|
|
|
|
|
|
|
case Instruction::ZExt:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getZeroExtendExpr(getSCEV(U->getOperand(0)), U->getType());
|
2008-06-23 03:56:46 +08:00
|
|
|
|
|
|
|
case Instruction::SExt:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getSignExtendExpr(getSCEV(U->getOperand(0)), U->getType());
|
2008-06-23 03:56:46 +08:00
|
|
|
|
|
|
|
case Instruction::BitCast:
|
|
|
|
// BitCasts are no-op casts so we just eliminate the cast.
|
2009-04-21 09:07:12 +08:00
|
|
|
if (isSCEVable(U->getType()) && isSCEVable(U->getOperand(0)->getType()))
|
2008-06-23 03:56:46 +08:00
|
|
|
return getSCEV(U->getOperand(0));
|
|
|
|
break;
|
|
|
|
|
2010-02-02 02:27:38 +08:00
|
|
|
// It's tempting to handle inttoptr and ptrtoint as no-ops, however this can
|
|
|
|
// lead to pointer expressions which cannot safely be expanded to GEPs,
|
|
|
|
// because ScalarEvolution doesn't respect the GEP aliasing rules when
|
|
|
|
// simplifying integer expressions.
|
2009-04-16 11:18:22 +08:00
|
|
|
|
2009-05-09 04:26:55 +08:00
|
|
|
case Instruction::GetElementPtr:
|
2009-12-18 10:09:29 +08:00
|
|
|
return createNodeForGEP(cast<GEPOperator>(U));
|
2009-04-16 11:18:22 +08:00
|
|
|
|
2008-06-23 03:56:46 +08:00
|
|
|
case Instruction::PHI:
|
|
|
|
return createNodeForPHI(cast<PHINode>(U));
|
|
|
|
|
|
|
|
case Instruction::Select:
|
|
|
|
// This could be a smax or umax that was lowered earlier.
|
|
|
|
// Try to recover it.
|
|
|
|
if (ICmpInst *ICI = dyn_cast<ICmpInst>(U->getOperand(0))) {
|
|
|
|
Value *LHS = ICI->getOperand(0);
|
|
|
|
Value *RHS = ICI->getOperand(1);
|
|
|
|
switch (ICI->getPredicate()) {
|
|
|
|
case ICmpInst::ICMP_SLT:
|
|
|
|
case ICmpInst::ICMP_SLE:
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
// fall through
|
|
|
|
case ICmpInst::ICMP_SGT:
|
|
|
|
case ICmpInst::ICMP_SGE:
|
2010-04-24 11:09:42 +08:00
|
|
|
// a >s b ? a+x : b+x -> smax(a, b)+x
|
|
|
|
// a >s b ? b+x : a+x -> smin(a, b)+x
|
|
|
|
if (LHS->getType() == U->getType()) {
|
|
|
|
const SCEV *LS = getSCEV(LHS);
|
|
|
|
const SCEV *RS = getSCEV(RHS);
|
|
|
|
const SCEV *LA = getSCEV(U->getOperand(1));
|
|
|
|
const SCEV *RA = getSCEV(U->getOperand(2));
|
|
|
|
const SCEV *LDiff = getMinusSCEV(LA, LS);
|
|
|
|
const SCEV *RDiff = getMinusSCEV(RA, RS);
|
|
|
|
if (LDiff == RDiff)
|
|
|
|
return getAddExpr(getSMaxExpr(LS, RS), LDiff);
|
|
|
|
LDiff = getMinusSCEV(LA, RS);
|
|
|
|
RDiff = getMinusSCEV(RA, LS);
|
|
|
|
if (LDiff == RDiff)
|
|
|
|
return getAddExpr(getSMinExpr(LS, RS), LDiff);
|
|
|
|
}
|
2008-06-23 03:56:46 +08:00
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULT:
|
|
|
|
case ICmpInst::ICMP_ULE:
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
// fall through
|
|
|
|
case ICmpInst::ICMP_UGT:
|
|
|
|
case ICmpInst::ICMP_UGE:
|
2010-04-24 11:09:42 +08:00
|
|
|
// a >u b ? a+x : b+x -> umax(a, b)+x
|
|
|
|
// a >u b ? b+x : a+x -> umin(a, b)+x
|
|
|
|
if (LHS->getType() == U->getType()) {
|
|
|
|
const SCEV *LS = getSCEV(LHS);
|
|
|
|
const SCEV *RS = getSCEV(RHS);
|
|
|
|
const SCEV *LA = getSCEV(U->getOperand(1));
|
|
|
|
const SCEV *RA = getSCEV(U->getOperand(2));
|
|
|
|
const SCEV *LDiff = getMinusSCEV(LA, LS);
|
|
|
|
const SCEV *RDiff = getMinusSCEV(RA, RS);
|
|
|
|
if (LDiff == RDiff)
|
|
|
|
return getAddExpr(getUMaxExpr(LS, RS), LDiff);
|
|
|
|
LDiff = getMinusSCEV(LA, RS);
|
|
|
|
RDiff = getMinusSCEV(RA, LS);
|
|
|
|
if (LDiff == RDiff)
|
|
|
|
return getAddExpr(getUMinExpr(LS, RS), LDiff);
|
|
|
|
}
|
2008-06-23 03:56:46 +08:00
|
|
|
break;
|
2009-06-19 04:21:07 +08:00
|
|
|
case ICmpInst::ICMP_NE:
|
2010-04-24 11:09:42 +08:00
|
|
|
// n != 0 ? n+x : 1+x -> umax(n, 1)+x
|
|
|
|
if (LHS->getType() == U->getType() &&
|
2009-06-19 04:21:07 +08:00
|
|
|
isa<ConstantInt>(RHS) &&
|
2010-04-24 11:09:42 +08:00
|
|
|
cast<ConstantInt>(RHS)->isZero()) {
|
|
|
|
const SCEV *One = getConstant(LHS->getType(), 1);
|
|
|
|
const SCEV *LS = getSCEV(LHS);
|
|
|
|
const SCEV *LA = getSCEV(U->getOperand(1));
|
|
|
|
const SCEV *RA = getSCEV(U->getOperand(2));
|
|
|
|
const SCEV *LDiff = getMinusSCEV(LA, LS);
|
|
|
|
const SCEV *RDiff = getMinusSCEV(RA, One);
|
|
|
|
if (LDiff == RDiff)
|
2010-08-14 04:17:14 +08:00
|
|
|
return getAddExpr(getUMaxExpr(One, LS), LDiff);
|
2010-04-24 11:09:42 +08:00
|
|
|
}
|
2009-06-19 04:21:07 +08:00
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_EQ:
|
2010-04-24 11:09:42 +08:00
|
|
|
// n == 0 ? 1+x : n+x -> umax(n, 1)+x
|
|
|
|
if (LHS->getType() == U->getType() &&
|
2009-06-19 04:21:07 +08:00
|
|
|
isa<ConstantInt>(RHS) &&
|
2010-04-24 11:09:42 +08:00
|
|
|
cast<ConstantInt>(RHS)->isZero()) {
|
|
|
|
const SCEV *One = getConstant(LHS->getType(), 1);
|
|
|
|
const SCEV *LS = getSCEV(LHS);
|
|
|
|
const SCEV *LA = getSCEV(U->getOperand(1));
|
|
|
|
const SCEV *RA = getSCEV(U->getOperand(2));
|
|
|
|
const SCEV *LDiff = getMinusSCEV(LA, One);
|
|
|
|
const SCEV *RDiff = getMinusSCEV(RA, LS);
|
|
|
|
if (LDiff == RDiff)
|
2010-08-14 04:17:14 +08:00
|
|
|
return getAddExpr(getUMaxExpr(One, LS), LDiff);
|
2010-04-24 11:09:42 +08:00
|
|
|
}
|
2009-06-19 04:21:07 +08:00
|
|
|
break;
|
2008-06-23 03:56:46 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
default: // We cannot analyze this expression.
|
|
|
|
break;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUnknown(V);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Iteration Count Computation Code
|
|
|
|
//
|
|
|
|
|
2009-02-25 02:55:53 +08:00
|
|
|
/// getBackedgeTakenCount - If the specified loop has a predictable
|
|
|
|
/// backedge-taken count, return it, otherwise return a SCEVCouldNotCompute
|
|
|
|
/// object. The backedge-taken count is the number of times the loop header
|
|
|
|
/// will be branched to from within the loop. This is one less than the
|
|
|
|
/// trip count of the loop, since it doesn't count the first iteration,
|
|
|
|
/// when the header is branched to from outside the loop.
|
|
|
|
///
|
|
|
|
/// Note that it is not valid to call this method on a loop without a
|
|
|
|
/// loop-invariant backedge-taken count (see
|
|
|
|
/// hasLoopInvariantBackedgeTakenCount).
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getBackedgeTakenCount(const Loop *L) {
|
2009-05-01 04:47:05 +08:00
|
|
|
return getBackedgeTakenInfo(L).Exact;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getMaxBackedgeTakenCount - Similar to getBackedgeTakenCount, except
|
|
|
|
/// return the least SCEV value that is known never to be less than the
|
|
|
|
/// actual backedge taken count.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getMaxBackedgeTakenCount(const Loop *L) {
|
2009-05-01 04:47:05 +08:00
|
|
|
return getBackedgeTakenInfo(L).Max;
|
|
|
|
}
|
|
|
|
|
2009-07-09 03:23:34 +08:00
|
|
|
/// PushLoopPHIs - Push PHI nodes in the header of the given loop
|
|
|
|
/// onto the given Worklist.
|
|
|
|
static void
|
|
|
|
PushLoopPHIs(const Loop *L, SmallVectorImpl<Instruction *> &Worklist) {
|
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
|
|
|
|
// Push all Loop-header PHIs onto the Worklist stack.
|
|
|
|
for (BasicBlock::iterator I = Header->begin();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(I); ++I)
|
|
|
|
Worklist.push_back(PN);
|
|
|
|
}
|
|
|
|
|
2009-05-01 04:47:05 +08:00
|
|
|
const ScalarEvolution::BackedgeTakenInfo &
|
|
|
|
ScalarEvolution::getBackedgeTakenInfo(const Loop *L) {
|
2009-04-28 04:16:15 +08:00
|
|
|
// Initially insert a CouldNotCompute for this loop. If the insertion
|
2010-03-02 01:49:51 +08:00
|
|
|
// succeeds, proceed to actually compute a backedge-taken count and
|
2009-04-28 04:16:15 +08:00
|
|
|
// update the value. The temporary CouldNotCompute value tells SCEV
|
|
|
|
// code elsewhere that it shouldn't attempt to request a new
|
|
|
|
// backedge-taken count, which could result in infinite recursion.
|
2009-12-18 09:14:11 +08:00
|
|
|
std::pair<std::map<const Loop *, BackedgeTakenInfo>::iterator, bool> Pair =
|
2009-04-28 04:16:15 +08:00
|
|
|
BackedgeTakenCounts.insert(std::make_pair(L, getCouldNotCompute()));
|
2011-01-09 10:16:18 +08:00
|
|
|
if (!Pair.second)
|
|
|
|
return Pair.first->second;
|
|
|
|
|
|
|
|
BackedgeTakenInfo BECount = ComputeBackedgeTakenCount(L);
|
|
|
|
if (BECount.Exact != getCouldNotCompute()) {
|
|
|
|
assert(isLoopInvariant(BECount.Exact, L) &&
|
|
|
|
isLoopInvariant(BECount.Max, L) &&
|
|
|
|
"Computed backedge-taken count isn't loop invariant for loop!");
|
|
|
|
++NumTripCountsComputed;
|
|
|
|
|
|
|
|
// Update the value in the map.
|
|
|
|
Pair.first->second = BECount;
|
|
|
|
} else {
|
|
|
|
if (BECount.Max != getCouldNotCompute())
|
2009-04-28 04:16:15 +08:00
|
|
|
// Update the value in the map.
|
2010-01-27 00:46:18 +08:00
|
|
|
Pair.first->second = BECount;
|
2011-01-09 10:16:18 +08:00
|
|
|
if (isa<PHINode>(L->getHeader()->begin()))
|
|
|
|
// Only count loops that have phi nodes as not being computable.
|
|
|
|
++NumTripCountsNotComputed;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we know more about the trip count for this loop, forget any
|
|
|
|
// existing SCEV values for PHI nodes in this loop since they are only
|
|
|
|
// conservative estimates made without the benefit of trip count
|
|
|
|
// information. This is similar to the code in forgetLoop, except that
|
|
|
|
// it handles SCEVUnknown PHI nodes specially.
|
|
|
|
if (BECount.hasAnyInfo()) {
|
|
|
|
SmallVector<Instruction *, 16> Worklist;
|
|
|
|
PushLoopPHIs(L, Worklist);
|
|
|
|
|
|
|
|
SmallPtrSet<Instruction *, 8> Visited;
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Instruction *I = Worklist.pop_back_val();
|
|
|
|
if (!Visited.insert(I)) continue;
|
|
|
|
|
|
|
|
ValueExprMapType::iterator It =
|
|
|
|
ValueExprMap.find(static_cast<Value *>(I));
|
|
|
|
if (It != ValueExprMap.end()) {
|
|
|
|
const SCEV *Old = It->second;
|
|
|
|
|
|
|
|
// SCEVUnknown for a PHI either means that it has an unrecognized
|
|
|
|
// structure, or it's a PHI that's in the progress of being computed
|
|
|
|
// by createNodeForPHI. In the former case, additional loop trip
|
|
|
|
// count information isn't going to change anything. In the later
|
|
|
|
// case, createNodeForPHI will perform the necessary updates on its
|
|
|
|
// own when it gets to that point.
|
|
|
|
if (!isa<PHINode>(I) || !isa<SCEVUnknown>(Old)) {
|
|
|
|
forgetMemoizedResults(Old);
|
|
|
|
ValueExprMap.erase(It);
|
2009-07-09 03:23:34 +08:00
|
|
|
}
|
2011-01-09 10:16:18 +08:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
ConstantEvolutionLoopExitValue.erase(PN);
|
2009-07-09 03:23:34 +08:00
|
|
|
}
|
2011-01-09 10:16:18 +08:00
|
|
|
|
|
|
|
PushDefUseChildren(I, Worklist);
|
2009-07-09 03:23:34 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-04-28 04:16:15 +08:00
|
|
|
return Pair.first->second;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-10-31 23:04:55 +08:00
|
|
|
/// forgetLoop - This method should be called by the client when it has
|
|
|
|
/// changed a loop in a way that may effect ScalarEvolution's ability to
|
|
|
|
/// compute a trip count, or if the loop is deleted.
|
|
|
|
void ScalarEvolution::forgetLoop(const Loop *L) {
|
|
|
|
// Drop any stored trip count value.
|
2009-02-25 02:55:53 +08:00
|
|
|
BackedgeTakenCounts.erase(L);
|
2009-05-05 06:30:44 +08:00
|
|
|
|
2009-10-31 23:04:55 +08:00
|
|
|
// Drop information about expressions based on loop-header PHIs.
|
2009-05-05 06:30:44 +08:00
|
|
|
SmallVector<Instruction *, 16> Worklist;
|
2009-07-09 03:23:34 +08:00
|
|
|
PushLoopPHIs(L, Worklist);
|
2009-05-05 06:30:44 +08:00
|
|
|
|
2009-07-09 03:23:34 +08:00
|
|
|
SmallPtrSet<Instruction *, 8> Visited;
|
2009-05-05 06:30:44 +08:00
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Instruction *I = Worklist.pop_back_val();
|
2009-07-09 03:23:34 +08:00
|
|
|
if (!Visited.insert(I)) continue;
|
|
|
|
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMapType::iterator It = ValueExprMap.find(static_cast<Value *>(I));
|
|
|
|
if (It != ValueExprMap.end()) {
|
2010-11-18 07:28:48 +08:00
|
|
|
forgetMemoizedResults(It->second);
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap.erase(It);
|
2010-02-19 15:14:22 +08:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
ConstantEvolutionLoopExitValue.erase(PN);
|
|
|
|
}
|
|
|
|
|
|
|
|
PushDefUseChildren(I, Worklist);
|
|
|
|
}
|
2010-10-30 04:16:10 +08:00
|
|
|
|
|
|
|
// Forget all contained loops too, to avoid dangling entries in the
|
|
|
|
// ValuesAtScopes map.
|
|
|
|
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
|
|
|
|
forgetLoop(*I);
|
2010-02-19 15:14:22 +08:00
|
|
|
}
|
|
|
|
|
2010-07-29 09:25:38 +08:00
|
|
|
/// forgetValue - This method should be called by the client when it has
|
|
|
|
/// changed a value in a way that may effect its value, or which may
|
|
|
|
/// disconnect it from a def-use chain linking it to a loop.
|
|
|
|
void ScalarEvolution::forgetValue(Value *V) {
|
2010-02-19 15:14:22 +08:00
|
|
|
Instruction *I = dyn_cast<Instruction>(V);
|
|
|
|
if (!I) return;
|
|
|
|
|
|
|
|
// Drop information about expressions based on loop-header PHIs.
|
|
|
|
SmallVector<Instruction *, 16> Worklist;
|
|
|
|
Worklist.push_back(I);
|
|
|
|
|
|
|
|
SmallPtrSet<Instruction *, 8> Visited;
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
I = Worklist.pop_back_val();
|
|
|
|
if (!Visited.insert(I)) continue;
|
|
|
|
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMapType::iterator It = ValueExprMap.find(static_cast<Value *>(I));
|
|
|
|
if (It != ValueExprMap.end()) {
|
2010-11-18 07:28:48 +08:00
|
|
|
forgetMemoizedResults(It->second);
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap.erase(It);
|
2009-07-09 03:23:34 +08:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
ConstantEvolutionLoopExitValue.erase(PN);
|
2010-07-01 04:21:12 +08:00
|
|
|
}
|
|
|
|
|
2009-07-09 03:23:34 +08:00
|
|
|
PushDefUseChildren(I, Worklist);
|
2009-05-05 06:30:44 +08:00
|
|
|
}
|
2009-02-18 04:49:49 +08:00
|
|
|
}
|
|
|
|
|
2009-02-25 02:55:53 +08:00
|
|
|
/// ComputeBackedgeTakenCount - Compute the number of times the backedge
|
|
|
|
/// of the specified loop will execute.
|
2009-05-01 04:47:05 +08:00
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::ComputeBackedgeTakenCount(const Loop *L) {
|
2009-12-18 09:14:11 +08:00
|
|
|
SmallVector<BasicBlock *, 8> ExitingBlocks;
|
2009-06-22 08:31:57 +08:00
|
|
|
L->getExitingBlocks(ExitingBlocks);
|
|
|
|
|
|
|
|
// Examine all exits and pick the most conservative values.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *BECount = getCouldNotCompute();
|
|
|
|
const SCEV *MaxBECount = getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
bool CouldNotComputeBECount = false;
|
|
|
|
for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
|
|
|
|
BackedgeTakenInfo NewBTI =
|
|
|
|
ComputeBackedgeTakenCountFromExit(L, ExitingBlocks[i]);
|
|
|
|
|
2009-06-28 05:21:31 +08:00
|
|
|
if (NewBTI.Exact == getCouldNotCompute()) {
|
2009-06-22 08:31:57 +08:00
|
|
|
// We couldn't compute an exact value for this exit, so
|
2009-06-23 05:10:22 +08:00
|
|
|
// we won't be able to compute an exact value for the loop.
|
2009-06-22 08:31:57 +08:00
|
|
|
CouldNotComputeBECount = true;
|
2009-06-28 05:21:31 +08:00
|
|
|
BECount = getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
} else if (!CouldNotComputeBECount) {
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BECount == getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
BECount = NewBTI.Exact;
|
|
|
|
else
|
2009-06-24 09:18:18 +08:00
|
|
|
BECount = getUMinFromMismatchedTypes(BECount, NewBTI.Exact);
|
2009-06-22 08:31:57 +08:00
|
|
|
}
|
2009-06-28 05:21:31 +08:00
|
|
|
if (MaxBECount == getCouldNotCompute())
|
2009-06-24 09:18:18 +08:00
|
|
|
MaxBECount = NewBTI.Max;
|
2009-06-28 05:21:31 +08:00
|
|
|
else if (NewBTI.Max != getCouldNotCompute())
|
2009-06-24 09:18:18 +08:00
|
|
|
MaxBECount = getUMinFromMismatchedTypes(MaxBECount, NewBTI.Max);
|
2009-06-22 08:31:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return BackedgeTakenInfo(BECount, MaxBECount);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ComputeBackedgeTakenCountFromExit - Compute the number of times the backedge
|
|
|
|
/// of the specified loop will execute if it exits via the specified block.
|
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::ComputeBackedgeTakenCountFromExit(const Loop *L,
|
|
|
|
BasicBlock *ExitingBlock) {
|
|
|
|
|
|
|
|
// Okay, we've chosen an exiting block. See what condition causes us to
|
|
|
|
// exit at this block.
|
2004-04-03 04:23:17 +08:00
|
|
|
//
|
|
|
|
// FIXME: we should be able to handle switch instructions (with a single exit)
|
|
|
|
BranchInst *ExitBr = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
|
2009-06-28 05:21:31 +08:00
|
|
|
if (ExitBr == 0) return getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
assert(ExitBr->isConditional() && "If unconditional, it can't be in loop!");
|
2009-06-24 12:48:43 +08:00
|
|
|
|
2007-01-07 10:24:26 +08:00
|
|
|
// At this point, we know we have a conditional branch that determines whether
|
|
|
|
// the loop is exited. However, we don't know if the branch is executed each
|
|
|
|
// time through the loop. If not, then the execution count of the branch will
|
|
|
|
// not be equal to the trip count of the loop.
|
|
|
|
//
|
|
|
|
// Currently we check for this by checking to see if the Exit branch goes to
|
|
|
|
// the loop header. If so, we know it will always execute the same number of
|
2007-01-14 09:24:47 +08:00
|
|
|
// times as the loop. We also handle the case where the exit block *is* the
|
2009-06-22 08:31:57 +08:00
|
|
|
// loop header. This is common for un-rotated loops.
|
|
|
|
//
|
|
|
|
// If both of those tests fail, walk up the unique predecessor chain to the
|
|
|
|
// header, stopping if there is an edge that doesn't exit the loop. If the
|
|
|
|
// header is reached, the execution count of the branch will be equal to the
|
|
|
|
// trip count of the loop.
|
|
|
|
//
|
|
|
|
// More extensive analysis could be done to handle more cases here.
|
|
|
|
//
|
2007-01-07 10:24:26 +08:00
|
|
|
if (ExitBr->getSuccessor(0) != L->getHeader() &&
|
2007-01-14 09:24:47 +08:00
|
|
|
ExitBr->getSuccessor(1) != L->getHeader() &&
|
2009-06-22 08:31:57 +08:00
|
|
|
ExitBr->getParent() != L->getHeader()) {
|
|
|
|
// The simple checks failed, try climbing the unique predecessor chain
|
|
|
|
// up to the header.
|
|
|
|
bool Ok = false;
|
|
|
|
for (BasicBlock *BB = ExitBr->getParent(); BB; ) {
|
|
|
|
BasicBlock *Pred = BB->getUniquePredecessor();
|
|
|
|
if (!Pred)
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
TerminatorInst *PredTerm = Pred->getTerminator();
|
|
|
|
for (unsigned i = 0, e = PredTerm->getNumSuccessors(); i != e; ++i) {
|
|
|
|
BasicBlock *PredSucc = PredTerm->getSuccessor(i);
|
|
|
|
if (PredSucc == BB)
|
|
|
|
continue;
|
|
|
|
// If the predecessor has a successor that isn't BB and isn't
|
|
|
|
// outside the loop, assume the worst.
|
|
|
|
if (L->contains(PredSucc))
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
}
|
|
|
|
if (Pred == L->getHeader()) {
|
|
|
|
Ok = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
BB = Pred;
|
|
|
|
}
|
|
|
|
if (!Ok)
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
}
|
|
|
|
|
2010-03-02 01:49:51 +08:00
|
|
|
// Proceed to the next level to examine the exit condition expression.
|
2009-06-22 08:31:57 +08:00
|
|
|
return ComputeBackedgeTakenCountFromExitCond(L, ExitBr->getCondition(),
|
|
|
|
ExitBr->getSuccessor(0),
|
|
|
|
ExitBr->getSuccessor(1));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ComputeBackedgeTakenCountFromExitCond - Compute the number of times the
|
|
|
|
/// backedge of the specified loop will execute if its exit condition
|
|
|
|
/// were a conditional branch of ExitCond, TBB, and FBB.
|
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::ComputeBackedgeTakenCountFromExitCond(const Loop *L,
|
|
|
|
Value *ExitCond,
|
|
|
|
BasicBlock *TBB,
|
|
|
|
BasicBlock *FBB) {
|
2009-06-24 09:18:18 +08:00
|
|
|
// Check if the controlling expression for this loop is an And or Or.
|
2009-06-22 08:31:57 +08:00
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(ExitCond)) {
|
|
|
|
if (BO->getOpcode() == Instruction::And) {
|
|
|
|
// Recurse on the operands of the and.
|
|
|
|
BackedgeTakenInfo BTI0 =
|
|
|
|
ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(0), TBB, FBB);
|
|
|
|
BackedgeTakenInfo BTI1 =
|
|
|
|
ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(1), TBB, FBB);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *BECount = getCouldNotCompute();
|
|
|
|
const SCEV *MaxBECount = getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
if (L->contains(TBB)) {
|
|
|
|
// Both conditions must be true for the loop to continue executing.
|
|
|
|
// Choose the less conservative count.
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Exact == getCouldNotCompute() ||
|
|
|
|
BTI1.Exact == getCouldNotCompute())
|
|
|
|
BECount = getCouldNotCompute();
|
2009-06-22 23:09:28 +08:00
|
|
|
else
|
|
|
|
BECount = getUMinFromMismatchedTypes(BTI0.Exact, BTI1.Exact);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Max == getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
MaxBECount = BTI1.Max;
|
2009-06-28 05:21:31 +08:00
|
|
|
else if (BTI1.Max == getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
MaxBECount = BTI0.Max;
|
2009-06-22 23:09:28 +08:00
|
|
|
else
|
|
|
|
MaxBECount = getUMinFromMismatchedTypes(BTI0.Max, BTI1.Max);
|
2009-06-22 08:31:57 +08:00
|
|
|
} else {
|
2010-08-11 08:12:36 +08:00
|
|
|
// Both conditions must be true at the same time for the loop to exit.
|
|
|
|
// For now, be conservative.
|
2009-06-22 08:31:57 +08:00
|
|
|
assert(L->contains(FBB) && "Loop block has no successor in loop!");
|
2010-08-11 08:12:36 +08:00
|
|
|
if (BTI0.Max == BTI1.Max)
|
|
|
|
MaxBECount = BTI0.Max;
|
|
|
|
if (BTI0.Exact == BTI1.Exact)
|
|
|
|
BECount = BTI0.Exact;
|
2009-06-22 08:31:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return BackedgeTakenInfo(BECount, MaxBECount);
|
|
|
|
}
|
|
|
|
if (BO->getOpcode() == Instruction::Or) {
|
|
|
|
// Recurse on the operands of the or.
|
|
|
|
BackedgeTakenInfo BTI0 =
|
|
|
|
ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(0), TBB, FBB);
|
|
|
|
BackedgeTakenInfo BTI1 =
|
|
|
|
ComputeBackedgeTakenCountFromExitCond(L, BO->getOperand(1), TBB, FBB);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *BECount = getCouldNotCompute();
|
|
|
|
const SCEV *MaxBECount = getCouldNotCompute();
|
2009-06-22 08:31:57 +08:00
|
|
|
if (L->contains(FBB)) {
|
|
|
|
// Both conditions must be false for the loop to continue executing.
|
|
|
|
// Choose the less conservative count.
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Exact == getCouldNotCompute() ||
|
|
|
|
BTI1.Exact == getCouldNotCompute())
|
|
|
|
BECount = getCouldNotCompute();
|
2009-06-22 23:09:28 +08:00
|
|
|
else
|
|
|
|
BECount = getUMinFromMismatchedTypes(BTI0.Exact, BTI1.Exact);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Max == getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
MaxBECount = BTI1.Max;
|
2009-06-28 05:21:31 +08:00
|
|
|
else if (BTI1.Max == getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
MaxBECount = BTI0.Max;
|
2009-06-22 23:09:28 +08:00
|
|
|
else
|
|
|
|
MaxBECount = getUMinFromMismatchedTypes(BTI0.Max, BTI1.Max);
|
2009-06-22 08:31:57 +08:00
|
|
|
} else {
|
2010-08-11 08:12:36 +08:00
|
|
|
// Both conditions must be false at the same time for the loop to exit.
|
|
|
|
// For now, be conservative.
|
2009-06-22 08:31:57 +08:00
|
|
|
assert(L->contains(TBB) && "Loop block has no successor in loop!");
|
2010-08-11 08:12:36 +08:00
|
|
|
if (BTI0.Max == BTI1.Max)
|
|
|
|
MaxBECount = BTI0.Max;
|
|
|
|
if (BTI0.Exact == BTI1.Exact)
|
|
|
|
BECount = BTI0.Exact;
|
2009-06-22 08:31:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return BackedgeTakenInfo(BECount, MaxBECount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// With an icmp, it may be feasible to compute an exact backedge-taken count.
|
2010-03-02 01:49:51 +08:00
|
|
|
// Proceed to the next level to examine the icmp.
|
2009-06-22 08:31:57 +08:00
|
|
|
if (ICmpInst *ExitCondICmp = dyn_cast<ICmpInst>(ExitCond))
|
|
|
|
return ComputeBackedgeTakenCountFromExitCondICmp(L, ExitCondICmp, TBB, FBB);
|
2006-12-23 14:05:41 +08:00
|
|
|
|
2010-02-20 02:12:07 +08:00
|
|
|
// Check for a constant condition. These are normally stripped out by
|
|
|
|
// SimplifyCFG, but ScalarEvolution may be used by a pass which wishes to
|
|
|
|
// preserve the CFG and is temporarily leaving constant conditions
|
|
|
|
// in place.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(ExitCond)) {
|
|
|
|
if (L->contains(FBB) == !CI->getZExtValue())
|
|
|
|
// The backedge is always taken.
|
|
|
|
return getCouldNotCompute();
|
|
|
|
else
|
|
|
|
// The backedge is never taken.
|
2010-05-04 06:09:21 +08:00
|
|
|
return getConstant(CI->getType(), 0);
|
2010-02-20 02:12:07 +08:00
|
|
|
}
|
|
|
|
|
2009-05-09 20:32:42 +08:00
|
|
|
// If it's not an integer or pointer comparison then compute it the hard way.
|
2009-06-22 08:31:57 +08:00
|
|
|
return ComputeBackedgeTakenCountExhaustively(L, ExitCond, !L->contains(TBB));
|
|
|
|
}
|
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
static const SCEVAddRecExpr *
|
|
|
|
isSimpleUnwrappingAddRec(const SCEV *S, const Loop *L) {
|
|
|
|
const SCEVAddRecExpr *SA = dyn_cast<SCEVAddRecExpr>(S);
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// The SCEV must be an addrec of this loop.
|
|
|
|
if (!SA || SA->getLoop() != L || !SA->isAffine())
|
|
|
|
return 0;
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// The SCEV must be known to not wrap in some way to be interesting.
|
2011-03-15 00:50:06 +08:00
|
|
|
if (!SA->getNoWrapFlags(SCEV::FlagNW))
|
2011-01-10 06:26:35 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// The stride must be a constant so that we know if it is striding up or down.
|
|
|
|
if (!isa<SCEVConstant>(SA->getOperand(1)))
|
|
|
|
return 0;
|
|
|
|
return SA;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getMinusSCEVForExitTest - When considering an exit test for a loop with a
|
|
|
|
/// "x != y" exit test, we turn this into a computation that evaluates x-y != 0,
|
|
|
|
/// and this function returns the expression to use for x-y. We know and take
|
|
|
|
/// advantage of the fact that this subtraction is only being used in a
|
|
|
|
/// comparison by zero context.
|
|
|
|
///
|
2011-03-15 00:50:06 +08:00
|
|
|
/// FIXME: this can be completely removed once AddRec FlagNWs are propagated.
|
2011-01-10 06:26:35 +08:00
|
|
|
static const SCEV *getMinusSCEVForExitTest(const SCEV *LHS, const SCEV *RHS,
|
|
|
|
const Loop *L, ScalarEvolution &SE) {
|
|
|
|
// If either LHS or RHS is an AddRec SCEV (of this loop) that is known to not
|
2011-03-15 00:50:06 +08:00
|
|
|
// self-wrap, then we know that the value will either become the other one
|
|
|
|
// (and thus the loop terminates), that the loop will terminate through some
|
|
|
|
// other exit condition first, or that the loop has undefined behavior. This
|
|
|
|
// information is useful when the addrec has a stride that is != 1 or -1,
|
|
|
|
// because it means we can't "miss" the exit value.
|
2011-01-10 06:26:35 +08:00
|
|
|
//
|
|
|
|
// In any of these three cases, it is safe to turn the exit condition into a
|
|
|
|
// "counting down" AddRec (to zero) by subtracting the two inputs as normal,
|
|
|
|
// but since we know that the "end cannot be missed" we can force the
|
|
|
|
// resulting AddRec to be a NUW addrec. Since it is counting down, this means
|
|
|
|
// that the AddRec *cannot* pass zero.
|
|
|
|
|
|
|
|
// See if LHS and RHS are addrec's we can handle.
|
|
|
|
const SCEVAddRecExpr *LHSA = isSimpleUnwrappingAddRec(LHS, L);
|
|
|
|
const SCEVAddRecExpr *RHSA = isSimpleUnwrappingAddRec(RHS, L);
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// If neither addrec is interesting, just return a minus.
|
|
|
|
if (RHSA == 0 && LHSA == 0)
|
|
|
|
return SE.getMinusSCEV(LHS, RHS);
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// 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);
|
|
|
|
}
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// 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);
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// 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.
|
|
|
|
const ConstantInt *Stride =
|
|
|
|
cast<SCEVConstant>(LHSA->getOperand(1))->getValue();
|
|
|
|
if (Stride->getValue().isNegative())
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
return SE.getMinusSCEV(RHS, LHS, SCEV::FlagNUW);
|
2011-01-10 06:26:35 +08:00
|
|
|
}
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// 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();
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// If the strides are equal, then this is just a (complex) loop invariant
|
2011-01-12 01:11:59 +08:00
|
|
|
// comparison of a and b.
|
2011-01-10 06:26:35 +08:00
|
|
|
if (LHSStride == RHSStride)
|
|
|
|
return SE.getMinusSCEV(LHSA->getStart(), RHSA->getStart());
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-01-10 06:26:35 +08:00
|
|
|
// 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()){
|
|
|
|
if (RHSStride->getValue().isNegative())
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
} else {
|
|
|
|
// If LHS's stride is smaller than RHS's stride, then "b" must be less than
|
|
|
|
// "a" and "b" is RHS is counting up (catching up) to LHS. This is true
|
|
|
|
// whether the strides are positive or negative.
|
|
|
|
if (RHSStride->getValue().slt(LHSStride->getValue()))
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
}
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
return SE.getMinusSCEV(LHS, RHS, SCEV::FlagNUW);
|
2011-01-10 06:26:35 +08:00
|
|
|
}
|
|
|
|
|
2009-06-22 08:31:57 +08:00
|
|
|
/// ComputeBackedgeTakenCountFromExitCondICmp - Compute the number of times the
|
|
|
|
/// backedge of the specified loop will execute if its exit condition
|
|
|
|
/// were a conditional branch of the ICmpInst ExitCond, TBB, and FBB.
|
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::ComputeBackedgeTakenCountFromExitCondICmp(const Loop *L,
|
|
|
|
ICmpInst *ExitCond,
|
|
|
|
BasicBlock *TBB,
|
|
|
|
BasicBlock *FBB) {
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2006-12-23 14:05:41 +08:00
|
|
|
// If the condition was exit on true, convert the condition to exit on false
|
|
|
|
ICmpInst::Predicate Cond;
|
2009-06-22 08:31:57 +08:00
|
|
|
if (!L->contains(FBB))
|
2006-12-23 14:05:41 +08:00
|
|
|
Cond = ExitCond->getPredicate();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
else
|
2006-12-23 14:05:41 +08:00
|
|
|
Cond = ExitCond->getInversePredicate();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
// Handle common loops like: for (X = "string"; *X; ++X)
|
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(ExitCond->getOperand(0)))
|
|
|
|
if (Constant *RHS = dyn_cast<Constant>(ExitCond->getOperand(1))) {
|
2010-02-25 01:31:30 +08:00
|
|
|
BackedgeTakenInfo ItCnt =
|
2009-02-25 02:55:53 +08:00
|
|
|
ComputeLoadConstantCompareBackedgeTakenCount(LI, RHS, L, Cond);
|
2010-02-25 01:31:30 +08:00
|
|
|
if (ItCnt.hasAnyInfo())
|
|
|
|
return ItCnt;
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *LHS = getSCEV(ExitCond->getOperand(0));
|
|
|
|
const SCEV *RHS = getSCEV(ExitCond->getOperand(1));
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// Try to evaluate any dependencies out of the loop.
|
2009-05-25 07:25:42 +08:00
|
|
|
LHS = getSCEVAtScope(LHS, L);
|
|
|
|
RHS = getSCEVAtScope(RHS, L);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-06-24 12:48:43 +08:00
|
|
|
// At this point, we would like to compute how many iterations of the
|
2006-12-23 14:05:41 +08:00
|
|
|
// loop the predicate will return true for these inputs.
|
2010-11-18 05:23:15 +08:00
|
|
|
if (isLoopInvariant(LHS, L) && !isLoopInvariant(RHS, L)) {
|
2008-09-17 02:52:57 +08:00
|
|
|
// If there is a loop-invariant, force it into the RHS.
|
2004-04-03 04:23:17 +08:00
|
|
|
std::swap(LHS, RHS);
|
2006-12-23 14:05:41 +08:00
|
|
|
Cond = ICmpInst::getSwappedPredicate(Cond);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2010-05-04 00:35:17 +08:00
|
|
|
// Simplify the operands before analyzing them.
|
|
|
|
(void)SimplifyICmpOperands(Cond, LHS, RHS);
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// If we have a comparison of a chrec against a constant, try to use value
|
|
|
|
// ranges to answer this query.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS))
|
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS))
|
2004-04-03 04:23:17 +08:00
|
|
|
if (AddRec->getLoop() == L) {
|
2009-05-09 20:32:42 +08:00
|
|
|
// Form the constant range.
|
|
|
|
ConstantRange CompRange(
|
|
|
|
ICmpInst::makeConstantRange(Cond, RHSC->getValue()->getValue()));
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Ret = AddRec->getNumIterationsInRange(CompRange, *this);
|
2009-05-09 20:32:42 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(Ret)) return Ret;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
switch (Cond) {
|
2006-12-23 14:05:41 +08:00
|
|
|
case ICmpInst::ICMP_NE: { // while (X != Y)
|
2004-04-03 04:23:17 +08:00
|
|
|
// Convert to: while (X-Y != 0)
|
2011-03-15 00:50:06 +08:00
|
|
|
// FIXME: Once AddRec FlagNW are propagated, should be:
|
|
|
|
// BackedgeTakenInfo BTI = HowFarToZero(getMinusSCEV(LHS, RHS), L);
|
2011-01-10 06:26:35 +08:00
|
|
|
BackedgeTakenInfo BTI = HowFarToZero(getMinusSCEVForExitTest(LHS, RHS, L,
|
|
|
|
*this), L);
|
2010-02-25 01:31:30 +08:00
|
|
|
if (BTI.hasAnyInfo()) return BTI;
|
2004-04-03 04:23:17 +08:00
|
|
|
break;
|
2006-12-23 14:05:41 +08:00
|
|
|
}
|
2009-08-21 00:42:55 +08:00
|
|
|
case ICmpInst::ICMP_EQ: { // while (X == Y)
|
|
|
|
// Convert to: while (X-Y == 0)
|
2010-02-25 01:31:30 +08:00
|
|
|
BackedgeTakenInfo BTI = HowFarToNonZero(getMinusSCEV(LHS, RHS), L);
|
|
|
|
if (BTI.hasAnyInfo()) return BTI;
|
2004-04-03 04:23:17 +08:00
|
|
|
break;
|
2006-12-23 14:05:41 +08:00
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_SLT: {
|
2009-05-01 04:47:05 +08:00
|
|
|
BackedgeTakenInfo BTI = HowManyLessThans(LHS, RHS, L, true);
|
|
|
|
if (BTI.hasAnyInfo()) return BTI;
|
2005-08-16 07:33:51 +08:00
|
|
|
break;
|
2006-12-23 14:05:41 +08:00
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_SGT: {
|
2009-05-01 04:47:05 +08:00
|
|
|
BackedgeTakenInfo BTI = HowManyLessThans(getNotSCEV(LHS),
|
|
|
|
getNotSCEV(RHS), L, true);
|
|
|
|
if (BTI.hasAnyInfo()) return BTI;
|
2007-08-07 03:21:00 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_ULT: {
|
2009-05-01 04:47:05 +08:00
|
|
|
BackedgeTakenInfo BTI = HowManyLessThans(LHS, RHS, L, false);
|
|
|
|
if (BTI.hasAnyInfo()) return BTI;
|
2007-08-07 03:21:00 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_UGT: {
|
2009-05-01 04:47:05 +08:00
|
|
|
BackedgeTakenInfo BTI = HowManyLessThans(getNotSCEV(LHS),
|
|
|
|
getNotSCEV(RHS), L, false);
|
|
|
|
if (BTI.hasAnyInfo()) return BTI;
|
2005-08-16 07:33:51 +08:00
|
|
|
break;
|
2006-12-23 14:05:41 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
default:
|
2004-04-03 04:26:46 +08:00
|
|
|
#if 0
|
2009-12-24 06:18:14 +08:00
|
|
|
dbgs() << "ComputeBackedgeTakenCount ";
|
2004-04-03 04:23:17 +08:00
|
|
|
if (ExitCond->getOperand(0)->getType()->isUnsigned())
|
2009-12-24 06:18:14 +08:00
|
|
|
dbgs() << "[unsigned] ";
|
|
|
|
dbgs() << *LHS << " "
|
2009-06-24 12:48:43 +08:00
|
|
|
<< Instruction::getOpcodeName(Instruction::ICmp)
|
2006-12-23 14:05:41 +08:00
|
|
|
<< " " << *RHS << "\n";
|
2004-04-03 04:26:46 +08:00
|
|
|
#endif
|
2004-04-03 08:43:03 +08:00
|
|
|
break;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-02-25 02:55:53 +08:00
|
|
|
return
|
2009-06-22 08:31:57 +08:00
|
|
|
ComputeBackedgeTakenCountExhaustively(L, ExitCond, !L->contains(TBB));
|
2004-04-18 02:36:24 +08:00
|
|
|
}
|
|
|
|
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
static ConstantInt *
|
2007-10-23 02:31:58 +08:00
|
|
|
EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C,
|
|
|
|
ScalarEvolution &SE) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *InVal = SE.getConstant(C);
|
|
|
|
const SCEV *Val = AddRec->evaluateAtIteration(InVal, SE);
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
assert(isa<SCEVConstant>(Val) &&
|
|
|
|
"Evaluation of SCEV at constant didn't fold correctly?");
|
|
|
|
return cast<SCEVConstant>(Val)->getValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// GetAddressedElementFromGlobal - Given a global variable with an initializer
|
|
|
|
/// and a GEP expression (missing the pointer index) indexing into it, return
|
|
|
|
/// the addressed element of the initializer or null if the index expression is
|
|
|
|
/// invalid.
|
|
|
|
static Constant *
|
2009-11-23 11:26:09 +08:00
|
|
|
GetAddressedElementFromGlobal(GlobalVariable *GV,
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
const std::vector<ConstantInt*> &Indices) {
|
|
|
|
Constant *Init = GV->getInitializer();
|
|
|
|
for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
|
2006-10-20 15:07:24 +08:00
|
|
|
uint64_t Idx = Indices[i]->getZExtValue();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Init)) {
|
|
|
|
assert(Idx < CS->getNumOperands() && "Bad struct index!");
|
|
|
|
Init = cast<Constant>(CS->getOperand(Idx));
|
|
|
|
} else if (ConstantArray *CA = dyn_cast<ConstantArray>(Init)) {
|
|
|
|
if (Idx >= CA->getNumOperands()) return 0; // Bogus program
|
|
|
|
Init = cast<Constant>(CA->getOperand(Idx));
|
|
|
|
} else if (isa<ConstantAggregateZero>(Init)) {
|
|
|
|
if (const StructType *STy = dyn_cast<StructType>(Init->getType())) {
|
|
|
|
assert(Idx < STy->getNumElements() && "Bad struct index!");
|
2009-08-01 04:28:14 +08:00
|
|
|
Init = Constant::getNullValue(STy->getElementType(Idx));
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
} else if (const ArrayType *ATy = dyn_cast<ArrayType>(Init->getType())) {
|
|
|
|
if (Idx >= ATy->getNumElements()) return 0; // Bogus program
|
2009-08-01 04:28:14 +08:00
|
|
|
Init = Constant::getNullValue(ATy->getElementType());
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
} else {
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Unknown constant aggregate type!");
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return 0; // Unknown initializer type
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Init;
|
|
|
|
}
|
|
|
|
|
2009-02-25 02:55:53 +08:00
|
|
|
/// ComputeLoadConstantCompareBackedgeTakenCount - Given an exit condition of
|
|
|
|
/// 'icmp op load X, cst', try to see if we can compute the backedge
|
|
|
|
/// execution count.
|
2010-02-25 01:31:30 +08:00
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
2009-06-24 12:48:43 +08:00
|
|
|
ScalarEvolution::ComputeLoadConstantCompareBackedgeTakenCount(
|
|
|
|
LoadInst *LI,
|
|
|
|
Constant *RHS,
|
|
|
|
const Loop *L,
|
|
|
|
ICmpInst::Predicate predicate) {
|
2009-06-28 05:21:31 +08:00
|
|
|
if (LI->isVolatile()) return getCouldNotCompute();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
// Check to see if the loaded pointer is a getelementptr of a global.
|
2010-02-25 01:31:30 +08:00
|
|
|
// TODO: Use SCEV instead of manually grubbing with GEPs.
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(LI->getOperand(0));
|
2009-06-28 05:21:31 +08:00
|
|
|
if (!GEP) return getCouldNotCompute();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
// Make sure that it is really a constant global we are gepping, with an
|
|
|
|
// initializer, and make sure the first IDX is really 0.
|
|
|
|
GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0));
|
2009-08-20 02:20:44 +08:00
|
|
|
if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer() ||
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
GEP->getNumOperands() < 3 || !isa<Constant>(GEP->getOperand(1)) ||
|
|
|
|
!cast<Constant>(GEP->getOperand(1))->isNullValue())
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
// Okay, we allow one non-constant index into the GEP instruction.
|
|
|
|
Value *VarIdx = 0;
|
|
|
|
std::vector<ConstantInt*> Indexes;
|
|
|
|
unsigned VarIdxNum = 0;
|
|
|
|
for (unsigned i = 2, e = GEP->getNumOperands(); i != e; ++i)
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
|
|
|
|
Indexes.push_back(CI);
|
|
|
|
} else if (!isa<ConstantInt>(GEP->getOperand(i))) {
|
2009-06-28 05:21:31 +08:00
|
|
|
if (VarIdx) return getCouldNotCompute(); // Multiple non-constant idx's.
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
VarIdx = GEP->getOperand(i);
|
|
|
|
VarIdxNum = i-2;
|
|
|
|
Indexes.push_back(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, we know we have a (load (gep GV, 0, X)) comparison with a constant.
|
|
|
|
// Check to see if X is a loop variant variable value now.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Idx = getSCEV(VarIdx);
|
2009-05-25 07:25:42 +08:00
|
|
|
Idx = getSCEVAtScope(Idx, L);
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
// We can only recognize very limited forms of loop index expressions, in
|
|
|
|
// particular, only affine AddRec's like {C1,+,C2}.
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *IdxExpr = dyn_cast<SCEVAddRecExpr>(Idx);
|
2010-11-18 05:23:15 +08:00
|
|
|
if (!IdxExpr || !IdxExpr->isAffine() || isLoopInvariant(IdxExpr, L) ||
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
!isa<SCEVConstant>(IdxExpr->getOperand(0)) ||
|
|
|
|
!isa<SCEVConstant>(IdxExpr->getOperand(1)))
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
unsigned MaxSteps = MaxBruteForceIterations;
|
|
|
|
for (unsigned IterationNum = 0; IterationNum != MaxSteps; ++IterationNum) {
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt *ItCst = ConstantInt::get(
|
2009-07-15 07:09:55 +08:00
|
|
|
cast<IntegerType>(IdxExpr->getType()), IterationNum);
|
2009-04-22 07:15:49 +08:00
|
|
|
ConstantInt *Val = EvaluateConstantChrecAtConstant(IdxExpr, ItCst, *this);
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
|
|
|
|
// Form the GEP offset.
|
|
|
|
Indexes[VarIdxNum] = Val;
|
|
|
|
|
2009-11-23 11:26:09 +08:00
|
|
|
Constant *Result = GetAddressedElementFromGlobal(GV, Indexes);
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
if (Result == 0) break; // Cannot compute!
|
|
|
|
|
|
|
|
// Evaluate the condition for this iteration.
|
2006-12-23 14:05:41 +08:00
|
|
|
Result = ConstantExpr::getICmp(predicate, Result, RHS);
|
2007-01-11 20:24:14 +08:00
|
|
|
if (!isa<ConstantInt>(Result)) break; // Couldn't decide for sure
|
2007-03-01 15:25:48 +08:00
|
|
|
if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
#if 0
|
2009-12-24 06:18:14 +08:00
|
|
|
dbgs() << "\n***\n*** Computed loop count " << *ItCst
|
2009-04-21 08:47:46 +08:00
|
|
|
<< "\n*** From global " << *GV << "*** BB: " << *L->getHeader()
|
|
|
|
<< "***\n";
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
#endif
|
|
|
|
++NumArrayLenItCounts;
|
2009-04-22 07:15:49 +08:00
|
|
|
return getConstant(ItCst); // Found terminating iteration!
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
}
|
|
|
|
}
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
This nutty patch has been in my tree since before 1.3 went out, and it needs
to go in. This patch allows us to compute the trip count of loops controlled
by values loaded from constant arrays. The cannonnical example of this is
strlen when passed a constant argument:
for (int i = 0; "constantstring"[i]; ++i) ;
return i;
In this case, it will compute that the loop executes 14 times, which means
that the exit value of i is 14. Because of this, the loop gets DCE'd and
we are happy. This also applies to anything that does similar things, e.g.
loops like this:
const float Array[] = { 0.1, 2.1, 3.2, 23.21 };
for (int i = 0; Array[i] < 20; ++i)
and is actually fairly general.
The problem with this is that it almost never triggers. The reason is that
we run indvars and the loop optimizer only at compile time, which is before
things like strlen and strcpy have been inlined into the program from libc.
Because of this, it almost never is used (it triggers twice in specint2k).
I'm committing it because it DOES work, may be useful in the future, and
doesn't slow us down at all. If/when we start running the loop optimizer
at link-time (-O4?) this will be very nice indeed :)
llvm-svn: 16926
2004-10-12 09:49:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
/// CanConstantFold - Return true if we can constant fold an instruction of the
|
|
|
|
/// specified type, assuming that all operands were constants.
|
|
|
|
static bool CanConstantFold(const Instruction *I) {
|
2007-02-02 10:16:23 +08:00
|
|
|
if (isa<BinaryOperator>(I) || isa<CmpInst>(I) ||
|
2004-04-18 06:58:41 +08:00
|
|
|
isa<SelectInst>(I) || isa<CastInst>(I) || isa<GetElementPtrInst>(I))
|
|
|
|
return true;
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(I))
|
|
|
|
if (const Function *F = CI->getCalledFunction())
|
2008-01-31 09:05:10 +08:00
|
|
|
return canConstantFoldCallTo(F);
|
2004-04-18 06:58:41 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2004-04-18 02:36:24 +08:00
|
|
|
/// getConstantEvolvingPHI - Given an LLVM value and a loop, return a PHI node
|
|
|
|
/// in the loop that V is derived from. We allow arbitrary operations along the
|
|
|
|
/// way, but the operands of an operation must either be constants or a value
|
|
|
|
/// derived from a constant PHI. If this expression does not fit with these
|
|
|
|
/// constraints, return null.
|
|
|
|
static PHINode *getConstantEvolvingPHI(Value *V, const Loop *L) {
|
|
|
|
// If this is not an instruction, or if this is an instruction outside of the
|
|
|
|
// loop, it can't be derived from a loop PHI.
|
|
|
|
Instruction *I = dyn_cast<Instruction>(V);
|
2009-12-18 09:24:09 +08:00
|
|
|
if (I == 0 || !L->contains(I)) return 0;
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2008-02-20 19:08:44 +08:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I)) {
|
2004-04-18 02:36:24 +08:00
|
|
|
if (L->getHeader() == I->getParent())
|
|
|
|
return PN;
|
|
|
|
else
|
|
|
|
// We don't currently keep track of the control flow needed to evaluate
|
|
|
|
// PHIs, so we cannot handle PHIs inside of loops.
|
|
|
|
return 0;
|
2008-02-20 19:08:44 +08:00
|
|
|
}
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
// If we won't be able to constant fold this expression even if the operands
|
|
|
|
// are constants, return early.
|
|
|
|
if (!CanConstantFold(I)) return 0;
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
// Otherwise, we can evaluate this instruction if all of its operands are
|
|
|
|
// constant or derived from a PHI node themselves.
|
|
|
|
PHINode *PHI = 0;
|
|
|
|
for (unsigned Op = 0, e = I->getNumOperands(); Op != e; ++Op)
|
2010-06-22 21:15:46 +08:00
|
|
|
if (!isa<Constant>(I->getOperand(Op))) {
|
2004-04-18 06:58:41 +08:00
|
|
|
PHINode *P = getConstantEvolvingPHI(I->getOperand(Op), L);
|
|
|
|
if (P == 0) return 0; // Not evolving from PHI
|
|
|
|
if (PHI == 0)
|
|
|
|
PHI = P;
|
|
|
|
else if (PHI != P)
|
|
|
|
return 0; // Evolving from multiple different PHIs.
|
|
|
|
}
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
// This is a expression evolving from a constant PHI!
|
|
|
|
return PHI;
|
2004-04-18 02:36:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// EvaluateExpression - Given an expression that passes the
|
|
|
|
/// getConstantEvolvingPHI predicate, evaluate its value assuming the PHI node
|
|
|
|
/// in the loop has the value PHIVal. If we can't fold this expression for some
|
|
|
|
/// reason, return null.
|
2009-11-10 07:34:17 +08:00
|
|
|
static Constant *EvaluateExpression(Value *V, Constant *PHIVal,
|
|
|
|
const TargetData *TD) {
|
2004-04-18 02:36:24 +08:00
|
|
|
if (isa<PHINode>(V)) return PHIVal;
|
2004-07-18 08:18:30 +08:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) return C;
|
2004-04-18 02:36:24 +08:00
|
|
|
Instruction *I = cast<Instruction>(V);
|
|
|
|
|
2010-06-22 21:15:46 +08:00
|
|
|
std::vector<Constant*> Operands(I->getNumOperands());
|
2004-04-18 02:36:24 +08:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
|
2009-11-10 07:34:17 +08:00
|
|
|
Operands[i] = EvaluateExpression(I->getOperand(i), PHIVal, TD);
|
2004-04-18 02:36:24 +08:00
|
|
|
if (Operands[i] == 0) return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-11 06:53:04 +08:00
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(I))
|
2009-11-10 07:06:58 +08:00
|
|
|
return ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
|
2009-11-10 07:34:17 +08:00
|
|
|
Operands[1], TD);
|
2009-11-10 07:06:58 +08:00
|
|
|
return ConstantFoldInstOperands(I->getOpcode(), I->getType(),
|
2009-11-10 07:34:17 +08:00
|
|
|
&Operands[0], Operands.size(), TD);
|
2004-04-18 06:58:41 +08:00
|
|
|
}
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
/// getConstantEvolutionLoopExitValue - If we know that the specified Phi is
|
|
|
|
/// in the header of its containing loop, we know the loop executes a
|
|
|
|
/// constant number of times, and the PHI node is just a recurrence
|
|
|
|
/// involving constants, fold it.
|
2009-06-24 12:48:43 +08:00
|
|
|
Constant *
|
|
|
|
ScalarEvolution::getConstantEvolutionLoopExitValue(PHINode *PN,
|
2009-12-18 09:14:11 +08:00
|
|
|
const APInt &BEs,
|
2009-06-24 12:48:43 +08:00
|
|
|
const Loop *L) {
|
2010-08-17 00:30:01 +08:00
|
|
|
std::map<PHINode*, Constant*>::const_iterator I =
|
2004-04-18 06:58:41 +08:00
|
|
|
ConstantEvolutionLoopExitValue.find(PN);
|
|
|
|
if (I != ConstantEvolutionLoopExitValue.end())
|
|
|
|
return I->second;
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2010-04-09 07:03:40 +08:00
|
|
|
if (BEs.ugt(MaxBruteForceIterations))
|
2004-04-18 06:58:41 +08:00
|
|
|
return ConstantEvolutionLoopExitValue[PN] = 0; // Not going to evaluate it.
|
|
|
|
|
|
|
|
Constant *&RetVal = ConstantEvolutionLoopExitValue[PN];
|
|
|
|
|
|
|
|
// Since the loop is canonicalized, the PHI node must have two entries. One
|
|
|
|
// entry must be a constant (coming in from outside of the loop), and the
|
|
|
|
// second must be derived from the same PHI.
|
|
|
|
bool SecondIsBackedge = L->contains(PN->getIncomingBlock(1));
|
|
|
|
Constant *StartCST =
|
|
|
|
dyn_cast<Constant>(PN->getIncomingValue(!SecondIsBackedge));
|
|
|
|
if (StartCST == 0)
|
|
|
|
return RetVal = 0; // Must be a constant.
|
|
|
|
|
|
|
|
Value *BEValue = PN->getIncomingValue(SecondIsBackedge);
|
2010-06-22 21:15:46 +08:00
|
|
|
if (getConstantEvolvingPHI(BEValue, L) != PN &&
|
|
|
|
!isa<Constant>(BEValue))
|
2004-04-18 06:58:41 +08:00
|
|
|
return RetVal = 0; // Not derived from same PHI.
|
|
|
|
|
|
|
|
// Execute the loop symbolically to determine the exit value.
|
2009-02-25 02:55:53 +08:00
|
|
|
if (BEs.getActiveBits() >= 32)
|
2007-03-01 15:25:48 +08:00
|
|
|
return RetVal = 0; // More than 2^32-1 iterations?? Not doing it!
|
2004-04-18 06:58:41 +08:00
|
|
|
|
2009-02-25 02:55:53 +08:00
|
|
|
unsigned NumIterations = BEs.getZExtValue(); // must be in range
|
2007-03-01 15:25:48 +08:00
|
|
|
unsigned IterationNum = 0;
|
2004-04-18 06:58:41 +08:00
|
|
|
for (Constant *PHIVal = StartCST; ; ++IterationNum) {
|
|
|
|
if (IterationNum == NumIterations)
|
|
|
|
return RetVal = PHIVal; // Got exit value!
|
|
|
|
|
|
|
|
// Compute the value of the PHI node for the next iteration.
|
2009-11-10 07:34:17 +08:00
|
|
|
Constant *NextPHI = EvaluateExpression(BEValue, PHIVal, TD);
|
2004-04-18 06:58:41 +08:00
|
|
|
if (NextPHI == PHIVal)
|
|
|
|
return RetVal = NextPHI; // Stopped evolving!
|
|
|
|
if (NextPHI == 0)
|
|
|
|
return 0; // Couldn't evaluate!
|
|
|
|
PHIVal = NextPHI;
|
2004-04-18 02:36:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-28 00:09:48 +08:00
|
|
|
/// ComputeBackedgeTakenCountExhaustively - If the loop is known to execute a
|
2004-04-18 02:36:24 +08:00
|
|
|
/// constant number of times (the condition evolves only from constants),
|
|
|
|
/// try to evaluate a few iterations of the loop until we get the exit
|
|
|
|
/// condition gets a value of ExitWhen (true or false). If we cannot
|
2009-06-28 05:21:31 +08:00
|
|
|
/// evaluate the trip count of the loop, return getCouldNotCompute().
|
2009-06-24 12:48:43 +08:00
|
|
|
const SCEV *
|
|
|
|
ScalarEvolution::ComputeBackedgeTakenCountExhaustively(const Loop *L,
|
|
|
|
Value *Cond,
|
|
|
|
bool ExitWhen) {
|
2004-04-18 02:36:24 +08:00
|
|
|
PHINode *PN = getConstantEvolvingPHI(Cond, L);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (PN == 0) return getCouldNotCompute();
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2010-06-19 22:17:24 +08:00
|
|
|
// If the loop is canonicalized, the PHI will have exactly two entries.
|
|
|
|
// That's the only form we support here.
|
|
|
|
if (PN->getNumIncomingValues() != 2) return getCouldNotCompute();
|
|
|
|
|
|
|
|
// One entry must be a constant (coming in from outside of the loop), and the
|
2004-04-18 02:36:24 +08:00
|
|
|
// second must be derived from the same PHI.
|
|
|
|
bool SecondIsBackedge = L->contains(PN->getIncomingBlock(1));
|
|
|
|
Constant *StartCST =
|
|
|
|
dyn_cast<Constant>(PN->getIncomingValue(!SecondIsBackedge));
|
2009-06-28 05:21:31 +08:00
|
|
|
if (StartCST == 0) return getCouldNotCompute(); // Must be a constant.
|
2004-04-18 02:36:24 +08:00
|
|
|
|
|
|
|
Value *BEValue = PN->getIncomingValue(SecondIsBackedge);
|
2010-06-22 21:15:46 +08:00
|
|
|
if (getConstantEvolvingPHI(BEValue, L) != PN &&
|
|
|
|
!isa<Constant>(BEValue))
|
|
|
|
return getCouldNotCompute(); // Not derived from same PHI.
|
2004-04-18 02:36:24 +08:00
|
|
|
|
|
|
|
// Okay, we find a PHI node that defines the trip count of this loop. Execute
|
|
|
|
// the loop symbolically to determine when the condition gets a value of
|
|
|
|
// "ExitWhen".
|
|
|
|
unsigned IterationNum = 0;
|
|
|
|
unsigned MaxIterations = MaxBruteForceIterations; // Limit analysis.
|
|
|
|
for (Constant *PHIVal = StartCST;
|
|
|
|
IterationNum != MaxIterations; ++IterationNum) {
|
2007-01-11 20:24:14 +08:00
|
|
|
ConstantInt *CondVal =
|
2009-11-10 07:34:17 +08:00
|
|
|
dyn_cast_or_null<ConstantInt>(EvaluateExpression(Cond, PHIVal, TD));
|
2004-04-18 06:58:41 +08:00
|
|
|
|
2007-01-11 20:24:14 +08:00
|
|
|
// Couldn't symbolically evaluate.
|
2009-06-28 05:21:31 +08:00
|
|
|
if (!CondVal) return getCouldNotCompute();
|
2007-01-11 20:24:14 +08:00
|
|
|
|
2007-03-01 15:25:48 +08:00
|
|
|
if (CondVal->getValue() == uint64_t(ExitWhen)) {
|
2004-04-18 02:36:24 +08:00
|
|
|
++NumBruteForceTripCountsComputed;
|
2009-08-14 05:58:54 +08:00
|
|
|
return getConstant(Type::getInt32Ty(getContext()), IterationNum);
|
2004-04-18 02:36:24 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
// Compute the value of the PHI node for the next iteration.
|
2009-11-10 07:34:17 +08:00
|
|
|
Constant *NextPHI = EvaluateExpression(BEValue, PHIVal, TD);
|
2004-04-18 06:58:41 +08:00
|
|
|
if (NextPHI == 0 || NextPHI == PHIVal)
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();// Couldn't evaluate or not making progress...
|
2004-04-18 06:58:41 +08:00
|
|
|
PHIVal = NextPHI;
|
2004-04-18 02:36:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Too many iterations were needed to evaluate.
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-09-03 23:00:26 +08:00
|
|
|
/// getSCEVAtScope - Return a SCEV expression for the specified value
|
2009-05-09 04:38:54 +08:00
|
|
|
/// at the specified scope in the program. The L value specifies a loop
|
|
|
|
/// nest to evaluate the expression at, where null is the top-level or a
|
|
|
|
/// specified loop is immediately inside of the loop.
|
|
|
|
///
|
|
|
|
/// This method can be used to compute the exit value for a variable defined
|
|
|
|
/// in a loop by querying what the value will hold in the parent loop.
|
|
|
|
///
|
2009-05-25 07:25:42 +08:00
|
|
|
/// In the case that a relevant loop exit value cannot be computed, the
|
|
|
|
/// original value V is returned.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getSCEVAtScope(const SCEV *V, const Loop *L) {
|
2009-09-01 05:15:23 +08:00
|
|
|
// Check to see if we've folded this expression at this loop before.
|
|
|
|
std::map<const Loop *, const SCEV *> &Values = ValuesAtScopes[V];
|
|
|
|
std::pair<std::map<const Loop *, const SCEV *>::iterator, bool> Pair =
|
|
|
|
Values.insert(std::make_pair(L, static_cast<const SCEV *>(0)));
|
|
|
|
if (!Pair.second)
|
|
|
|
return Pair.first->second ? Pair.first->second : V;
|
|
|
|
|
|
|
|
// Otherwise compute it.
|
|
|
|
const SCEV *C = computeSCEVAtScope(V, L);
|
2009-09-01 05:58:28 +08:00
|
|
|
ValuesAtScopes[V][L] = C;
|
2009-09-01 05:15:23 +08:00
|
|
|
return C;
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-09-01 05:15:23 +08:00
|
|
|
const SCEV *ScalarEvolution::computeSCEVAtScope(const SCEV *V, const Loop *L) {
|
2004-04-18 06:58:41 +08:00
|
|
|
if (isa<SCEVConstant>(V)) return V;
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2008-02-20 14:48:22 +08:00
|
|
|
// If this instruction is evolved from a constant-evolving PHI, compute the
|
2004-04-18 06:58:41 +08:00
|
|
|
// exit value from the loop without using SCEVs.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(V)) {
|
2004-04-18 06:58:41 +08:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(SU->getValue())) {
|
2009-04-22 07:15:49 +08:00
|
|
|
const Loop *LI = (*this->LI)[I->getParent()];
|
2004-04-18 06:58:41 +08:00
|
|
|
if (LI && LI->getParentLoop() == L) // Looking for loop exit value.
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
if (PN->getParent() == LI->getHeader()) {
|
|
|
|
// Okay, there is no closed form solution for the PHI node. Check
|
2009-02-25 02:55:53 +08:00
|
|
|
// to see if the loop that contains it has a known backedge-taken
|
|
|
|
// count. If so, we may be able to force computation of the exit
|
|
|
|
// value.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *BackedgeTakenCount = getBackedgeTakenCount(LI);
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *BTCC =
|
2009-02-25 02:55:53 +08:00
|
|
|
dyn_cast<SCEVConstant>(BackedgeTakenCount)) {
|
2004-04-18 06:58:41 +08:00
|
|
|
// Okay, we know how many times the containing loop executes. If
|
|
|
|
// this is a constant evolving PHI node, get the final value at
|
|
|
|
// the specified iteration number.
|
|
|
|
Constant *RV = getConstantEvolutionLoopExitValue(PN,
|
2009-02-25 02:55:53 +08:00
|
|
|
BTCC->getValue()->getValue(),
|
2004-04-18 06:58:41 +08:00
|
|
|
LI);
|
2009-06-30 05:31:18 +08:00
|
|
|
if (RV) return getSCEV(RV);
|
2004-04-18 06:58:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-05 05:33:23 +08:00
|
|
|
// Okay, this is an expression that we cannot symbolically evaluate
|
2004-04-18 06:58:41 +08:00
|
|
|
// into a SCEV. Check to see if it's possible to symbolically evaluate
|
2006-12-05 05:33:23 +08:00
|
|
|
// the arguments into constants, and if so, try to constant propagate the
|
2004-04-18 06:58:41 +08:00
|
|
|
// result. This is particularly useful for computing loop exit values.
|
|
|
|
if (CanConstantFold(I)) {
|
2010-06-30 07:43:06 +08:00
|
|
|
SmallVector<Constant *, 4> Operands;
|
|
|
|
bool MadeImprovement = false;
|
2004-04-18 06:58:41 +08:00
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
|
|
|
|
Value *Op = I->getOperand(i);
|
|
|
|
if (Constant *C = dyn_cast<Constant>(Op)) {
|
|
|
|
Operands.push_back(C);
|
2010-06-30 07:43:06 +08:00
|
|
|
continue;
|
2004-04-18 06:58:41 +08:00
|
|
|
}
|
2010-06-30 07:43:06 +08:00
|
|
|
|
|
|
|
// If any of the operands is non-constant and if they are
|
|
|
|
// non-integer and non-pointer, don't even try to analyze them
|
|
|
|
// with scev techniques.
|
|
|
|
if (!isSCEVable(Op->getType()))
|
|
|
|
return V;
|
|
|
|
|
|
|
|
const SCEV *OrigV = getSCEV(Op);
|
|
|
|
const SCEV *OpV = getSCEVAtScope(OrigV, L);
|
|
|
|
MadeImprovement |= OrigV != OpV;
|
|
|
|
|
|
|
|
Constant *C = 0;
|
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(OpV))
|
|
|
|
C = SC->getValue();
|
|
|
|
if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(OpV))
|
|
|
|
C = dyn_cast<Constant>(SU->getValue());
|
|
|
|
if (!C) return V;
|
|
|
|
if (C->getType() != Op->getType())
|
|
|
|
C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false,
|
|
|
|
Op->getType(),
|
|
|
|
false),
|
|
|
|
C, Op->getType());
|
|
|
|
Operands.push_back(C);
|
2004-04-18 06:58:41 +08:00
|
|
|
}
|
2009-06-24 12:48:43 +08:00
|
|
|
|
2010-06-30 07:43:06 +08:00
|
|
|
// Check to see if getSCEVAtScope actually made an improvement.
|
|
|
|
if (MadeImprovement) {
|
|
|
|
Constant *C = 0;
|
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(I))
|
|
|
|
C = ConstantFoldCompareInstOperands(CI->getPredicate(),
|
|
|
|
Operands[0], Operands[1], TD);
|
|
|
|
else
|
|
|
|
C = ConstantFoldInstOperands(I->getOpcode(), I->getType(),
|
|
|
|
&Operands[0], Operands.size(), TD);
|
|
|
|
if (!C) return V;
|
2010-02-25 03:31:47 +08:00
|
|
|
return getSCEV(C);
|
2010-06-30 07:43:06 +08:00
|
|
|
}
|
2004-04-18 06:58:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is some other type of SCEVUnknown, just return it.
|
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVCommutativeExpr *Comm = dyn_cast<SCEVCommutativeExpr>(V)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// Avoid performing the look-up in the common case where the specified
|
|
|
|
// expression has no loop-variant portions.
|
|
|
|
for (unsigned i = 0, e = Comm->getNumOperands(); i != e; ++i) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (OpAtScope != Comm->getOperand(i)) {
|
|
|
|
// Okay, at least one of these operands is loop variant but might be
|
|
|
|
// foldable. Build a new instance of the folded commutative expression.
|
2009-06-24 12:48:43 +08:00
|
|
|
SmallVector<const SCEV *, 8> NewOps(Comm->op_begin(),
|
|
|
|
Comm->op_begin()+i);
|
2004-04-03 04:23:17 +08:00
|
|
|
NewOps.push_back(OpAtScope);
|
|
|
|
|
|
|
|
for (++i; i != e; ++i) {
|
|
|
|
OpAtScope = getSCEVAtScope(Comm->getOperand(i), L);
|
|
|
|
NewOps.push_back(OpAtScope);
|
|
|
|
}
|
|
|
|
if (isa<SCEVAddExpr>(Comm))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getAddExpr(NewOps);
|
2007-11-26 06:41:31 +08:00
|
|
|
if (isa<SCEVMulExpr>(Comm))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getMulExpr(NewOps);
|
2007-11-26 06:41:31 +08:00
|
|
|
if (isa<SCEVSMaxExpr>(Comm))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getSMaxExpr(NewOps);
|
2008-02-20 14:48:22 +08:00
|
|
|
if (isa<SCEVUMaxExpr>(Comm))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUMaxExpr(NewOps);
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Unknown commutative SCEV type!");
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// If we got here, all operands are loop invariant.
|
|
|
|
return Comm;
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVUDivExpr *Div = dyn_cast<SCEVUDivExpr>(V)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *LHS = getSCEVAtScope(Div->getLHS(), L);
|
|
|
|
const SCEV *RHS = getSCEVAtScope(Div->getRHS(), L);
|
2009-01-13 17:18:58 +08:00
|
|
|
if (LHS == Div->getLHS() && RHS == Div->getRHS())
|
|
|
|
return Div; // must be loop invariant
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUDivExpr(LHS, RHS);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If this is a loop recurrence for a loop that does not contain L, then we
|
|
|
|
// are dealing with the final value computed by the loop.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V)) {
|
2010-06-30 07:43:06 +08:00
|
|
|
// First, attempt to evaluate each operand.
|
|
|
|
// Avoid performing the look-up in the common case where the specified
|
|
|
|
// expression has no loop-variant portions.
|
|
|
|
for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
|
|
|
|
const SCEV *OpAtScope = getSCEVAtScope(AddRec->getOperand(i), L);
|
|
|
|
if (OpAtScope == AddRec->getOperand(i))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Okay, at least one of these operands is loop variant but might be
|
|
|
|
// foldable. Build a new instance of the folded commutative expression.
|
|
|
|
SmallVector<const SCEV *, 8> NewOps(AddRec->op_begin(),
|
|
|
|
AddRec->op_begin()+i);
|
|
|
|
NewOps.push_back(OpAtScope);
|
|
|
|
for (++i; i != e; ++i)
|
|
|
|
NewOps.push_back(getSCEVAtScope(AddRec->getOperand(i), L));
|
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
AddRec = cast<SCEVAddRecExpr>(
|
|
|
|
getAddRecExpr(NewOps, AddRec->getLoop(),
|
2011-03-15 08:37:00 +08:00
|
|
|
AddRec->getNoWrapFlags(SCEV::FlagNW)));
|
2010-06-30 07:43:06 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the scope is outside the addrec's loop, evaluate it by using the
|
|
|
|
// loop exit value of the addrec.
|
|
|
|
if (!AddRec->getLoop()->contains(L)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// To evaluate this recurrence, we need to know how many times the AddRec
|
|
|
|
// loop iterates. Compute this now.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *BackedgeTakenCount = getBackedgeTakenCount(AddRec->getLoop());
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BackedgeTakenCount == getCouldNotCompute()) return AddRec;
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2008-08-05 07:49:06 +08:00
|
|
|
// Then, evaluate the AddRec.
|
2009-04-22 07:15:49 +08:00
|
|
|
return AddRec->evaluateAtIteration(BackedgeTakenCount, *this);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2010-06-30 07:43:06 +08:00
|
|
|
|
2009-05-25 07:25:42 +08:00
|
|
|
return AddRec;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVZeroExtendExpr *Cast = dyn_cast<SCEVZeroExtendExpr>(V)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
|
2009-04-30 06:29:01 +08:00
|
|
|
if (Op == Cast->getOperand())
|
|
|
|
return Cast; // must be loop invariant
|
|
|
|
return getZeroExtendExpr(Op, Cast->getType());
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVSignExtendExpr *Cast = dyn_cast<SCEVSignExtendExpr>(V)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
|
2009-04-30 06:29:01 +08:00
|
|
|
if (Op == Cast->getOperand())
|
|
|
|
return Cast; // must be loop invariant
|
|
|
|
return getSignExtendExpr(Op, Cast->getType());
|
|
|
|
}
|
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVTruncateExpr *Cast = dyn_cast<SCEVTruncateExpr>(V)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Op = getSCEVAtScope(Cast->getOperand(), L);
|
2009-04-30 06:29:01 +08:00
|
|
|
if (Op == Cast->getOperand())
|
|
|
|
return Cast; // must be loop invariant
|
|
|
|
return getTruncateExpr(Op, Cast->getType());
|
|
|
|
}
|
|
|
|
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Unknown SCEV type!");
|
2009-05-19 00:43:04 +08:00
|
|
|
return 0;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-05-09 04:38:54 +08:00
|
|
|
/// getSCEVAtScope - This is a convenience function which does
|
|
|
|
/// getSCEVAtScope(getSCEV(V), L).
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getSCEVAtScope(Value *V, const Loop *L) {
|
2009-04-22 07:15:49 +08:00
|
|
|
return getSCEVAtScope(getSCEV(V), L);
|
|
|
|
}
|
|
|
|
|
2008-07-20 23:55:14 +08:00
|
|
|
/// SolveLinEquationWithOverflow - Finds the minimum unsigned root of the
|
|
|
|
/// following equation:
|
|
|
|
///
|
|
|
|
/// A * X = B (mod N)
|
|
|
|
///
|
|
|
|
/// where N = 2^BW and BW is the common bit width of A and B. The signedness of
|
|
|
|
/// A and B isn't important.
|
|
|
|
///
|
|
|
|
/// If the equation does not have a solution, SCEVCouldNotCompute is returned.
|
2009-07-08 01:06:11 +08:00
|
|
|
static const SCEV *SolveLinEquationWithOverflow(const APInt &A, const APInt &B,
|
2008-07-20 23:55:14 +08:00
|
|
|
ScalarEvolution &SE) {
|
|
|
|
uint32_t BW = A.getBitWidth();
|
|
|
|
assert(BW == B.getBitWidth() && "Bit widths must be the same.");
|
|
|
|
assert(A != 0 && "A must be non-zero.");
|
|
|
|
|
|
|
|
// 1. D = gcd(A, N)
|
|
|
|
//
|
|
|
|
// The gcd of A and N may have only one prime factor: 2. The number of
|
|
|
|
// trailing zeros in A is its multiplicity
|
|
|
|
uint32_t Mult2 = A.countTrailingZeros();
|
|
|
|
// D = 2^Mult2
|
|
|
|
|
|
|
|
// 2. Check if B is divisible by D.
|
|
|
|
//
|
|
|
|
// B is divisible by D if and only if the multiplicity of prime factor 2 for B
|
|
|
|
// is not less than multiplicity of this prime factor for D.
|
|
|
|
if (B.countTrailingZeros() < Mult2)
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute();
|
2008-07-20 23:55:14 +08:00
|
|
|
|
|
|
|
// 3. Compute I: the multiplicative inverse of (A / D) in arithmetic
|
|
|
|
// modulo (N / D).
|
|
|
|
//
|
|
|
|
// (N / D) may need BW+1 bits in its representation. Hence, we'll use this
|
|
|
|
// bit width during computations.
|
|
|
|
APInt AD = A.lshr(Mult2).zext(BW + 1); // AD = A / D
|
|
|
|
APInt Mod(BW + 1, 0);
|
2010-12-01 16:53:58 +08:00
|
|
|
Mod.setBit(BW - Mult2); // Mod = N / D
|
2008-07-20 23:55:14 +08:00
|
|
|
APInt I = AD.multiplicativeInverse(Mod);
|
|
|
|
|
|
|
|
// 4. Compute the minimum unsigned root of the equation:
|
|
|
|
// I * (B / D) mod (N / D)
|
|
|
|
APInt Result = (I * B.lshr(Mult2).zext(BW + 1)).urem(Mod);
|
|
|
|
|
|
|
|
// The result is guaranteed to be less than 2^BW so we may truncate it to BW
|
|
|
|
// bits.
|
|
|
|
return SE.getConstant(Result.trunc(BW));
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
/// SolveQuadraticEquation - Find the roots of the quadratic equation for the
|
|
|
|
/// given quadratic chrec {L,+,M,+,N}. This returns either the two roots (which
|
|
|
|
/// might be the same) or two SCEVCouldNotCompute objects.
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
static std::pair<const SCEV *,const SCEV *>
|
2007-10-23 02:31:58 +08:00
|
|
|
SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) {
|
2004-04-03 04:23:17 +08:00
|
|
|
assert(AddRec->getNumOperands() == 3 && "This is not a quadratic chrec!");
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVConstant *LC = dyn_cast<SCEVConstant>(AddRec->getOperand(0));
|
|
|
|
const SCEVConstant *MC = dyn_cast<SCEVConstant>(AddRec->getOperand(1));
|
|
|
|
const SCEVConstant *NC = dyn_cast<SCEVConstant>(AddRec->getOperand(2));
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// We currently can only solve this if the coefficients are constants.
|
2007-03-01 15:25:48 +08:00
|
|
|
if (!LC || !MC || !NC) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEV *CNC = SE.getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
return std::make_pair(CNC, CNC);
|
|
|
|
}
|
|
|
|
|
2007-03-01 15:25:48 +08:00
|
|
|
uint32_t BitWidth = LC->getValue()->getValue().getBitWidth();
|
2007-04-16 03:52:49 +08:00
|
|
|
const APInt &L = LC->getValue()->getValue();
|
|
|
|
const APInt &M = MC->getValue()->getValue();
|
|
|
|
const APInt &N = NC->getValue()->getValue();
|
2007-03-01 15:25:48 +08:00
|
|
|
APInt Two(BitWidth, 2);
|
|
|
|
APInt Four(BitWidth, 4);
|
|
|
|
|
2009-06-24 12:48:43 +08:00
|
|
|
{
|
2007-03-01 15:25:48 +08:00
|
|
|
using namespace APIntOps;
|
2007-04-08 01:48:27 +08:00
|
|
|
const APInt& C = L;
|
2007-03-01 15:25:48 +08:00
|
|
|
// Convert from chrec coefficients to polynomial coefficients AX^2+BX+C
|
|
|
|
// The B coefficient is M-N/2
|
|
|
|
APInt B(M);
|
|
|
|
B -= sdiv(N,Two);
|
|
|
|
|
|
|
|
// The A coefficient is N/2
|
2007-04-08 01:48:27 +08:00
|
|
|
APInt A(N.sdiv(Two));
|
2007-03-01 15:25:48 +08:00
|
|
|
|
|
|
|
// Compute the B^2-4ac term.
|
|
|
|
APInt SqrtTerm(B);
|
|
|
|
SqrtTerm *= B;
|
|
|
|
SqrtTerm -= Four * (A * C);
|
|
|
|
|
|
|
|
// Compute sqrt(B^2-4ac). This is guaranteed to be the nearest
|
|
|
|
// integer value or else APInt::sqrt() will assert.
|
|
|
|
APInt SqrtVal(SqrtTerm.sqrt());
|
|
|
|
|
2009-06-24 12:48:43 +08:00
|
|
|
// Compute the two solutions for the quadratic formula.
|
2007-03-01 15:25:48 +08:00
|
|
|
// The divisions must be performed as signed divisions.
|
|
|
|
APInt NegB(-B);
|
2007-04-16 10:24:41 +08:00
|
|
|
APInt TwoA( A << 1 );
|
2008-11-03 10:43:49 +08:00
|
|
|
if (TwoA.isMinValue()) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEV *CNC = SE.getCouldNotCompute();
|
2008-11-03 10:43:49 +08:00
|
|
|
return std::make_pair(CNC, CNC);
|
|
|
|
}
|
|
|
|
|
2009-07-22 08:24:57 +08:00
|
|
|
LLVMContext &Context = SE.getContext();
|
2009-07-07 06:37:39 +08:00
|
|
|
|
|
|
|
ConstantInt *Solution1 =
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt::get(Context, (NegB + SqrtVal).sdiv(TwoA));
|
2009-07-07 06:37:39 +08:00
|
|
|
ConstantInt *Solution2 =
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt::get(Context, (NegB - SqrtVal).sdiv(TwoA));
|
2007-03-01 15:25:48 +08:00
|
|
|
|
2009-06-24 12:48:43 +08:00
|
|
|
return std::make_pair(SE.getConstant(Solution1),
|
2007-10-23 02:31:58 +08:00
|
|
|
SE.getConstant(Solution2));
|
2007-03-01 15:25:48 +08:00
|
|
|
} // end APIntOps namespace
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// HowFarToZero - Return the number of times a backedge comparing the specified
|
2009-06-06 22:37:11 +08:00
|
|
|
/// value to zero will execute. If not computable, return CouldNotCompute.
|
2011-03-15 00:50:06 +08:00
|
|
|
///
|
|
|
|
/// This is only used for loops with a "x != y" exit test. The exit condition is
|
|
|
|
/// now expressed as a single expression, V = x-y. So the exit test is
|
|
|
|
/// effectively V != 0. We know and take advantage of the fact that this
|
|
|
|
/// expression only being used in a comparison by zero context.
|
2010-02-25 01:31:30 +08:00
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If the value is a constant
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If the value is already zero, the branch will execute zero times.
|
2007-03-02 08:28:52 +08:00
|
|
|
if (C->getValue()->isZero()) return C;
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute(); // Otherwise it will loop infinitely.
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(V);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (!AddRec || AddRec->getLoop() != L)
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2011-01-10 06:39:48 +08:00
|
|
|
// If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of
|
|
|
|
// the quadratic equation to solve it.
|
|
|
|
if (AddRec->isQuadratic() && AddRec->getType()->isIntegerTy()) {
|
|
|
|
std::pair<const SCEV *,const SCEV *> Roots =
|
|
|
|
SolveQuadraticEquation(AddRec, *this);
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVConstant *R1 = dyn_cast<SCEVConstant>(Roots.first);
|
|
|
|
const SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
|
2011-01-10 06:39:48 +08:00
|
|
|
if (R1 && R2) {
|
2004-04-03 04:26:46 +08:00
|
|
|
#if 0
|
2009-12-24 06:18:14 +08:00
|
|
|
dbgs() << "HFTZ: " << *V << " - sol#1: " << *R1
|
2009-04-21 08:47:46 +08:00
|
|
|
<< " sol#2: " << *R2 << "\n";
|
2004-04-03 04:26:46 +08:00
|
|
|
#endif
|
2004-04-03 04:23:17 +08:00
|
|
|
// Pick the smallest positive root value.
|
2007-01-11 20:24:14 +08:00
|
|
|
if (ConstantInt *CB =
|
2011-01-10 06:58:47 +08:00
|
|
|
dyn_cast<ConstantInt>(ConstantExpr::getICmp(CmpInst::ICMP_ULT,
|
|
|
|
R1->getValue(),
|
|
|
|
R2->getValue()))) {
|
2007-01-12 12:24:46 +08:00
|
|
|
if (CB->getZExtValue() == false)
|
2004-04-03 04:23:17 +08:00
|
|
|
std::swap(R1, R2); // R1 is the minimum root now.
|
2011-03-10 01:23:39 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// 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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Val = AddRec->evaluateAtIteration(R1, *this);
|
2008-06-19 00:23:07 +08:00
|
|
|
if (Val->isZero())
|
|
|
|
return R1; // We found a quadratic root!
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
}
|
2011-01-10 06:39:48 +08:00
|
|
|
return getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2011-01-10 06:39:48 +08:00
|
|
|
// Otherwise we can only handle this if it is affine.
|
|
|
|
if (!AddRec->isAffine())
|
|
|
|
return getCouldNotCompute();
|
|
|
|
|
|
|
|
// If this is an affine expression, the execution count of this branch is
|
|
|
|
// the minimum unsigned root of the following equation:
|
|
|
|
//
|
|
|
|
// Start + Step*N = 0 (mod 2^BW)
|
|
|
|
//
|
|
|
|
// equivalent to:
|
|
|
|
//
|
|
|
|
// Step*N = -Start (mod 2^BW)
|
|
|
|
//
|
|
|
|
// where BW is the common bit width of Start and Step.
|
|
|
|
|
|
|
|
// Get the initial value for the loop.
|
|
|
|
const SCEV *Start = getSCEVAtScope(AddRec->getStart(), L->getParentLoop());
|
|
|
|
const SCEV *Step = getSCEVAtScope(AddRec->getOperand(1), L->getParentLoop());
|
|
|
|
|
|
|
|
// For now we handle only constant steps.
|
2011-03-15 00:50:06 +08:00
|
|
|
//
|
|
|
|
// TODO: Handle a nonconstant Step given AddRec<NUW>. If the
|
|
|
|
// AddRec is NUW, then (in an unsigned sense) it cannot be counting up to wrap
|
|
|
|
// to 0, it must be counting down to equal 0. Consequently, N = Start / -Step.
|
|
|
|
// We have not yet seen any such cases.
|
2011-01-10 06:39:48 +08:00
|
|
|
const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step);
|
|
|
|
if (StepC == 0)
|
|
|
|
return getCouldNotCompute();
|
|
|
|
|
2011-03-15 00:50:06 +08:00
|
|
|
// For positive steps (counting up until unsigned overflow):
|
|
|
|
// N = -Start/Step (as unsigned)
|
|
|
|
// For negative steps (counting down to zero):
|
|
|
|
// N = Start/-Step
|
|
|
|
// First compute the unsigned distance from zero in the direction of Step.
|
2011-03-15 01:28:02 +08:00
|
|
|
bool CountDown = StepC->getValue()->getValue().isNegative();
|
|
|
|
const SCEV *Distance = CountDown ? Start : getNegativeSCEV(Start);
|
2011-03-15 00:50:06 +08:00
|
|
|
|
|
|
|
// Handle unitary steps, which cannot wraparound.
|
2011-03-15 01:28:02 +08:00
|
|
|
// 1*N = -Start; -1*N = Start (mod 2^BW), so:
|
|
|
|
// N = Distance (as unsigned)
|
|
|
|
if (StepC->getValue()->equalsInt(1) || StepC->getValue()->isAllOnesValue())
|
|
|
|
return Distance;
|
|
|
|
|
|
|
|
// If the recurrence is known not to wraparound, unsigned divide computes the
|
|
|
|
// back edge count. We know that the value will either become zero (and thus
|
|
|
|
// the loop terminates), that the loop will terminate through some other exit
|
|
|
|
// condition first, or that the loop has undefined behavior. This means
|
|
|
|
// we can't "miss" the exit value, even with nonunit stride.
|
|
|
|
//
|
|
|
|
// FIXME: Prove that loops always exhibits *acceptable* undefined
|
|
|
|
// behavior. Loops must exhibit defined behavior until a wrapped value is
|
|
|
|
// actually used. So the trip count computed by udiv could be smaller than the
|
|
|
|
// number of well-defined iterations.
|
|
|
|
if (AddRec->getNoWrapFlags(SCEV::FlagNW))
|
|
|
|
// FIXME: We really want an "isexact" bit for udiv.
|
|
|
|
return getUDivExpr(Distance, CountDown ? getNegativeSCEV(Step) : Step);
|
2011-01-10 06:39:48 +08:00
|
|
|
|
|
|
|
// Then, try to solve the above equation provided that Start is constant.
|
|
|
|
if (const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start))
|
|
|
|
return SolveLinEquationWithOverflow(StepC->getValue()->getValue(),
|
|
|
|
-StartC->getValue()->getValue(),
|
|
|
|
*this);
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// HowFarToNonZero - Return the number of times a backedge checking the
|
|
|
|
/// specified value for nonzero will execute. If not computable, return
|
2009-06-06 22:37:11 +08:00
|
|
|
/// CouldNotCompute
|
2010-02-25 01:31:30 +08:00
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::HowFarToNonZero(const SCEV *V, const Loop *L) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// Loops that look like: while (X == 0) are very strange indeed. We don't
|
|
|
|
// handle them yet except for the trivial case. This could be expanded in the
|
|
|
|
// future as needed.
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// If the value is a constant, check to see if it is known to be non-zero
|
|
|
|
// already. If so, the backedge will execute zero times.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
|
2008-02-21 17:14:53 +08:00
|
|
|
if (!C->getValue()->isNullValue())
|
2010-05-04 06:09:21 +08:00
|
|
|
return getConstant(C->getType(), 0);
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute(); // Otherwise it will loop infinitely.
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// We could implement others, but I really doubt anyone writes loops like
|
|
|
|
// this, and if they did, they would already be constant folded.
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2008-09-16 06:18:04 +08:00
|
|
|
/// getPredecessorWithUniqueSuccessorForBB - Return a predecessor of BB
|
|
|
|
/// (which may not be an immediate predecessor) which has exactly one
|
|
|
|
/// successor from which BB is reachable, or null if no such block is
|
|
|
|
/// found.
|
|
|
|
///
|
2010-04-16 00:19:08 +08:00
|
|
|
std::pair<BasicBlock *, BasicBlock *>
|
2009-04-22 07:15:49 +08:00
|
|
|
ScalarEvolution::getPredecessorWithUniqueSuccessorForBB(BasicBlock *BB) {
|
2009-05-01 04:48:53 +08:00
|
|
|
// If the block has a unique predecessor, then there is no path from the
|
|
|
|
// predecessor to the block that does not go through the direct edge
|
|
|
|
// from the predecessor to the block.
|
2008-09-16 06:18:04 +08:00
|
|
|
if (BasicBlock *Pred = BB->getSinglePredecessor())
|
2010-04-16 00:19:08 +08:00
|
|
|
return std::make_pair(Pred, BB);
|
2008-09-16 06:18:04 +08:00
|
|
|
|
|
|
|
// A loop's header is defined to be a block that dominates the loop.
|
2009-05-18 23:36:09 +08:00
|
|
|
// If the header has a unique predecessor outside the loop, it must be
|
|
|
|
// a block that has exactly one successor that can reach the loop.
|
2009-04-22 07:15:49 +08:00
|
|
|
if (Loop *L = LI->getLoopFor(BB))
|
2010-06-23 07:43:28 +08:00
|
|
|
return std::make_pair(L->getLoopPredecessor(), L->getHeader());
|
2008-09-16 06:18:04 +08:00
|
|
|
|
2010-04-16 00:19:08 +08:00
|
|
|
return std::pair<BasicBlock *, BasicBlock *>();
|
2008-09-16 06:18:04 +08:00
|
|
|
}
|
|
|
|
|
2009-06-20 08:35:32 +08:00
|
|
|
/// HasSameValue - SCEV structural equivalence is usually sufficient for
|
|
|
|
/// testing whether two expressions are equal, however for the purposes of
|
|
|
|
/// looking for a condition guarding a loop, it can be useful to be a little
|
|
|
|
/// more general, since a front-end may have replicated the controlling
|
|
|
|
/// expression.
|
|
|
|
///
|
2009-07-08 01:06:11 +08:00
|
|
|
static bool HasSameValue(const SCEV *A, const SCEV *B) {
|
2009-06-20 08:35:32 +08:00
|
|
|
// Quick check to see if they are the same SCEV.
|
|
|
|
if (A == B) return true;
|
|
|
|
|
|
|
|
// Otherwise, if they're both SCEVUnknown, it's possible that they hold
|
|
|
|
// two different instructions with the same value. Check for this case.
|
|
|
|
if (const SCEVUnknown *AU = dyn_cast<SCEVUnknown>(A))
|
|
|
|
if (const SCEVUnknown *BU = dyn_cast<SCEVUnknown>(B))
|
|
|
|
if (const Instruction *AI = dyn_cast<Instruction>(AU->getValue()))
|
|
|
|
if (const Instruction *BI = dyn_cast<Instruction>(BU->getValue()))
|
2009-08-26 01:56:57 +08:00
|
|
|
if (AI->isIdenticalTo(BI) && !AI->mayReadFromMemory())
|
2009-06-20 08:35:32 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise assume they may have a different value.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-04-24 09:28:42 +08:00
|
|
|
/// SimplifyICmpOperands - Simplify LHS and RHS in a comparison with
|
|
|
|
/// predicate Pred. Return true iff any changes were made.
|
|
|
|
///
|
|
|
|
bool ScalarEvolution::SimplifyICmpOperands(ICmpInst::Predicate &Pred,
|
|
|
|
const SCEV *&LHS, const SCEV *&RHS) {
|
|
|
|
bool Changed = false;
|
|
|
|
|
|
|
|
// Canonicalize a constant to the right side.
|
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
|
|
|
|
// Check for both operands constant.
|
|
|
|
if (const SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS)) {
|
|
|
|
if (ConstantExpr::getICmp(Pred,
|
|
|
|
LHSC->getValue(),
|
|
|
|
RHSC->getValue())->isNullValue())
|
|
|
|
goto trivially_false;
|
|
|
|
else
|
|
|
|
goto trivially_true;
|
|
|
|
}
|
|
|
|
// Otherwise swap the operands to put the constant on the right.
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
Pred = ICmpInst::getSwappedPredicate(Pred);
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we're comparing an addrec with a value which is loop-invariant in the
|
2010-05-04 01:00:11 +08:00
|
|
|
// addrec's loop, put the addrec on the left. Also make a dominance check,
|
|
|
|
// as both operands could be addrecs loop-invariant in each other's loop.
|
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS)) {
|
|
|
|
const Loop *L = AR->getLoop();
|
2010-11-18 05:41:58 +08:00
|
|
|
if (isLoopInvariant(LHS, L) && properlyDominates(LHS, L->getHeader())) {
|
2010-04-24 09:28:42 +08:00
|
|
|
std::swap(LHS, RHS);
|
|
|
|
Pred = ICmpInst::getSwappedPredicate(Pred);
|
|
|
|
Changed = true;
|
|
|
|
}
|
2010-05-04 01:00:11 +08:00
|
|
|
}
|
2010-04-24 09:28:42 +08:00
|
|
|
|
|
|
|
// If there's a constant operand, canonicalize comparisons with boundary
|
|
|
|
// cases, and canonicalize *-or-equal comparisons to regular comparisons.
|
|
|
|
if (const SCEVConstant *RC = dyn_cast<SCEVConstant>(RHS)) {
|
|
|
|
const APInt &RA = RC->getValue()->getValue();
|
|
|
|
switch (Pred) {
|
|
|
|
default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
|
|
|
|
case ICmpInst::ICMP_EQ:
|
|
|
|
case ICmpInst::ICMP_NE:
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_UGE:
|
|
|
|
if ((RA - 1).isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinValue()) goto trivially_true;
|
|
|
|
|
|
|
|
Pred = ICmpInst::ICMP_UGT;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULE:
|
|
|
|
if ((RA + 1).isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxValue()) goto trivially_true;
|
|
|
|
|
|
|
|
Pred = ICmpInst::ICMP_ULT;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGE:
|
|
|
|
if ((RA - 1).isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinSignedValue()) goto trivially_true;
|
|
|
|
|
|
|
|
Pred = ICmpInst::ICMP_SGT;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SLE:
|
|
|
|
if ((RA + 1).isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxSignedValue()) goto trivially_true;
|
|
|
|
|
|
|
|
Pred = ICmpInst::ICMP_SLT;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_UGT:
|
|
|
|
if (RA.isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA + 1).isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxValue()) goto trivially_false;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULT:
|
|
|
|
if (RA.isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA - 1).isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinValue()) goto trivially_false;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGT:
|
|
|
|
if (RA.isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA + 1).isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxSignedValue()) goto trivially_false;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SLT:
|
|
|
|
if (RA.isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA - 1).isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
Changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinSignedValue()) goto trivially_false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for obvious equality.
|
|
|
|
if (HasSameValue(LHS, RHS)) {
|
|
|
|
if (ICmpInst::isTrueWhenEqual(Pred))
|
|
|
|
goto trivially_true;
|
|
|
|
if (ICmpInst::isFalseWhenEqual(Pred))
|
|
|
|
goto trivially_false;
|
|
|
|
}
|
|
|
|
|
2010-05-04 00:35:17 +08:00
|
|
|
// If possible, canonicalize GE/LE comparisons to GT/LT comparisons, by
|
|
|
|
// adding or subtracting 1 from one of the operands.
|
|
|
|
switch (Pred) {
|
|
|
|
case ICmpInst::ICMP_SLE:
|
|
|
|
if (!getSignedRange(RHS).getSignedMax().isMaxSignedValue()) {
|
|
|
|
RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNSW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_SLT;
|
|
|
|
Changed = true;
|
|
|
|
} else if (!getSignedRange(LHS).getSignedMin().isMinSignedValue()) {
|
2010-05-04 04:23:47 +08:00
|
|
|
LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNSW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_SLT;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGE:
|
|
|
|
if (!getSignedRange(RHS).getSignedMin().isMinSignedValue()) {
|
2010-05-04 04:23:47 +08:00
|
|
|
RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNSW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_SGT;
|
|
|
|
Changed = true;
|
|
|
|
} else if (!getSignedRange(LHS).getSignedMax().isMaxSignedValue()) {
|
|
|
|
LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNSW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_SGT;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULE:
|
|
|
|
if (!getUnsignedRange(RHS).getUnsignedMax().isMaxValue()) {
|
2010-05-04 04:23:47 +08:00
|
|
|
RHS = getAddExpr(getConstant(RHS->getType(), 1, true), RHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNUW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_ULT;
|
|
|
|
Changed = true;
|
|
|
|
} else if (!getUnsignedRange(LHS).getUnsignedMin().isMinValue()) {
|
2010-05-04 04:23:47 +08:00
|
|
|
LHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), LHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNUW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_ULT;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_UGE:
|
|
|
|
if (!getUnsignedRange(RHS).getUnsignedMin().isMinValue()) {
|
2010-05-04 04:23:47 +08:00
|
|
|
RHS = getAddExpr(getConstant(RHS->getType(), (uint64_t)-1, true), RHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNUW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_UGT;
|
|
|
|
Changed = true;
|
|
|
|
} else if (!getUnsignedRange(LHS).getUnsignedMax().isMaxValue()) {
|
2010-05-04 04:23:47 +08:00
|
|
|
LHS = getAddExpr(getConstant(RHS->getType(), 1, true), LHS,
|
2011-03-15 00:50:06 +08:00
|
|
|
SCEV::FlagNUW);
|
2010-05-04 00:35:17 +08:00
|
|
|
Pred = ICmpInst::ICMP_UGT;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-04-24 09:28:42 +08:00
|
|
|
// TODO: More simplifications are possible here.
|
|
|
|
|
|
|
|
return Changed;
|
|
|
|
|
|
|
|
trivially_true:
|
|
|
|
// Return 0 == 0.
|
2010-11-21 02:43:35 +08:00
|
|
|
LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
|
2010-04-24 09:28:42 +08:00
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
trivially_false:
|
|
|
|
// Return 0 != 0.
|
2010-11-21 02:43:35 +08:00
|
|
|
LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
|
2010-04-24 09:28:42 +08:00
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
bool ScalarEvolution::isKnownNegative(const SCEV *S) {
|
|
|
|
return getSignedRange(S).getSignedMax().isNegative();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::isKnownPositive(const SCEV *S) {
|
|
|
|
return getSignedRange(S).getSignedMin().isStrictlyPositive();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::isKnownNonNegative(const SCEV *S) {
|
|
|
|
return !getSignedRange(S).getSignedMin().isNegative();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::isKnownNonPositive(const SCEV *S) {
|
|
|
|
return !getSignedRange(S).getSignedMax().isStrictlyPositive();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::isKnownNonZero(const SCEV *S) {
|
|
|
|
return isKnownNegative(S) || isKnownPositive(S);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::isKnownPredicate(ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS) {
|
2010-04-24 09:38:36 +08:00
|
|
|
// Canonicalize the inputs first.
|
|
|
|
(void)SimplifyICmpOperands(Pred, LHS, RHS);
|
|
|
|
|
2010-04-12 06:16:48 +08:00
|
|
|
// If LHS or RHS is an addrec, check to see if the condition is true in
|
|
|
|
// every iteration of the loop.
|
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(LHS))
|
|
|
|
if (isLoopEntryGuardedByCond(
|
|
|
|
AR->getLoop(), Pred, AR->getStart(), RHS) &&
|
|
|
|
isLoopBackedgeGuardedByCond(
|
2010-05-04 09:12:27 +08:00
|
|
|
AR->getLoop(), Pred, AR->getPostIncExpr(*this), RHS))
|
2010-04-12 06:16:48 +08:00
|
|
|
return true;
|
|
|
|
if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(RHS))
|
|
|
|
if (isLoopEntryGuardedByCond(
|
|
|
|
AR->getLoop(), Pred, LHS, AR->getStart()) &&
|
|
|
|
isLoopBackedgeGuardedByCond(
|
2010-05-04 09:12:27 +08:00
|
|
|
AR->getLoop(), Pred, LHS, AR->getPostIncExpr(*this)))
|
2010-04-12 06:16:48 +08:00
|
|
|
return true;
|
2009-07-14 05:35:55 +08:00
|
|
|
|
2010-04-12 06:16:48 +08:00
|
|
|
// Otherwise see what can be done with known constant ranges.
|
|
|
|
return isKnownPredicateWithRanges(Pred, LHS, RHS);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ScalarEvolution::isKnownPredicateWithRanges(ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS) {
|
2009-07-14 05:35:55 +08:00
|
|
|
if (HasSameValue(LHS, RHS))
|
|
|
|
return ICmpInst::isTrueWhenEqual(Pred);
|
|
|
|
|
2010-04-12 06:16:48 +08:00
|
|
|
// This code is split out from isKnownPredicate because it is called from
|
|
|
|
// within isLoopEntryGuardedByCond.
|
2009-07-14 05:35:55 +08:00
|
|
|
switch (Pred) {
|
|
|
|
default:
|
2009-07-17 01:34:36 +08:00
|
|
|
llvm_unreachable("Unexpected ICmpInst::Predicate value!");
|
2009-07-14 05:35:55 +08:00
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGT:
|
|
|
|
Pred = ICmpInst::ICMP_SLT;
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
case ICmpInst::ICMP_SLT: {
|
|
|
|
ConstantRange LHSRange = getSignedRange(LHS);
|
|
|
|
ConstantRange RHSRange = getSignedRange(RHS);
|
|
|
|
if (LHSRange.getSignedMax().slt(RHSRange.getSignedMin()))
|
|
|
|
return true;
|
|
|
|
if (LHSRange.getSignedMin().sge(RHSRange.getSignedMax()))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_SGE:
|
|
|
|
Pred = ICmpInst::ICMP_SLE;
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
case ICmpInst::ICMP_SLE: {
|
|
|
|
ConstantRange LHSRange = getSignedRange(LHS);
|
|
|
|
ConstantRange RHSRange = getSignedRange(RHS);
|
|
|
|
if (LHSRange.getSignedMax().sle(RHSRange.getSignedMin()))
|
|
|
|
return true;
|
|
|
|
if (LHSRange.getSignedMin().sgt(RHSRange.getSignedMax()))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_UGT:
|
|
|
|
Pred = ICmpInst::ICMP_ULT;
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
case ICmpInst::ICMP_ULT: {
|
|
|
|
ConstantRange LHSRange = getUnsignedRange(LHS);
|
|
|
|
ConstantRange RHSRange = getUnsignedRange(RHS);
|
|
|
|
if (LHSRange.getUnsignedMax().ult(RHSRange.getUnsignedMin()))
|
|
|
|
return true;
|
|
|
|
if (LHSRange.getUnsignedMin().uge(RHSRange.getUnsignedMax()))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_UGE:
|
|
|
|
Pred = ICmpInst::ICMP_ULE;
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
case ICmpInst::ICMP_ULE: {
|
|
|
|
ConstantRange LHSRange = getUnsignedRange(LHS);
|
|
|
|
ConstantRange RHSRange = getUnsignedRange(RHS);
|
|
|
|
if (LHSRange.getUnsignedMax().ule(RHSRange.getUnsignedMin()))
|
|
|
|
return true;
|
|
|
|
if (LHSRange.getUnsignedMin().ugt(RHSRange.getUnsignedMax()))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_NE: {
|
|
|
|
if (getUnsignedRange(LHS).intersectWith(getUnsignedRange(RHS)).isEmptySet())
|
|
|
|
return true;
|
|
|
|
if (getSignedRange(LHS).intersectWith(getSignedRange(RHS)).isEmptySet())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
const SCEV *Diff = getMinusSCEV(LHS, RHS);
|
|
|
|
if (isKnownNonZero(Diff))
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_EQ:
|
2009-07-21 07:54:43 +08:00
|
|
|
// The check at the top of the function catches the case where
|
|
|
|
// the values are known to be equal.
|
2009-07-14 05:35:55 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isLoopBackedgeGuardedByCond - Test whether the backedge of the loop is
|
|
|
|
/// protected by a conditional between LHS and RHS. This is used to
|
|
|
|
/// to eliminate casts.
|
|
|
|
bool
|
|
|
|
ScalarEvolution::isLoopBackedgeGuardedByCond(const Loop *L,
|
|
|
|
ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS) {
|
|
|
|
// Interpret a null as meaning no loop, where there is obviously no guard
|
|
|
|
// (interprocedural conditions notwithstanding).
|
|
|
|
if (!L) return true;
|
|
|
|
|
|
|
|
BasicBlock *Latch = L->getLoopLatch();
|
|
|
|
if (!Latch)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
BranchInst *LoopContinuePredicate =
|
|
|
|
dyn_cast<BranchInst>(Latch->getTerminator());
|
|
|
|
if (!LoopContinuePredicate ||
|
|
|
|
LoopContinuePredicate->isUnconditional())
|
|
|
|
return false;
|
|
|
|
|
2010-08-11 07:46:30 +08:00
|
|
|
return isImpliedCond(Pred, LHS, RHS,
|
|
|
|
LoopContinuePredicate->getCondition(),
|
2009-07-22 07:03:19 +08:00
|
|
|
LoopContinuePredicate->getSuccessor(0) != L->getHeader());
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
2010-04-12 03:27:13 +08:00
|
|
|
/// isLoopEntryGuardedByCond - Test whether entry to the loop is protected
|
2009-07-14 05:35:55 +08:00
|
|
|
/// by a conditional between LHS and RHS. This is used to help avoid max
|
|
|
|
/// expressions in loop trip counts, and to eliminate casts.
|
|
|
|
bool
|
2010-04-12 03:27:13 +08:00
|
|
|
ScalarEvolution::isLoopEntryGuardedByCond(const Loop *L,
|
|
|
|
ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS) {
|
2009-05-19 00:03:58 +08:00
|
|
|
// Interpret a null as meaning no loop, where there is obviously no guard
|
|
|
|
// (interprocedural conditions notwithstanding).
|
|
|
|
if (!L) return false;
|
|
|
|
|
2009-05-18 23:36:09 +08:00
|
|
|
// Starting at the loop predecessor, climb up the predecessor chain, as long
|
|
|
|
// as there are predecessors that can be found that have unique successors
|
2008-09-16 06:18:04 +08:00
|
|
|
// leading to the original header.
|
2010-04-16 00:19:08 +08:00
|
|
|
for (std::pair<BasicBlock *, BasicBlock *>
|
2010-06-23 07:43:28 +08:00
|
|
|
Pair(L->getLoopPredecessor(), L->getHeader());
|
2010-04-16 00:19:08 +08:00
|
|
|
Pair.first;
|
|
|
|
Pair = getPredecessorWithUniqueSuccessorForBB(Pair.first)) {
|
2008-07-12 15:41:32 +08:00
|
|
|
|
2008-08-13 04:17:31 +08:00
|
|
|
BranchInst *LoopEntryPredicate =
|
2010-04-16 00:19:08 +08:00
|
|
|
dyn_cast<BranchInst>(Pair.first->getTerminator());
|
2008-08-13 04:17:31 +08:00
|
|
|
if (!LoopEntryPredicate ||
|
|
|
|
LoopEntryPredicate->isUnconditional())
|
|
|
|
continue;
|
|
|
|
|
2010-08-11 07:46:30 +08:00
|
|
|
if (isImpliedCond(Pred, LHS, RHS,
|
|
|
|
LoopEntryPredicate->getCondition(),
|
2010-04-16 00:19:08 +08:00
|
|
|
LoopEntryPredicate->getSuccessor(0) != Pair.second))
|
2009-06-24 09:18:18 +08:00
|
|
|
return true;
|
|
|
|
}
|
2008-08-13 04:17:31 +08:00
|
|
|
|
2009-06-24 09:18:18 +08:00
|
|
|
return false;
|
|
|
|
}
|
2008-08-13 04:17:31 +08:00
|
|
|
|
2009-07-22 07:03:19 +08:00
|
|
|
/// isImpliedCond - Test whether the condition described by Pred, LHS,
|
|
|
|
/// and RHS is true whenever the given Cond value evaluates to true.
|
2010-08-11 07:46:30 +08:00
|
|
|
bool ScalarEvolution::isImpliedCond(ICmpInst::Predicate Pred,
|
2009-07-22 07:03:19 +08:00
|
|
|
const SCEV *LHS, const SCEV *RHS,
|
2010-08-11 07:46:30 +08:00
|
|
|
Value *FoundCondValue,
|
2009-07-22 07:03:19 +08:00
|
|
|
bool Inverse) {
|
2010-03-02 01:49:51 +08:00
|
|
|
// Recursively handle And and Or conditions.
|
2010-08-11 07:46:30 +08:00
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FoundCondValue)) {
|
2009-06-24 09:18:18 +08:00
|
|
|
if (BO->getOpcode() == Instruction::And) {
|
|
|
|
if (!Inverse)
|
2010-08-11 07:46:30 +08:00
|
|
|
return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
|
|
|
|
isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
|
2009-06-24 09:18:18 +08:00
|
|
|
} else if (BO->getOpcode() == Instruction::Or) {
|
|
|
|
if (Inverse)
|
2010-08-11 07:46:30 +08:00
|
|
|
return isImpliedCond(Pred, LHS, RHS, BO->getOperand(0), Inverse) ||
|
|
|
|
isImpliedCond(Pred, LHS, RHS, BO->getOperand(1), Inverse);
|
2009-06-24 09:18:18 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-11 07:46:30 +08:00
|
|
|
ICmpInst *ICI = dyn_cast<ICmpInst>(FoundCondValue);
|
2009-06-24 09:18:18 +08:00
|
|
|
if (!ICI) return false;
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
// Bail if the ICmp's operands' types are wider than the needed type
|
|
|
|
// before attempting to call getSCEV on them. This avoids infinite
|
|
|
|
// recursion, since the analysis of widening casts can require loop
|
|
|
|
// exit condition information for overflow checking, which would
|
|
|
|
// lead back here.
|
|
|
|
if (getTypeSizeInBits(LHS->getType()) <
|
2009-07-22 07:03:19 +08:00
|
|
|
getTypeSizeInBits(ICI->getOperand(0)->getType()))
|
2009-07-14 05:35:55 +08:00
|
|
|
return false;
|
2008-07-12 15:41:32 +08:00
|
|
|
|
2009-07-22 07:03:19 +08:00
|
|
|
// Now that we found a conditional branch that dominates the loop, check to
|
|
|
|
// see if it is the comparison we are looking for.
|
|
|
|
ICmpInst::Predicate FoundPred;
|
|
|
|
if (Inverse)
|
|
|
|
FoundPred = ICI->getInversePredicate();
|
|
|
|
else
|
|
|
|
FoundPred = ICI->getPredicate();
|
|
|
|
|
|
|
|
const SCEV *FoundLHS = getSCEV(ICI->getOperand(0));
|
|
|
|
const SCEV *FoundRHS = getSCEV(ICI->getOperand(1));
|
2009-07-14 05:35:55 +08:00
|
|
|
|
|
|
|
// Balance the types. The case where FoundLHS' type is wider than
|
|
|
|
// LHS' type is checked for above.
|
|
|
|
if (getTypeSizeInBits(LHS->getType()) >
|
|
|
|
getTypeSizeInBits(FoundLHS->getType())) {
|
|
|
|
if (CmpInst::isSigned(Pred)) {
|
|
|
|
FoundLHS = getSignExtendExpr(FoundLHS, LHS->getType());
|
|
|
|
FoundRHS = getSignExtendExpr(FoundRHS, LHS->getType());
|
|
|
|
} else {
|
|
|
|
FoundLHS = getZeroExtendExpr(FoundLHS, LHS->getType());
|
|
|
|
FoundRHS = getZeroExtendExpr(FoundRHS, LHS->getType());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-22 07:03:19 +08:00
|
|
|
// Canonicalize the query to match the way instcombine will have
|
|
|
|
// canonicalized the comparison.
|
2010-04-24 09:34:53 +08:00
|
|
|
if (SimplifyICmpOperands(Pred, LHS, RHS))
|
|
|
|
if (LHS == RHS)
|
2010-05-04 02:00:24 +08:00
|
|
|
return CmpInst::isTrueWhenEqual(Pred);
|
2010-04-24 09:34:53 +08:00
|
|
|
if (SimplifyICmpOperands(FoundPred, FoundLHS, FoundRHS))
|
|
|
|
if (FoundLHS == FoundRHS)
|
2010-05-04 02:00:24 +08:00
|
|
|
return CmpInst::isFalseWhenEqual(Pred);
|
2009-07-22 07:03:19 +08:00
|
|
|
|
|
|
|
// Check to see if we can make the LHS or RHS match.
|
|
|
|
if (LHS == FoundRHS || RHS == FoundLHS) {
|
|
|
|
if (isa<SCEVConstant>(RHS)) {
|
|
|
|
std::swap(FoundLHS, FoundRHS);
|
|
|
|
FoundPred = ICmpInst::getSwappedPredicate(FoundPred);
|
|
|
|
} else {
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
Pred = ICmpInst::getSwappedPredicate(Pred);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check whether the found predicate is the same as the desired predicate.
|
|
|
|
if (FoundPred == Pred)
|
|
|
|
return isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS);
|
|
|
|
|
|
|
|
// Check whether swapping the found predicate makes it the same as the
|
|
|
|
// desired predicate.
|
|
|
|
if (ICmpInst::getSwappedPredicate(FoundPred) == Pred) {
|
|
|
|
if (isa<SCEVConstant>(RHS))
|
|
|
|
return isImpliedCondOperands(Pred, LHS, RHS, FoundRHS, FoundLHS);
|
|
|
|
else
|
|
|
|
return isImpliedCondOperands(ICmpInst::getSwappedPredicate(Pred),
|
|
|
|
RHS, LHS, FoundLHS, FoundRHS);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check whether the actual condition is beyond sufficient.
|
|
|
|
if (FoundPred == ICmpInst::ICMP_EQ)
|
|
|
|
if (ICmpInst::isTrueWhenEqual(Pred))
|
|
|
|
if (isImpliedCondOperands(Pred, LHS, RHS, FoundLHS, FoundRHS))
|
|
|
|
return true;
|
|
|
|
if (Pred == ICmpInst::ICMP_NE)
|
|
|
|
if (!ICmpInst::isTrueWhenEqual(FoundPred))
|
|
|
|
if (isImpliedCondOperands(FoundPred, LHS, RHS, FoundLHS, FoundRHS))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise assume the worst.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isImpliedCondOperands - Test whether the condition described by Pred,
|
2010-03-02 01:49:51 +08:00
|
|
|
/// LHS, and RHS is true whenever the condition described by Pred, FoundLHS,
|
2009-07-22 07:03:19 +08:00
|
|
|
/// and FoundRHS is true.
|
|
|
|
bool ScalarEvolution::isImpliedCondOperands(ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS,
|
|
|
|
const SCEV *FoundLHS,
|
|
|
|
const SCEV *FoundRHS) {
|
|
|
|
return isImpliedCondOperandsHelper(Pred, LHS, RHS,
|
|
|
|
FoundLHS, FoundRHS) ||
|
2009-07-14 05:35:55 +08:00
|
|
|
// ~x < ~y --> x > y
|
2009-07-22 07:03:19 +08:00
|
|
|
isImpliedCondOperandsHelper(Pred, LHS, RHS,
|
|
|
|
getNotSCEV(FoundRHS),
|
|
|
|
getNotSCEV(FoundLHS));
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
2009-07-22 07:03:19 +08:00
|
|
|
/// isImpliedCondOperandsHelper - Test whether the condition described by
|
2010-03-02 01:49:51 +08:00
|
|
|
/// Pred, LHS, and RHS is true whenever the condition described by Pred,
|
2009-07-22 07:03:19 +08:00
|
|
|
/// FoundLHS, and FoundRHS is true.
|
2009-07-14 05:35:55 +08:00
|
|
|
bool
|
2009-07-22 07:03:19 +08:00
|
|
|
ScalarEvolution::isImpliedCondOperandsHelper(ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS,
|
|
|
|
const SCEV *FoundLHS,
|
|
|
|
const SCEV *FoundRHS) {
|
2009-07-14 05:35:55 +08:00
|
|
|
switch (Pred) {
|
2009-07-17 01:34:36 +08:00
|
|
|
default: llvm_unreachable("Unexpected ICmpInst::Predicate value!");
|
|
|
|
case ICmpInst::ICMP_EQ:
|
|
|
|
case ICmpInst::ICMP_NE:
|
|
|
|
if (HasSameValue(LHS, FoundLHS) && HasSameValue(RHS, FoundRHS))
|
|
|
|
return true;
|
|
|
|
break;
|
2009-07-14 05:35:55 +08:00
|
|
|
case ICmpInst::ICMP_SLT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_SLE:
|
2010-04-12 06:16:48 +08:00
|
|
|
if (isKnownPredicateWithRanges(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicateWithRanges(ICmpInst::ICMP_SGE, RHS, FoundRHS))
|
2009-07-14 05:35:55 +08:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_SGE:
|
2010-04-12 06:16:48 +08:00
|
|
|
if (isKnownPredicateWithRanges(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicateWithRanges(ICmpInst::ICMP_SLE, RHS, FoundRHS))
|
2009-07-14 05:35:55 +08:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_ULE:
|
2010-04-12 06:16:48 +08:00
|
|
|
if (isKnownPredicateWithRanges(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicateWithRanges(ICmpInst::ICMP_UGE, RHS, FoundRHS))
|
2009-07-14 05:35:55 +08:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_UGT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_UGE:
|
2010-04-12 06:16:48 +08:00
|
|
|
if (isKnownPredicateWithRanges(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicateWithRanges(ICmpInst::ICMP_ULE, RHS, FoundRHS))
|
2009-07-14 05:35:55 +08:00
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2008-07-12 15:41:32 +08:00
|
|
|
}
|
|
|
|
|
2009-06-22 07:46:38 +08:00
|
|
|
/// getBECount - Subtract the end and start values and divide by the step,
|
|
|
|
/// rounding up, to get the number of times the backedge is executed. Return
|
|
|
|
/// CouldNotCompute if an intermediate computation overflows.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getBECount(const SCEV *Start,
|
2009-07-14 06:05:32 +08:00
|
|
|
const SCEV *End,
|
2009-09-18 02:05:20 +08:00
|
|
|
const SCEV *Step,
|
|
|
|
bool NoWrap) {
|
2010-01-26 12:40:18 +08:00
|
|
|
assert(!isKnownNegative(Step) &&
|
|
|
|
"This code doesn't handle negative strides yet!");
|
|
|
|
|
2009-06-22 07:46:38 +08:00
|
|
|
const Type *Ty = Start->getType();
|
2011-03-10 01:29:58 +08:00
|
|
|
|
|
|
|
// When Start == End, we have an exact BECount == 0. Short-circuit this case
|
|
|
|
// here because SCEV may not be able to determine that the unsigned division
|
|
|
|
// after rounding is zero.
|
|
|
|
if (Start == End)
|
|
|
|
return getConstant(Ty, 0);
|
|
|
|
|
2010-05-04 06:09:21 +08:00
|
|
|
const SCEV *NegOne = getConstant(Ty, (uint64_t)-1);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Diff = getMinusSCEV(End, Start);
|
|
|
|
const SCEV *RoundUp = getAddExpr(Step, NegOne);
|
2009-06-22 07:46:38 +08:00
|
|
|
|
|
|
|
// Add an adjustment to the difference between End and Start so that
|
|
|
|
// the division will effectively round up.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Add = getAddExpr(Diff, RoundUp);
|
2009-06-22 07:46:38 +08:00
|
|
|
|
2009-09-18 02:05:20 +08:00
|
|
|
if (!NoWrap) {
|
|
|
|
// Check Add for unsigned overflow.
|
|
|
|
// TODO: More sophisticated things could be done here.
|
|
|
|
const Type *WideTy = IntegerType::get(getContext(),
|
|
|
|
getTypeSizeInBits(Ty) + 1);
|
|
|
|
const SCEV *EDiff = getZeroExtendExpr(Diff, WideTy);
|
|
|
|
const SCEV *ERoundUp = getZeroExtendExpr(RoundUp, WideTy);
|
|
|
|
const SCEV *OperandExtendedAdd = getAddExpr(EDiff, ERoundUp);
|
|
|
|
if (getZeroExtendExpr(Add, WideTy) != OperandExtendedAdd)
|
|
|
|
return getCouldNotCompute();
|
|
|
|
}
|
2009-06-22 07:46:38 +08:00
|
|
|
|
|
|
|
return getUDivExpr(Add, Step);
|
|
|
|
}
|
|
|
|
|
2005-08-16 07:33:51 +08:00
|
|
|
/// HowManyLessThans - Return the number of times a backedge containing the
|
|
|
|
/// specified less-than comparison will execute. If not computable, return
|
2009-06-06 22:37:11 +08:00
|
|
|
/// CouldNotCompute.
|
2009-06-24 12:48:43 +08:00
|
|
|
ScalarEvolution::BackedgeTakenInfo
|
|
|
|
ScalarEvolution::HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
|
|
|
|
const Loop *L, bool isSigned) {
|
2005-08-16 07:33:51 +08:00
|
|
|
// Only handle: "ADDREC < LoopInvariant".
|
2010-11-18 05:23:15 +08:00
|
|
|
if (!isLoopInvariant(RHS, L)) return getCouldNotCompute();
|
2005-08-16 07:33:51 +08:00
|
|
|
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(LHS);
|
2005-08-16 07:33:51 +08:00
|
|
|
if (!AddRec || AddRec->getLoop() != L)
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2005-08-16 07:33:51 +08:00
|
|
|
|
2009-09-18 02:05:20 +08:00
|
|
|
// Check to see if we have a flag which makes analysis easy.
|
2011-03-15 00:50:06 +08:00
|
|
|
bool NoWrap = isSigned ? AddRec->getNoWrapFlags(SCEV::FlagNSW) :
|
|
|
|
AddRec->getNoWrapFlags(SCEV::FlagNUW);
|
2009-09-18 02:05:20 +08:00
|
|
|
|
2005-08-16 07:33:51 +08:00
|
|
|
if (AddRec->isAffine()) {
|
2009-05-01 04:47:05 +08:00
|
|
|
unsigned BitWidth = getTypeSizeInBits(AddRec->getType());
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Step = AddRec->getStepRecurrence(*this);
|
2009-05-01 04:47:05 +08:00
|
|
|
|
2010-01-26 12:40:18 +08:00
|
|
|
if (Step->isZero())
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2010-01-26 12:40:18 +08:00
|
|
|
if (Step->isOne()) {
|
2009-05-01 04:47:05 +08:00
|
|
|
// With unit stride, the iteration never steps past the limit value.
|
2010-01-26 12:40:18 +08:00
|
|
|
} else if (isKnownPositive(Step)) {
|
2010-02-11 00:03:48 +08:00
|
|
|
// Test whether a positive iteration can step past the limit
|
2010-01-26 12:40:18 +08:00
|
|
|
// value and past the maximum value for its type in a single step.
|
|
|
|
// Note that it's not sufficient to check NoWrap here, because even
|
|
|
|
// though the value after a wrap is undefined, it's not undefined
|
|
|
|
// behavior, so if wrap does occur, the loop could either terminate or
|
2010-01-27 02:32:54 +08:00
|
|
|
// loop infinitely, but in either case, the loop is guaranteed to
|
2010-01-26 12:40:18 +08:00
|
|
|
// iterate at least until the iteration where the wrapping occurs.
|
2010-05-04 06:09:21 +08:00
|
|
|
const SCEV *One = getConstant(Step->getType(), 1);
|
2010-01-26 12:40:18 +08:00
|
|
|
if (isSigned) {
|
|
|
|
APInt Max = APInt::getSignedMaxValue(BitWidth);
|
|
|
|
if ((Max - getSignedRange(getMinusSCEV(Step, One)).getSignedMax())
|
|
|
|
.slt(getSignedRange(RHS).getSignedMax()))
|
|
|
|
return getCouldNotCompute();
|
|
|
|
} else {
|
|
|
|
APInt Max = APInt::getMaxValue(BitWidth);
|
|
|
|
if ((Max - getUnsignedRange(getMinusSCEV(Step, One)).getUnsignedMax())
|
|
|
|
.ult(getUnsignedRange(RHS).getUnsignedMax()))
|
|
|
|
return getCouldNotCompute();
|
|
|
|
}
|
2009-05-01 04:47:05 +08:00
|
|
|
} else
|
2010-01-26 12:40:18 +08:00
|
|
|
// TODO: Handle negative strides here and below.
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-01-03 02:54:17 +08:00
|
|
|
|
2009-05-01 04:47:05 +08:00
|
|
|
// We know the LHS is of the form {n,+,s} and the RHS is some loop-invariant
|
|
|
|
// m. So, we count the number of iterations in which {n,+,s} < m is true.
|
|
|
|
// Note that we cannot simply return max(m-n,0)/s because it's not safe to
|
2008-02-13 20:21:32 +08:00
|
|
|
// treat m-n as signed nor unsigned due to overflow possibility.
|
2008-02-13 19:51:34 +08:00
|
|
|
|
|
|
|
// First, we get the value of the LHS in the first iteration: n
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Start = AddRec->getOperand(0);
|
2006-12-23 14:05:41 +08:00
|
|
|
|
2009-05-01 04:47:05 +08:00
|
|
|
// Determine the minimum constant start value.
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *MinStart = getConstant(isSigned ?
|
|
|
|
getSignedRange(Start).getSignedMin() :
|
|
|
|
getUnsignedRange(Start).getUnsignedMin());
|
2009-05-01 04:47:05 +08:00
|
|
|
|
|
|
|
// If we know that the condition is true in order to enter the loop,
|
|
|
|
// then we know that it will run exactly (m-n)/s times. Otherwise, we
|
2009-05-25 07:45:28 +08:00
|
|
|
// only know that it will execute (max(m,n)-n)/s times. In both cases,
|
|
|
|
// the division must round up.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *End = RHS;
|
2010-04-12 03:27:13 +08:00
|
|
|
if (!isLoopEntryGuardedByCond(L,
|
|
|
|
isSigned ? ICmpInst::ICMP_SLT :
|
|
|
|
ICmpInst::ICMP_ULT,
|
|
|
|
getMinusSCEV(Start, Step), RHS))
|
2009-05-01 04:47:05 +08:00
|
|
|
End = isSigned ? getSMaxExpr(RHS, Start)
|
|
|
|
: getUMaxExpr(RHS, Start);
|
|
|
|
|
|
|
|
// Determine the maximum constant end value.
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *MaxEnd = getConstant(isSigned ?
|
|
|
|
getSignedRange(End).getSignedMax() :
|
|
|
|
getUnsignedRange(End).getUnsignedMax());
|
2009-05-01 04:47:05 +08:00
|
|
|
|
2010-01-26 12:40:18 +08:00
|
|
|
// If MaxEnd is within a step of the maximum integer value in its type,
|
|
|
|
// adjust it down to the minimum value which would produce the same effect.
|
2010-03-02 01:49:51 +08:00
|
|
|
// This allows the subsequent ceiling division of (N+(step-1))/step to
|
2010-01-26 12:40:18 +08:00
|
|
|
// compute the correct value.
|
|
|
|
const SCEV *StepMinusOne = getMinusSCEV(Step,
|
2010-05-04 06:09:21 +08:00
|
|
|
getConstant(Step->getType(), 1));
|
2010-01-26 12:40:18 +08:00
|
|
|
MaxEnd = isSigned ?
|
|
|
|
getSMinExpr(MaxEnd,
|
|
|
|
getMinusSCEV(getConstant(APInt::getSignedMaxValue(BitWidth)),
|
|
|
|
StepMinusOne)) :
|
|
|
|
getUMinExpr(MaxEnd,
|
|
|
|
getMinusSCEV(getConstant(APInt::getMaxValue(BitWidth)),
|
|
|
|
StepMinusOne));
|
|
|
|
|
2009-05-01 04:47:05 +08:00
|
|
|
// Finally, we subtract these two values and divide, rounding up, to get
|
|
|
|
// the number of times the backedge is executed.
|
2009-09-18 02:05:20 +08:00
|
|
|
const SCEV *BECount = getBECount(Start, End, Step, NoWrap);
|
2009-05-01 04:47:05 +08:00
|
|
|
|
|
|
|
// The maximum backedge count is similar, except using the minimum start
|
|
|
|
// value and the maximum end value.
|
2011-03-10 01:29:58 +08:00
|
|
|
// If we already have an exact constant BECount, use it instead.
|
|
|
|
const SCEV *MaxBECount = isa<SCEVConstant>(BECount) ? BECount
|
|
|
|
: getBECount(MinStart, MaxEnd, Step, NoWrap);
|
|
|
|
|
|
|
|
// If the stride is nonconstant, and NoWrap == true, then
|
|
|
|
// getBECount(MinStart, MaxEnd) may not compute. This would result in an
|
|
|
|
// exact BECount and invalid MaxBECount, which should be avoided to catch
|
|
|
|
// more optimization opportunities.
|
|
|
|
if (isa<SCEVCouldNotCompute>(MaxBECount))
|
|
|
|
MaxBECount = BECount;
|
2009-05-01 04:47:05 +08:00
|
|
|
|
|
|
|
return BackedgeTakenInfo(BECount, MaxBECount);
|
2005-08-16 07:33:51 +08:00
|
|
|
}
|
|
|
|
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2005-08-16 07:33:51 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
/// getNumIterationsInRange - Return the number of iterations of this loop that
|
|
|
|
/// produce values in the specified constant range. Another way of looking at
|
|
|
|
/// this is that it returns the first iteration number where the value is not in
|
|
|
|
/// the condition, thus computing the exit count. If the iteration count can't
|
|
|
|
/// be computed, an instance of SCEVCouldNotCompute is returned.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
|
2009-06-24 12:48:43 +08:00
|
|
|
ScalarEvolution &SE) const {
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Range.isFullSet()) // Infinite loop.
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// If the start is a non-zero constant, shift the range to simplify things.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
|
2007-03-02 08:28:52 +08:00
|
|
|
if (!SC->getValue()->isZero()) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
|
2010-05-04 06:09:21 +08:00
|
|
|
Operands[0] = SE.getConstant(SC->getType(), 0);
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop(),
|
2011-03-15 08:37:00 +08:00
|
|
|
getNoWrapFlags(FlagNW));
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVAddRecExpr *ShiftedAddRec =
|
|
|
|
dyn_cast<SCEVAddRecExpr>(Shifted))
|
2004-04-03 04:23:17 +08:00
|
|
|
return ShiftedAddRec->getNumIterationsInRange(
|
2007-10-23 02:31:58 +08:00
|
|
|
Range.subtract(SC->getValue()->getValue()), SE);
|
2004-04-03 04:23:17 +08:00
|
|
|
// This is strange and shouldn't happen.
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// The only time we can solve this is when we have all constant indices.
|
|
|
|
// Otherwise, we cannot determine the overflow conditions.
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (!isa<SCEVConstant>(getOperand(i)))
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
|
|
|
|
// Okay at this point we know that all elements of the chrec are constants and
|
|
|
|
// that the start element is zero.
|
|
|
|
|
|
|
|
// First check to see if the range contains zero. If not, the first
|
|
|
|
// iteration exits.
|
2009-04-21 09:07:12 +08:00
|
|
|
unsigned BitWidth = SE.getTypeSizeInBits(getType());
|
2009-04-16 11:18:22 +08:00
|
|
|
if (!Range.contains(APInt(BitWidth, 0)))
|
2010-05-04 06:09:21 +08:00
|
|
|
return SE.getConstant(getType(), 0);
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
if (isAffine()) {
|
|
|
|
// If this is an affine expression then we have this situation:
|
|
|
|
// Solve {0,+,A} in Range === Ax in Range
|
|
|
|
|
2007-07-16 10:08:00 +08:00
|
|
|
// We know that zero is in the range. If A is positive then we know that
|
|
|
|
// the upper value of the range must be the first possible exit value.
|
|
|
|
// If A is negative then the lower of the range is the last possible loop
|
|
|
|
// value. Also note that we already checked for a full range.
|
2009-04-16 11:18:22 +08:00
|
|
|
APInt One(BitWidth,1);
|
2007-07-16 10:08:00 +08:00
|
|
|
APInt A = cast<SCEVConstant>(getOperand(1))->getValue()->getValue();
|
|
|
|
APInt End = A.sge(One) ? (Range.getUpper() - One) : Range.getLower();
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2007-07-16 10:08:00 +08:00
|
|
|
// The exit value should be (End+A)/A.
|
2007-09-27 22:12:54 +08:00
|
|
|
APInt ExitVal = (End + A).udiv(A);
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt *ExitValue = ConstantInt::get(SE.getContext(), ExitVal);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// Evaluate at the exit value. If we really did fall out of the valid
|
|
|
|
// range, then we computed our trip count, otherwise wrap around or other
|
|
|
|
// things must have happened.
|
2007-10-23 02:31:58 +08:00
|
|
|
ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue, SE);
|
2007-03-01 15:54:15 +08:00
|
|
|
if (Range.contains(Val->getValue()))
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute(); // Something strange happened
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// Ensure that the previous value is in the range. This is a sanity check.
|
2007-03-01 03:57:34 +08:00
|
|
|
assert(Range.contains(
|
2009-06-24 12:48:43 +08:00
|
|
|
EvaluateConstantChrecAtConstant(this,
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt::get(SE.getContext(), ExitVal - One), SE)->getValue()) &&
|
2004-04-03 04:23:17 +08:00
|
|
|
"Linear scev computation is off in a bad way!");
|
2007-10-23 02:31:58 +08:00
|
|
|
return SE.getConstant(ExitValue);
|
2004-04-03 04:23:17 +08:00
|
|
|
} else if (isQuadratic()) {
|
|
|
|
// If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of the
|
|
|
|
// quadratic equation to solve it. To do this, we must frame our problem in
|
|
|
|
// terms of figuring out when zero is crossed, instead of when
|
|
|
|
// Range.getUpper() is crossed.
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> NewOps(op_begin(), op_end());
|
2007-10-23 02:31:58 +08:00
|
|
|
NewOps[0] = SE.getNegativeSCEV(SE.getConstant(Range.getUpper()));
|
2011-03-15 00:50:06 +08:00
|
|
|
const SCEV *NewAddRec = SE.getAddRecExpr(NewOps, getLoop(),
|
|
|
|
// getNoWrapFlags(FlagNW)
|
|
|
|
FlagAnyWrap);
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
// Next, solve the constructed addrec
|
2009-07-08 01:06:11 +08:00
|
|
|
std::pair<const SCEV *,const SCEV *> Roots =
|
2007-10-23 02:31:58 +08:00
|
|
|
SolveQuadraticEquation(cast<SCEVAddRecExpr>(NewAddRec), SE);
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVConstant *R1 = dyn_cast<SCEVConstant>(Roots.first);
|
|
|
|
const SCEVConstant *R2 = dyn_cast<SCEVConstant>(Roots.second);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (R1) {
|
|
|
|
// Pick the smallest positive root value.
|
2007-01-11 20:24:14 +08:00
|
|
|
if (ConstantInt *CB =
|
2009-07-30 02:55:55 +08:00
|
|
|
dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
|
2009-07-07 06:37:39 +08:00
|
|
|
R1->getValue(), R2->getValue()))) {
|
2007-01-12 12:24:46 +08:00
|
|
|
if (CB->getZExtValue() == false)
|
2004-04-03 04:23:17 +08:00
|
|
|
std::swap(R1, R2); // R1 is the minimum root now.
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Make sure the root is not off by one. The returned iteration should
|
|
|
|
// not be in the range, but the previous one should be. When solving
|
|
|
|
// for "X*X < 5", for example, we should not return a root of 2.
|
|
|
|
ConstantInt *R1Val = EvaluateConstantChrecAtConstant(this,
|
2007-10-23 02:31:58 +08:00
|
|
|
R1->getValue(),
|
|
|
|
SE);
|
2007-03-01 15:54:15 +08:00
|
|
|
if (Range.contains(R1Val->getValue())) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// The next iteration must be out of the range...
|
2009-07-07 06:37:39 +08:00
|
|
|
ConstantInt *NextVal =
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt::get(SE.getContext(), R1->getValue()->getValue()+1);
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2007-10-23 02:31:58 +08:00
|
|
|
R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
|
2007-03-01 15:54:15 +08:00
|
|
|
if (!Range.contains(R1Val->getValue()))
|
2007-10-23 02:31:58 +08:00
|
|
|
return SE.getConstant(NextVal);
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute(); // Something strange happened
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// If R1 was not in the range, then it is a good return value. Make
|
|
|
|
// sure that R1-1 WAS in the range though, just in case.
|
2009-07-07 06:37:39 +08:00
|
|
|
ConstantInt *NextVal =
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt::get(SE.getContext(), R1->getValue()->getValue()-1);
|
2007-10-23 02:31:58 +08:00
|
|
|
R1Val = EvaluateConstantChrecAtConstant(this, NextVal, SE);
|
2007-03-01 15:54:15 +08:00
|
|
|
if (Range.contains(R1Val->getValue()))
|
2004-04-03 04:23:17 +08:00
|
|
|
return R1;
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute(); // Something strange happened
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-19 01:58:19 +08:00
|
|
|
return SE.getCouldNotCompute();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-05-05 06:30:44 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SCEVCallbackVH Class Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-05-20 03:22:47 +08:00
|
|
|
void ScalarEvolution::SCEVCallbackVH::deleted() {
|
2009-07-14 06:20:53 +08:00
|
|
|
assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
|
2009-05-05 06:30:44 +08:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(getValPtr()))
|
|
|
|
SE->ConstantEvolutionLoopExitValue.erase(PN);
|
2010-08-28 02:55:03 +08:00
|
|
|
SE->ValueExprMap.erase(getValPtr());
|
2009-05-05 06:30:44 +08:00
|
|
|
// this now dangles!
|
|
|
|
}
|
|
|
|
|
2010-07-28 09:09:07 +08:00
|
|
|
void ScalarEvolution::SCEVCallbackVH::allUsesReplacedWith(Value *V) {
|
2009-07-14 06:20:53 +08:00
|
|
|
assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
|
2010-07-29 09:25:38 +08:00
|
|
|
|
2009-05-05 06:30:44 +08:00
|
|
|
// Forget all the expressions associated with users of the old value,
|
|
|
|
// so that future queries will recompute the expressions using the new
|
|
|
|
// value.
|
2010-08-03 07:49:30 +08:00
|
|
|
Value *Old = getValPtr();
|
2009-05-05 06:30:44 +08:00
|
|
|
SmallVector<User *, 16> Worklist;
|
2009-07-14 22:34:04 +08:00
|
|
|
SmallPtrSet<User *, 8> Visited;
|
2009-05-05 06:30:44 +08:00
|
|
|
for (Value::use_iterator UI = Old->use_begin(), UE = Old->use_end();
|
|
|
|
UI != UE; ++UI)
|
|
|
|
Worklist.push_back(*UI);
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
User *U = Worklist.pop_back_val();
|
|
|
|
// Deleting the Old value will cause this to dangle. Postpone
|
|
|
|
// that until everything else is done.
|
2010-07-28 08:28:25 +08:00
|
|
|
if (U == Old)
|
2009-05-05 06:30:44 +08:00
|
|
|
continue;
|
2009-07-14 22:34:04 +08:00
|
|
|
if (!Visited.insert(U))
|
|
|
|
continue;
|
2009-05-05 06:30:44 +08:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(U))
|
|
|
|
SE->ConstantEvolutionLoopExitValue.erase(PN);
|
2010-08-28 02:55:03 +08:00
|
|
|
SE->ValueExprMap.erase(U);
|
2009-07-14 22:34:04 +08:00
|
|
|
for (Value::use_iterator UI = U->use_begin(), UE = U->use_end();
|
|
|
|
UI != UE; ++UI)
|
|
|
|
Worklist.push_back(*UI);
|
2009-05-05 06:30:44 +08:00
|
|
|
}
|
2010-07-28 08:28:25 +08:00
|
|
|
// Delete the Old value.
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(Old))
|
|
|
|
SE->ConstantEvolutionLoopExitValue.erase(PN);
|
2010-08-28 02:55:03 +08:00
|
|
|
SE->ValueExprMap.erase(Old);
|
2010-07-28 08:28:25 +08:00
|
|
|
// this now dangles!
|
2009-05-05 06:30:44 +08:00
|
|
|
}
|
|
|
|
|
2009-05-20 03:22:47 +08:00
|
|
|
ScalarEvolution::SCEVCallbackVH::SCEVCallbackVH(Value *V, ScalarEvolution *se)
|
2009-05-05 06:30:44 +08:00
|
|
|
: CallbackVH(V), SE(se) {}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// ScalarEvolution Class Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-04-22 07:15:49 +08:00
|
|
|
ScalarEvolution::ScalarEvolution()
|
2010-08-07 02:33:48 +08:00
|
|
|
: FunctionPass(ID), FirstUnknown(0) {
|
2010-10-20 01:21:58 +08:00
|
|
|
initializeScalarEvolutionPass(*PassRegistry::getPassRegistry());
|
2009-04-22 07:15:49 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
bool ScalarEvolution::runOnFunction(Function &F) {
|
2009-04-22 07:15:49 +08:00
|
|
|
this->F = &F;
|
|
|
|
LI = &getAnalysis<LoopInfo>();
|
|
|
|
TD = getAnalysisIfAvailable<TargetData>();
|
2010-02-22 12:11:59 +08:00
|
|
|
DT = &getAnalysis<DominatorTree>();
|
2004-04-03 04:23:17 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ScalarEvolution::releaseMemory() {
|
2010-08-03 07:49:30 +08:00
|
|
|
// Iterate through all the SCEVUnknown instances and call their
|
|
|
|
// destructors, so that they release their references to their values.
|
|
|
|
for (SCEVUnknown *U = FirstUnknown; U; U = U->Next)
|
|
|
|
U->~SCEVUnknown();
|
|
|
|
FirstUnknown = 0;
|
|
|
|
|
2010-08-28 02:55:03 +08:00
|
|
|
ValueExprMap.clear();
|
2009-04-22 07:15:49 +08:00
|
|
|
BackedgeTakenCounts.clear();
|
|
|
|
ConstantEvolutionLoopExitValue.clear();
|
2009-05-09 04:47:27 +08:00
|
|
|
ValuesAtScopes.clear();
|
2010-11-18 07:21:44 +08:00
|
|
|
LoopDispositions.clear();
|
2010-11-18 08:34:22 +08:00
|
|
|
BlockDispositions.clear();
|
2010-11-17 10:44:44 +08:00
|
|
|
UnsignedRanges.clear();
|
|
|
|
SignedRanges.clear();
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.clear();
|
|
|
|
SCEVAllocator.Reset();
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void ScalarEvolution::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
|
|
|
AU.addRequiredTransitive<LoopInfo>();
|
2010-01-20 06:21:27 +08:00
|
|
|
AU.addRequiredTransitive<DominatorTree>();
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
|
|
|
|
2009-04-22 07:15:49 +08:00
|
|
|
bool ScalarEvolution::hasLoopInvariantBackedgeTakenCount(const Loop *L) {
|
2009-02-25 02:55:53 +08:00
|
|
|
return !isa<SCEVCouldNotCompute>(getBackedgeTakenCount(L));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-04-22 07:15:49 +08:00
|
|
|
static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
|
2004-04-03 04:23:17 +08:00
|
|
|
const Loop *L) {
|
|
|
|
// Print all inner loops first
|
|
|
|
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
|
|
|
|
PrintLoopInfo(OS, SE, *I);
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2010-01-10 02:17:45 +08:00
|
|
|
OS << "Loop ";
|
|
|
|
WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
|
|
|
|
OS << ": ";
|
2004-04-19 06:14:10 +08:00
|
|
|
|
2009-12-18 09:14:11 +08:00
|
|
|
SmallVector<BasicBlock *, 8> ExitBlocks;
|
2004-04-19 06:14:10 +08:00
|
|
|
L->getExitBlocks(ExitBlocks);
|
|
|
|
if (ExitBlocks.size() != 1)
|
2008-01-02 10:49:20 +08:00
|
|
|
OS << "<multiple exits> ";
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-02-25 02:55:53 +08:00
|
|
|
if (SE->hasLoopInvariantBackedgeTakenCount(L)) {
|
|
|
|
OS << "backedge-taken count is " << *SE->getBackedgeTakenCount(L);
|
2004-04-03 04:23:17 +08:00
|
|
|
} else {
|
2009-02-25 02:55:53 +08:00
|
|
|
OS << "Unpredictable backedge-taken count. ";
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2010-01-10 02:17:45 +08:00
|
|
|
OS << "\n"
|
|
|
|
"Loop ";
|
|
|
|
WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
|
|
|
|
OS << ": ";
|
2009-06-24 08:33:16 +08:00
|
|
|
|
|
|
|
if (!isa<SCEVCouldNotCompute>(SE->getMaxBackedgeTakenCount(L))) {
|
|
|
|
OS << "max backedge-taken count is " << *SE->getMaxBackedgeTakenCount(L);
|
|
|
|
} else {
|
|
|
|
OS << "Unpredictable max backedge-taken count. ";
|
|
|
|
}
|
|
|
|
|
2008-01-02 10:49:20 +08:00
|
|
|
OS << "\n";
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-12-18 09:14:11 +08:00
|
|
|
void ScalarEvolution::print(raw_ostream &OS, const Module *) const {
|
2010-03-02 01:49:51 +08:00
|
|
|
// ScalarEvolution's implementation of the print method is to print
|
2009-04-22 07:15:49 +08:00
|
|
|
// out SCEV values of all instructions that are interesting. Doing
|
|
|
|
// this potentially causes it to create new SCEV objects though,
|
|
|
|
// which technically conflicts with the const qualifier. This isn't
|
2009-07-11 04:25:29 +08:00
|
|
|
// observable from outside the class though, so casting away the
|
|
|
|
// const isn't dangerous.
|
2009-12-18 09:14:11 +08:00
|
|
|
ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
|
2009-04-22 07:15:49 +08:00
|
|
|
|
2010-01-10 02:17:45 +08:00
|
|
|
OS << "Classifying expressions for: ";
|
|
|
|
WriteAsOperand(OS, F, /*PrintType=*/false);
|
|
|
|
OS << "\n";
|
2004-04-03 04:23:17 +08:00
|
|
|
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
|
2010-05-04 01:03:23 +08:00
|
|
|
if (isSCEVable(I->getType()) && !isa<CmpInst>(*I)) {
|
2009-07-14 07:03:05 +08:00
|
|
|
OS << *I << '\n';
|
2008-09-15 01:21:12 +08:00
|
|
|
OS << " --> ";
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SV = SE.getSCEV(&*I);
|
2004-04-03 04:23:17 +08:00
|
|
|
SV->print(OS);
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2009-06-20 01:49:54 +08:00
|
|
|
const Loop *L = LI->getLoopFor((*I).getParent());
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *AtUse = SE.getSCEVAtScope(SV, L);
|
2009-06-20 01:49:54 +08:00
|
|
|
if (AtUse != SV) {
|
|
|
|
OS << " --> ";
|
|
|
|
AtUse->print(OS);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (L) {
|
2009-06-18 08:37:45 +08:00
|
|
|
OS << "\t\t" "Exits: ";
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ExitValue = SE.getSCEVAtScope(SV, L->getParentLoop());
|
2010-11-18 05:23:15 +08:00
|
|
|
if (!SE.isLoopInvariant(ExitValue, L)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
OS << "<<Unknown>>";
|
|
|
|
} else {
|
|
|
|
OS << *ExitValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
}
|
|
|
|
|
2010-01-10 02:17:45 +08:00
|
|
|
OS << "Determining loop execution counts for: ";
|
|
|
|
WriteAsOperand(OS, F, /*PrintType=*/false);
|
|
|
|
OS << "\n";
|
2009-04-22 07:15:49 +08:00
|
|
|
for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
|
|
|
|
PrintLoopInfo(OS, &SE, *I);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-04-21 08:47:46 +08:00
|
|
|
|
2010-11-18 07:21:44 +08:00
|
|
|
ScalarEvolution::LoopDisposition
|
|
|
|
ScalarEvolution::getLoopDisposition(const SCEV *S, const Loop *L) {
|
|
|
|
std::map<const Loop *, LoopDisposition> &Values = LoopDispositions[S];
|
|
|
|
std::pair<std::map<const Loop *, LoopDisposition>::iterator, bool> Pair =
|
|
|
|
Values.insert(std::make_pair(L, LoopVariant));
|
|
|
|
if (!Pair.second)
|
|
|
|
return Pair.first->second;
|
|
|
|
|
|
|
|
LoopDisposition D = computeLoopDisposition(S, L);
|
|
|
|
return LoopDispositions[S][L] = D;
|
|
|
|
}
|
|
|
|
|
|
|
|
ScalarEvolution::LoopDisposition
|
|
|
|
ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) {
|
2010-11-18 05:23:15 +08:00
|
|
|
switch (S->getSCEVType()) {
|
|
|
|
case scConstant:
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopInvariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
case scTruncate:
|
|
|
|
case scZeroExtend:
|
|
|
|
case scSignExtend:
|
2010-11-18 07:21:44 +08:00
|
|
|
return getLoopDisposition(cast<SCEVCastExpr>(S)->getOperand(), L);
|
2010-11-18 05:23:15 +08:00
|
|
|
case scAddRecExpr: {
|
|
|
|
const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
|
|
|
|
|
2010-11-18 07:21:44 +08:00
|
|
|
// If L is the addrec's loop, it's computable.
|
|
|
|
if (AR->getLoop() == L)
|
|
|
|
return LoopComputable;
|
|
|
|
|
2010-11-18 05:23:15 +08:00
|
|
|
// Add recurrences are never invariant in the function-body (null loop).
|
|
|
|
if (!L)
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopVariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
|
|
|
|
// This recurrence is variant w.r.t. L if L contains AR's loop.
|
|
|
|
if (L->contains(AR->getLoop()))
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopVariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
|
|
|
|
// This recurrence is invariant w.r.t. L if AR's loop contains L.
|
|
|
|
if (AR->getLoop()->contains(L))
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopInvariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
|
|
|
|
// This recurrence is variant w.r.t. L if any of its operands
|
|
|
|
// are variant.
|
|
|
|
for (SCEVAddRecExpr::op_iterator I = AR->op_begin(), E = AR->op_end();
|
|
|
|
I != E; ++I)
|
|
|
|
if (!isLoopInvariant(*I, L))
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopVariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
|
|
|
|
// Otherwise it's loop-invariant.
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopInvariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
}
|
|
|
|
case scAddExpr:
|
|
|
|
case scMulExpr:
|
|
|
|
case scUMaxExpr:
|
|
|
|
case scSMaxExpr: {
|
|
|
|
const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(S);
|
2010-11-18 07:21:44 +08:00
|
|
|
bool HasVarying = false;
|
2010-11-18 05:23:15 +08:00
|
|
|
for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
|
2010-11-18 07:21:44 +08:00
|
|
|
I != E; ++I) {
|
|
|
|
LoopDisposition D = getLoopDisposition(*I, L);
|
|
|
|
if (D == LoopVariant)
|
|
|
|
return LoopVariant;
|
|
|
|
if (D == LoopComputable)
|
|
|
|
HasVarying = true;
|
|
|
|
}
|
|
|
|
return HasVarying ? LoopComputable : LoopInvariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
}
|
|
|
|
case scUDivExpr: {
|
|
|
|
const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
|
2010-11-18 07:21:44 +08:00
|
|
|
LoopDisposition LD = getLoopDisposition(UDiv->getLHS(), L);
|
|
|
|
if (LD == LoopVariant)
|
|
|
|
return LoopVariant;
|
|
|
|
LoopDisposition RD = getLoopDisposition(UDiv->getRHS(), L);
|
|
|
|
if (RD == LoopVariant)
|
|
|
|
return LoopVariant;
|
|
|
|
return (LD == LoopInvariant && RD == LoopInvariant) ?
|
|
|
|
LoopInvariant : LoopComputable;
|
2010-11-18 05:23:15 +08:00
|
|
|
}
|
|
|
|
case scUnknown:
|
|
|
|
// All non-instruction values are loop invariant. All instructions are loop
|
|
|
|
// invariant if they are not contained in the specified loop.
|
|
|
|
// Instructions are never considered invariant in the function body
|
|
|
|
// (null loop) because they are defined within the "loop".
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue()))
|
2010-11-18 07:21:44 +08:00
|
|
|
return (L && !L->contains(I)) ? LoopInvariant : LoopVariant;
|
|
|
|
return LoopInvariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
case scCouldNotCompute:
|
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopVariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
2010-11-18 07:21:44 +08:00
|
|
|
return LoopVariant;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::isLoopInvariant(const SCEV *S, const Loop *L) {
|
|
|
|
return getLoopDisposition(S, L) == LoopInvariant;
|
2010-11-18 05:23:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::hasComputableLoopEvolution(const SCEV *S, const Loop *L) {
|
2010-11-18 07:21:44 +08:00
|
|
|
return getLoopDisposition(S, L) == LoopComputable;
|
2010-11-18 05:23:15 +08:00
|
|
|
}
|
2010-11-18 05:41:58 +08:00
|
|
|
|
2010-11-18 08:34:22 +08:00
|
|
|
ScalarEvolution::BlockDisposition
|
|
|
|
ScalarEvolution::getBlockDisposition(const SCEV *S, const BasicBlock *BB) {
|
|
|
|
std::map<const BasicBlock *, BlockDisposition> &Values = BlockDispositions[S];
|
|
|
|
std::pair<std::map<const BasicBlock *, BlockDisposition>::iterator, bool>
|
|
|
|
Pair = Values.insert(std::make_pair(BB, DoesNotDominateBlock));
|
|
|
|
if (!Pair.second)
|
|
|
|
return Pair.first->second;
|
|
|
|
|
|
|
|
BlockDisposition D = computeBlockDisposition(S, BB);
|
|
|
|
return BlockDispositions[S][BB] = D;
|
2010-11-18 05:41:58 +08:00
|
|
|
}
|
|
|
|
|
2010-11-18 08:34:22 +08:00
|
|
|
ScalarEvolution::BlockDisposition
|
|
|
|
ScalarEvolution::computeBlockDisposition(const SCEV *S, const BasicBlock *BB) {
|
2010-11-18 05:41:58 +08:00
|
|
|
switch (S->getSCEVType()) {
|
|
|
|
case scConstant:
|
2010-11-18 08:34:22 +08:00
|
|
|
return ProperlyDominatesBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
case scTruncate:
|
|
|
|
case scZeroExtend:
|
|
|
|
case scSignExtend:
|
2010-11-18 08:34:22 +08:00
|
|
|
return getBlockDisposition(cast<SCEVCastExpr>(S)->getOperand(), BB);
|
2010-11-18 05:41:58 +08:00
|
|
|
case scAddRecExpr: {
|
|
|
|
// This uses a "dominates" query instead of "properly dominates" query
|
2010-11-18 08:34:22 +08:00
|
|
|
// to test for proper dominance too, because the instruction which
|
|
|
|
// produces the addrec's value is a PHI, and a PHI effectively properly
|
|
|
|
// dominates its entire containing block.
|
2010-11-18 05:41:58 +08:00
|
|
|
const SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(S);
|
|
|
|
if (!DT->dominates(AR->getLoop()->getHeader(), BB))
|
2010-11-18 08:34:22 +08:00
|
|
|
return DoesNotDominateBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
}
|
|
|
|
// FALL THROUGH into SCEVNAryExpr handling.
|
|
|
|
case scAddExpr:
|
|
|
|
case scMulExpr:
|
|
|
|
case scUMaxExpr:
|
|
|
|
case scSMaxExpr: {
|
|
|
|
const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(S);
|
2010-11-18 08:34:22 +08:00
|
|
|
bool Proper = true;
|
2010-11-18 05:41:58 +08:00
|
|
|
for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
|
2010-11-18 08:34:22 +08:00
|
|
|
I != E; ++I) {
|
|
|
|
BlockDisposition D = getBlockDisposition(*I, BB);
|
|
|
|
if (D == DoesNotDominateBlock)
|
|
|
|
return DoesNotDominateBlock;
|
|
|
|
if (D == DominatesBlock)
|
|
|
|
Proper = false;
|
|
|
|
}
|
|
|
|
return Proper ? ProperlyDominatesBlock : DominatesBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
}
|
|
|
|
case scUDivExpr: {
|
|
|
|
const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
|
2010-11-18 08:34:22 +08:00
|
|
|
const SCEV *LHS = UDiv->getLHS(), *RHS = UDiv->getRHS();
|
|
|
|
BlockDisposition LD = getBlockDisposition(LHS, BB);
|
|
|
|
if (LD == DoesNotDominateBlock)
|
|
|
|
return DoesNotDominateBlock;
|
|
|
|
BlockDisposition RD = getBlockDisposition(RHS, BB);
|
|
|
|
if (RD == DoesNotDominateBlock)
|
|
|
|
return DoesNotDominateBlock;
|
|
|
|
return (LD == ProperlyDominatesBlock && RD == ProperlyDominatesBlock) ?
|
|
|
|
ProperlyDominatesBlock : DominatesBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
}
|
|
|
|
case scUnknown:
|
|
|
|
if (Instruction *I =
|
2010-11-18 08:34:22 +08:00
|
|
|
dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue())) {
|
|
|
|
if (I->getParent() == BB)
|
|
|
|
return DominatesBlock;
|
|
|
|
if (DT->properlyDominates(I->getParent(), BB))
|
|
|
|
return ProperlyDominatesBlock;
|
|
|
|
return DoesNotDominateBlock;
|
|
|
|
}
|
|
|
|
return ProperlyDominatesBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
case scCouldNotCompute:
|
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
2010-11-18 08:34:22 +08:00
|
|
|
return DoesNotDominateBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
2010-11-18 08:34:22 +08:00
|
|
|
return DoesNotDominateBlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::dominates(const SCEV *S, const BasicBlock *BB) {
|
|
|
|
return getBlockDisposition(S, BB) >= DominatesBlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ScalarEvolution::properlyDominates(const SCEV *S, const BasicBlock *BB) {
|
|
|
|
return getBlockDisposition(S, BB) == ProperlyDominatesBlock;
|
2010-11-18 05:41:58 +08:00
|
|
|
}
|
2010-11-18 06:27:42 +08:00
|
|
|
|
|
|
|
bool ScalarEvolution::hasOperand(const SCEV *S, const SCEV *Op) const {
|
|
|
|
switch (S->getSCEVType()) {
|
|
|
|
case scConstant:
|
|
|
|
return false;
|
|
|
|
case scTruncate:
|
|
|
|
case scZeroExtend:
|
|
|
|
case scSignExtend: {
|
|
|
|
const SCEVCastExpr *Cast = cast<SCEVCastExpr>(S);
|
|
|
|
const SCEV *CastOp = Cast->getOperand();
|
|
|
|
return Op == CastOp || hasOperand(CastOp, Op);
|
|
|
|
}
|
|
|
|
case scAddRecExpr:
|
|
|
|
case scAddExpr:
|
|
|
|
case scMulExpr:
|
|
|
|
case scUMaxExpr:
|
|
|
|
case scSMaxExpr: {
|
|
|
|
const SCEVNAryExpr *NAry = cast<SCEVNAryExpr>(S);
|
|
|
|
for (SCEVNAryExpr::op_iterator I = NAry->op_begin(), E = NAry->op_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
const SCEV *NAryOp = *I;
|
|
|
|
if (NAryOp == Op || hasOperand(NAryOp, Op))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case scUDivExpr: {
|
|
|
|
const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
|
|
|
|
const SCEV *LHS = UDiv->getLHS(), *RHS = UDiv->getRHS();
|
|
|
|
return LHS == Op || hasOperand(LHS, Op) ||
|
|
|
|
RHS == Op || hasOperand(RHS, Op);
|
|
|
|
}
|
|
|
|
case scUnknown:
|
|
|
|
return false;
|
|
|
|
case scCouldNotCompute:
|
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
|
|
|
return false;
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
|
|
|
return false;
|
|
|
|
}
|
2010-11-18 07:28:48 +08:00
|
|
|
|
|
|
|
void ScalarEvolution::forgetMemoizedResults(const SCEV *S) {
|
|
|
|
ValuesAtScopes.erase(S);
|
|
|
|
LoopDispositions.erase(S);
|
2010-11-18 08:34:22 +08:00
|
|
|
BlockDispositions.erase(S);
|
2010-11-18 07:28:48 +08:00
|
|
|
UnsignedRanges.erase(S);
|
|
|
|
SignedRanges.erase(S);
|
|
|
|
}
|