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"
|
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"
|
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"
|
2006-10-05 05:49:37 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2004-04-03 04:23:17 +08:00
|
|
|
#include "llvm/Support/ConstantRange.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));
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
static RegisterPass<ScalarEvolution>
|
|
|
|
R("scalar-evolution", "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
|
|
|
SCEV::~SCEV() {}
|
2009-07-01 04:13:32 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
void SCEV::dump() const {
|
2009-04-21 08:47:46 +08:00
|
|
|
print(errs());
|
|
|
|
errs() << '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
void SCEV::print(std::ostream &o) const {
|
|
|
|
raw_os_ostream OS(o);
|
|
|
|
print(OS);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
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() :
|
2009-07-14 04:50:19 +08:00
|
|
|
SCEV(FoldingSetNodeID(), scCouldNotCompute) {}
|
2009-06-28 05:21:31 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
bool SCEVCouldNotCompute::isLoopInvariant(const Loop *L) const {
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
2004-04-06 03:00:46 +08:00
|
|
|
return false;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
const Type *SCEVCouldNotCompute::getType() const {
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
2004-04-06 03:00:46 +08:00
|
|
|
return 0;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool SCEVCouldNotCompute::hasComputableLoopEvolution(const Loop *L) const {
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
2004-04-03 04:23:17 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-07-25 09:13:03 +08:00
|
|
|
bool SCEVCouldNotCompute::hasOperand(const SCEV *) const {
|
|
|
|
llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
|
|
|
|
return false;
|
2005-02-13 12:37:18 +08:00
|
|
|
}
|
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVCouldNotCompute::print(raw_ostream &OS) const {
|
2004-04-03 04:23:17 +08:00
|
|
|
OS << "***COULDNOTCOMPUTE***";
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVConstant>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVConstant(ID, 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) {
|
2009-07-15 07:09:55 +08:00
|
|
|
return getConstant(
|
2009-07-25 07:12:02 +08:00
|
|
|
ConstantInt::get(cast<IntegerType>(Ty), V, isSigned));
|
2009-06-16 06:12:54 +08:00
|
|
|
}
|
|
|
|
|
2004-04-15 23:07:24 +08:00
|
|
|
const Type *SCEVConstant::getType() const { return V->getType(); }
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVConstant::print(raw_ostream &OS) const {
|
2004-04-15 23:07:24 +08:00
|
|
|
WriteAsOperand(OS, V, false);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 04:50:19 +08:00
|
|
|
SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeID &ID,
|
|
|
|
unsigned SCEVTy, const SCEV *op, const Type *ty)
|
|
|
|
: SCEV(ID, SCEVTy), Op(op), Ty(ty) {}
|
2009-06-28 05:21:31 +08:00
|
|
|
|
2009-04-21 09:25:57 +08:00
|
|
|
bool SCEVCastExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
|
|
|
|
return Op->dominates(BB, DT);
|
|
|
|
}
|
|
|
|
|
2009-07-14 04:50:19 +08:00
|
|
|
SCEVTruncateExpr::SCEVTruncateExpr(const FoldingSetNodeID &ID,
|
|
|
|
const SCEV *op, const Type *ty)
|
|
|
|
: SCEVCastExpr(ID, scTruncate, op, ty) {
|
2009-04-16 11:18:22 +08:00
|
|
|
assert((Op->getType()->isInteger() || isa<PointerType>(Op->getType())) &&
|
|
|
|
(Ty->isInteger() || isa<PointerType>(Ty)) &&
|
2004-04-15 23:07:24 +08:00
|
|
|
"Cannot truncate non-integer value!");
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVTruncateExpr::print(raw_ostream &OS) const {
|
2009-04-30 04:27:52 +08:00
|
|
|
OS << "(trunc " << *Op->getType() << " " << *Op << " to " << *Ty << ")";
|
2004-04-15 23:07:24 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-07-14 04:50:19 +08:00
|
|
|
SCEVZeroExtendExpr::SCEVZeroExtendExpr(const FoldingSetNodeID &ID,
|
|
|
|
const SCEV *op, const Type *ty)
|
|
|
|
: SCEVCastExpr(ID, scZeroExtend, op, ty) {
|
2009-04-16 11:18:22 +08:00
|
|
|
assert((Op->getType()->isInteger() || isa<PointerType>(Op->getType())) &&
|
|
|
|
(Ty->isInteger() || isa<PointerType>(Ty)) &&
|
2004-04-15 23:07:24 +08:00
|
|
|
"Cannot zero extend non-integer value!");
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVZeroExtendExpr::print(raw_ostream &OS) const {
|
2009-04-30 04:27:52 +08:00
|
|
|
OS << "(zext " << *Op->getType() << " " << *Op << " to " << *Ty << ")";
|
2004-04-15 23:07:24 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-07-14 04:50:19 +08:00
|
|
|
SCEVSignExtendExpr::SCEVSignExtendExpr(const FoldingSetNodeID &ID,
|
|
|
|
const SCEV *op, const Type *ty)
|
|
|
|
: SCEVCastExpr(ID, scSignExtend, op, ty) {
|
2009-04-16 11:18:22 +08:00
|
|
|
assert((Op->getType()->isInteger() || isa<PointerType>(Op->getType())) &&
|
|
|
|
(Ty->isInteger() || isa<PointerType>(Ty)) &&
|
2007-06-15 22:38:12 +08:00
|
|
|
"Cannot sign extend non-integer value!");
|
|
|
|
}
|
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVSignExtendExpr::print(raw_ostream &OS) const {
|
2009-04-30 04:27:52 +08:00
|
|
|
OS << "(sext " << *Op->getType() << " " << *Op << " to " << *Ty << ")";
|
2007-06-15 22:38:12 +08:00
|
|
|
}
|
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVCommutativeExpr::print(raw_ostream &OS) const {
|
2004-04-15 23:07:24 +08:00
|
|
|
assert(Operands.size() > 1 && "This plus expr shouldn't exist!");
|
|
|
|
const char *OpStr = getOperationStr();
|
|
|
|
OS << "(" << *Operands[0];
|
|
|
|
for (unsigned i = 1, e = Operands.size(); i != e; ++i)
|
|
|
|
OS << OpStr << *Operands[i];
|
|
|
|
OS << ")";
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-05-07 22:00:19 +08:00
|
|
|
bool SCEVNAryExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
|
2009-02-17 08:13:06 +08:00
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
|
|
|
|
if (!getOperand(i)->dominates(BB, DT))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SCEVUDivExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
|
|
|
|
return LHS->dominates(BB, DT) && RHS->dominates(BB, DT);
|
|
|
|
}
|
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVUDivExpr::print(raw_ostream &OS) const {
|
2008-02-11 19:03:14 +08:00
|
|
|
OS << "(" << *LHS << " /u " << *RHS << ")";
|
2004-04-15 23:07:24 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2008-02-11 19:03:14 +08:00
|
|
|
const Type *SCEVUDivExpr::getType() const {
|
2009-05-27 01:44:05 +08:00
|
|
|
// In most cases the types of LHS and RHS will be the same, but in some
|
|
|
|
// crazy cases one or the other may be a pointer. ScalarEvolution doesn't
|
|
|
|
// depend on the type for correctness, but handling types carefully can
|
|
|
|
// avoid extra casts in the SCEVExpander. The LHS is more likely to be
|
|
|
|
// a pointer type than the RHS, so use the RHS' type here.
|
|
|
|
return RHS->getType();
|
2004-04-15 23:07:24 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2004-04-15 23:07:24 +08:00
|
|
|
bool SCEVAddRecExpr::isLoopInvariant(const Loop *QueryLoop) const {
|
2009-05-20 09:01:24 +08:00
|
|
|
// Add recurrences are never invariant in the function-body (null loop).
|
2009-06-27 06:17:21 +08:00
|
|
|
if (!QueryLoop)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// This recurrence is variant w.r.t. QueryLoop if QueryLoop contains L.
|
|
|
|
if (QueryLoop->contains(L->getHeader()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// This recurrence is variant w.r.t. QueryLoop if any of its operands
|
|
|
|
// are variant.
|
|
|
|
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
|
|
|
|
if (!getOperand(i)->isLoopInvariant(QueryLoop))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Otherwise it's loop-invariant.
|
|
|
|
return true;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVAddRecExpr::print(raw_ostream &OS) const {
|
2004-04-15 23:07:24 +08:00
|
|
|
OS << "{" << *Operands[0];
|
|
|
|
for (unsigned i = 1, e = Operands.size(); i != e; ++i)
|
|
|
|
OS << ",+," << *Operands[i];
|
|
|
|
OS << "}<" << L->getHeader()->getName() + ">";
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2004-04-15 23:07:24 +08:00
|
|
|
bool SCEVUnknown::isLoopInvariant(const Loop *L) const {
|
|
|
|
// All non-instruction values are loop invariant. All instructions are loop
|
|
|
|
// invariant if they are not contained in the specified loop.
|
2009-05-20 09:01:24 +08:00
|
|
|
// Instructions are never considered invariant in the function body
|
|
|
|
// (null loop) because they are defined within the "loop".
|
2004-04-15 23:07:24 +08:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(V))
|
2009-05-20 09:01:24 +08:00
|
|
|
return L && !L->contains(I->getParent());
|
2004-04-15 23:07:24 +08:00
|
|
|
return true;
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-02-17 08:13:06 +08:00
|
|
|
bool SCEVUnknown::dominates(BasicBlock *BB, DominatorTree *DT) const {
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(getValue()))
|
|
|
|
return DT->dominates(I->getParent(), BB);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-04-15 23:07:24 +08:00
|
|
|
const Type *SCEVUnknown::getType() const {
|
|
|
|
return V->getType();
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-04-21 08:47:46 +08:00
|
|
|
void SCEVUnknown::print(raw_ostream &OS) const {
|
2004-04-15 23:07:24 +08:00
|
|
|
WriteAsOperand(OS, V, false);
|
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
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-05-07 22:39:04 +08:00
|
|
|
class VISIBILITY_HIDDEN SCEVComplexityCompare {
|
|
|
|
LoopInfo *LI;
|
|
|
|
public:
|
|
|
|
explicit SCEVComplexityCompare(LoopInfo *li) : LI(li) {}
|
|
|
|
|
2008-04-15 02:23:56 +08:00
|
|
|
bool operator()(const SCEV *LHS, const SCEV *RHS) const {
|
2009-05-07 22:39:04 +08:00
|
|
|
// Primarily, sort the SCEVs by their getSCEVType().
|
|
|
|
if (LHS->getSCEVType() != RHS->getSCEVType())
|
|
|
|
return LHS->getSCEVType() < RHS->getSCEVType();
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
// Sort SCEVUnknown values with some loose heuristics. TODO: This is
|
|
|
|
// not as complete as it could be.
|
|
|
|
if (const SCEVUnknown *LU = dyn_cast<SCEVUnknown>(LHS)) {
|
|
|
|
const SCEVUnknown *RU = cast<SCEVUnknown>(RHS);
|
|
|
|
|
2009-05-19 10:15:55 +08:00
|
|
|
// Order pointer values after integer values. This helps SCEVExpander
|
|
|
|
// form GEPs.
|
|
|
|
if (isa<PointerType>(LU->getType()) && !isa<PointerType>(RU->getType()))
|
|
|
|
return false;
|
|
|
|
if (isa<PointerType>(RU->getType()) && !isa<PointerType>(LU->getType()))
|
|
|
|
return true;
|
|
|
|
|
2009-05-07 22:39:04 +08:00
|
|
|
// Compare getValueID values.
|
|
|
|
if (LU->getValue()->getValueID() != RU->getValue()->getValueID())
|
|
|
|
return LU->getValue()->getValueID() < RU->getValue()->getValueID();
|
|
|
|
|
|
|
|
// Sort arguments by their position.
|
|
|
|
if (const Argument *LA = dyn_cast<Argument>(LU->getValue())) {
|
|
|
|
const Argument *RA = cast<Argument>(RU->getValue());
|
|
|
|
return LA->getArgNo() < RA->getArgNo();
|
|
|
|
}
|
|
|
|
|
|
|
|
// For instructions, compare their loop depth, and their opcode.
|
|
|
|
// This is pretty loose.
|
|
|
|
if (Instruction *LV = dyn_cast<Instruction>(LU->getValue())) {
|
|
|
|
Instruction *RV = cast<Instruction>(RU->getValue());
|
|
|
|
|
|
|
|
// Compare loop depths.
|
|
|
|
if (LI->getLoopDepth(LV->getParent()) !=
|
|
|
|
LI->getLoopDepth(RV->getParent()))
|
|
|
|
return LI->getLoopDepth(LV->getParent()) <
|
|
|
|
LI->getLoopDepth(RV->getParent());
|
|
|
|
|
|
|
|
// Compare opcodes.
|
|
|
|
if (LV->getOpcode() != RV->getOpcode())
|
|
|
|
return LV->getOpcode() < RV->getOpcode();
|
|
|
|
|
|
|
|
// Compare the number of operands.
|
|
|
|
if (LV->getNumOperands() != RV->getNumOperands())
|
|
|
|
return LV->getNumOperands() < RV->getNumOperands();
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-06-15 06:51:25 +08:00
|
|
|
// Compare constant values.
|
|
|
|
if (const SCEVConstant *LC = dyn_cast<SCEVConstant>(LHS)) {
|
|
|
|
const SCEVConstant *RC = cast<SCEVConstant>(RHS);
|
2009-07-05 01:24:52 +08:00
|
|
|
if (LC->getValue()->getBitWidth() != RC->getValue()->getBitWidth())
|
|
|
|
return LC->getValue()->getBitWidth() < RC->getValue()->getBitWidth();
|
2009-06-15 06:51:25 +08:00
|
|
|
return LC->getValue()->getValue().ult(RC->getValue()->getValue());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compare addrec loop depths.
|
|
|
|
if (const SCEVAddRecExpr *LA = dyn_cast<SCEVAddRecExpr>(LHS)) {
|
|
|
|
const SCEVAddRecExpr *RA = cast<SCEVAddRecExpr>(RHS);
|
|
|
|
if (LA->getLoop()->getLoopDepth() != RA->getLoop()->getLoopDepth())
|
|
|
|
return LA->getLoop()->getLoopDepth() < RA->getLoop()->getLoopDepth();
|
|
|
|
}
|
2009-05-07 22:39:04 +08:00
|
|
|
|
|
|
|
// Lexicographically compare n-ary expressions.
|
|
|
|
if (const SCEVNAryExpr *LC = dyn_cast<SCEVNAryExpr>(LHS)) {
|
|
|
|
const SCEVNAryExpr *RC = cast<SCEVNAryExpr>(RHS);
|
|
|
|
for (unsigned i = 0, e = LC->getNumOperands(); i != e; ++i) {
|
|
|
|
if (i >= RC->getNumOperands())
|
|
|
|
return false;
|
|
|
|
if (operator()(LC->getOperand(i), RC->getOperand(i)))
|
|
|
|
return true;
|
|
|
|
if (operator()(RC->getOperand(i), LC->getOperand(i)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return LC->getNumOperands() < RC->getNumOperands();
|
|
|
|
}
|
|
|
|
|
2009-05-08 03:23:21 +08:00
|
|
|
// Lexicographically compare udiv expressions.
|
|
|
|
if (const SCEVUDivExpr *LC = dyn_cast<SCEVUDivExpr>(LHS)) {
|
|
|
|
const SCEVUDivExpr *RC = cast<SCEVUDivExpr>(RHS);
|
|
|
|
if (operator()(LC->getLHS(), RC->getLHS()))
|
|
|
|
return true;
|
|
|
|
if (operator()(RC->getLHS(), LC->getLHS()))
|
|
|
|
return false;
|
|
|
|
if (operator()(LC->getRHS(), RC->getRHS()))
|
|
|
|
return true;
|
|
|
|
if (operator()(RC->getRHS(), LC->getRHS()))
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-05-07 22:39:04 +08:00
|
|
|
// Compare cast expressions by operand.
|
|
|
|
if (const SCEVCastExpr *LC = dyn_cast<SCEVCastExpr>(LHS)) {
|
|
|
|
const SCEVCastExpr *RC = cast<SCEVCastExpr>(RHS);
|
|
|
|
return operator()(LC->getOperand(), RC->getOperand());
|
|
|
|
}
|
|
|
|
|
2009-07-15 00:55:14 +08:00
|
|
|
llvm_unreachable("Unknown SCEV kind!");
|
2009-05-07 22:39:04 +08:00
|
|
|
return false;
|
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.
|
|
|
|
///
|
|
|
|
/// Note that we go take special precautions to ensure that we get determinstic
|
|
|
|
/// 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.
|
2009-05-07 22:39:04 +08:00
|
|
|
if (SCEVComplexityCompare(LI)(Ops[1], Ops[0]))
|
2004-06-20 14:23:15 +08:00
|
|
|
std::swap(Ops[0], Ops[1]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Do the rough sort by complexity.
|
2009-05-07 22:39:04 +08:00
|
|
|
std::stable_sort(Ops.begin(), Ops.end(), SCEVComplexityCompare(LI));
|
2004-06-20 14:23:15 +08:00
|
|
|
|
|
|
|
// 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.
|
2004-06-21 01:01:44 +08:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e-2; ++i) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEV *S = Ops[i];
|
2004-06-20 14:23:15 +08:00
|
|
|
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.
|
2004-06-21 04:32:16 +08:00
|
|
|
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
|
|
|
|
|
|
|
// Calcuate 2^T, at width T+W.
|
|
|
|
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) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *S = SE.getMinusSCEV(It, SE.getIntegerSCEV(i, It->getType()));
|
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(
|
|
|
|
cast<ConstantInt>(ConstantExpr::getTrunc(SC->getValue(), 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);
|
|
|
|
|
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));
|
|
|
|
return getAddRecExpr(Operands, AddRec->getLoop());
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 04:50:19 +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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVTruncateExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVTruncateExpr(ID, 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.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op)) {
|
2009-04-21 09:07:12 +08:00
|
|
|
const Type *IntTy = getEffectiveSCEVType(Ty);
|
2009-04-16 11:18:22 +08:00
|
|
|
Constant *C = ConstantExpr::getZExt(SC->getValue(), IntTy);
|
|
|
|
if (IntTy != Ty) C = ConstantExpr::getIntToPtr(C, Ty);
|
2009-06-24 08:38:39 +08:00
|
|
|
return getConstant(cast<ConstantInt>(C));
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
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;
|
|
|
|
|
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.
|
|
|
|
if (AR->hasNoUnsignedOverflow())
|
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getZeroExtendExpr(Step, Ty),
|
|
|
|
L);
|
|
|
|
|
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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ZMul =
|
2009-05-01 04:47:05 +08:00
|
|
|
getMulExpr(CastedMaxBECount,
|
2009-04-28 04:16:15 +08:00
|
|
|
getTruncateOrZeroExtend(Step, Start->getType()));
|
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)));
|
|
|
|
if (getZeroExtendExpr(Add, WideTy) == OperandExtendedAdd)
|
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),
|
2009-07-14 05:35:55 +08:00
|
|
|
L);
|
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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SMul =
|
2009-05-01 04:47:05 +08:00
|
|
|
getMulExpr(CastedMaxBECount,
|
2009-04-28 04:16:15 +08:00
|
|
|
getTruncateOrSignExtend(Step, Start->getType()));
|
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)));
|
|
|
|
if (getZeroExtendExpr(Add, WideTy) == OperandExtendedAdd)
|
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),
|
2009-07-14 05:35:55 +08:00
|
|
|
L);
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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) ||
|
|
|
|
(isLoopGuardedByCond(L, ICmpInst::ICMP_ULT, Start, N) &&
|
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_ULT,
|
|
|
|
AR->getPostIncExpr(*this), N)))
|
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getZeroExtendExpr(Step, Ty),
|
|
|
|
L);
|
|
|
|
} else if (isKnownNegative(Step)) {
|
|
|
|
const SCEV *N = getConstant(APInt::getMaxValue(BitWidth) -
|
|
|
|
getSignedRange(Step).getSignedMin());
|
|
|
|
if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT, AR, N) &&
|
|
|
|
(isLoopGuardedByCond(L, ICmpInst::ICMP_UGT, Start, N) ||
|
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_UGT,
|
|
|
|
AR->getPostIncExpr(*this), N)))
|
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getZeroExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
|
|
|
L);
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVZeroExtendExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVZeroExtendExpr(ID, 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.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(Op)) {
|
2009-04-21 09:07:12 +08:00
|
|
|
const Type *IntTy = getEffectiveSCEVType(Ty);
|
2009-04-16 11:18:22 +08:00
|
|
|
Constant *C = ConstantExpr::getSExt(SC->getValue(), IntTy);
|
|
|
|
if (IntTy != Ty) C = ConstantExpr::getIntToPtr(C, Ty);
|
2009-06-24 08:38:39 +08:00
|
|
|
return getConstant(cast<ConstantInt>(C));
|
2009-04-16 11:18:22 +08:00
|
|
|
}
|
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);
|
|
|
|
|
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;
|
|
|
|
|
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.
|
|
|
|
if (AR->hasNoSignedOverflow())
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
|
|
|
L);
|
|
|
|
|
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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *SMul =
|
2009-05-01 04:47:05 +08:00
|
|
|
getMulExpr(CastedMaxBECount,
|
2009-04-28 04:16:15 +08:00
|
|
|
getTruncateOrSignExtend(Step, Start->getType()));
|
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)));
|
|
|
|
if (getSignExtendExpr(Add, WideTy) == OperandExtendedAdd)
|
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),
|
2009-07-14 05:35:55 +08:00
|
|
|
L);
|
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.
|
|
|
|
const SCEV *UMul =
|
|
|
|
getMulExpr(CastedMaxBECount,
|
|
|
|
getTruncateOrZeroExtend(Step, Start->getType()));
|
|
|
|
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)));
|
2009-07-26 00:03:30 +08:00
|
|
|
if (getSignExtendExpr(Add, WideTy) == OperandExtendedAdd)
|
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),
|
|
|
|
L);
|
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) ||
|
|
|
|
(isLoopGuardedByCond(L, ICmpInst::ICMP_SLT, Start, N) &&
|
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SLT,
|
|
|
|
AR->getPostIncExpr(*this), N)))
|
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
|
|
|
L);
|
|
|
|
} else if (isKnownNegative(Step)) {
|
|
|
|
const SCEV *N = getConstant(APInt::getSignedMaxValue(BitWidth) -
|
|
|
|
getSignedRange(Step).getSignedMin());
|
|
|
|
if (isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SGT, AR, N) ||
|
|
|
|
(isLoopGuardedByCond(L, ICmpInst::ICMP_SGT, Start, N) &&
|
|
|
|
isLoopBackedgeGuardedByCond(L, ICmpInst::ICMP_SGT,
|
|
|
|
AR->getPostIncExpr(*this), N)))
|
|
|
|
// Return the expression with the addrec on the outside.
|
|
|
|
return getAddRecExpr(getSignExtendExpr(Start, Ty),
|
|
|
|
getSignExtendExpr(Step, Ty),
|
|
|
|
L);
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVSignExtendExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVSignExtendExpr(ID, 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-06-13 23:56:47 +08:00
|
|
|
const Type *Ty) {
|
|
|
|
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;
|
|
|
|
|
|
|
|
// 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,
|
2009-07-08 01:06:11 +08:00
|
|
|
const SmallVectorImpl<const SCEV *> &Ops,
|
2009-06-15 06:58:51 +08:00
|
|
|
const APInt &Scale,
|
|
|
|
ScalarEvolution &SE) {
|
|
|
|
bool Interesting = false;
|
|
|
|
|
|
|
|
// Iterate over the add operands.
|
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
|
|
|
|
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.
|
|
|
|
Interesting |=
|
|
|
|
CollectAddOperandsWithScales(M, NewOps, AccumulatedConstant,
|
|
|
|
cast<SCEVAddExpr>(Mul->getOperand(1))
|
|
|
|
->getOperands(),
|
|
|
|
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 if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[i])) {
|
|
|
|
// Pull a buried constant out to the outside.
|
|
|
|
if (Scale != 1 || AccumulatedConstant != 0 || C->isZero())
|
|
|
|
Interesting = true;
|
|
|
|
AccumulatedConstant += Scale * C->getValue()->getValue();
|
|
|
|
} 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-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getAddExpr(SmallVectorImpl<const SCEV *> &Ops) {
|
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
|
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) ==
|
|
|
|
getEffectiveSCEVType(Ops[0]->getType()) &&
|
|
|
|
"SCEVAddExpr operand types don't match!");
|
|
|
|
#endif
|
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.
|
2007-03-02 08:28:52 +08:00
|
|
|
if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
|
2004-04-03 04:23:17 +08:00
|
|
|
Ops.erase(Ops.begin());
|
|
|
|
--Idx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-08 00:16:11 +08:00
|
|
|
if (Ops.size() == 1) return Ops[0];
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Okay, check to see if the same value occurs in the operand list twice. If
|
|
|
|
// so, merge them together into an multiply expression. Since we sorted the
|
|
|
|
// list, these values are required to be adjacent.
|
|
|
|
const Type *Ty = Ops[0]->getType();
|
|
|
|
for (unsigned i = 0, e = Ops.size()-1; i != e; ++i)
|
|
|
|
if (Ops[i] == Ops[i+1]) { // X + Y + Y --> X + Y*2
|
|
|
|
// Found a match, merge the two values into a multiply, and add any
|
|
|
|
// remaining values to the result.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Two = getIntegerSCEV(2, Ty);
|
|
|
|
const SCEV *Mul = getMulExpr(Ops[i], Two);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Ops.size() == 2)
|
|
|
|
return Mul;
|
|
|
|
Ops.erase(Ops.begin()+i, Ops.begin()+i+2);
|
|
|
|
Ops.push_back(Mul);
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddExpr(Ops);
|
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])) {
|
|
|
|
// This could be either sign or zero extension, but sign extension
|
|
|
|
// is much more likely to be foldable here.
|
|
|
|
LargeOps.push_back(getSignExtendExpr(C, SrcType));
|
|
|
|
} 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))) {
|
|
|
|
// This could be either sign or zero extension, but sign extension
|
|
|
|
// is much more likely to be foldable here.
|
|
|
|
LargeMulOps.push_back(getSignExtendExpr(C, SrcType));
|
|
|
|
} else {
|
|
|
|
Ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Ok)
|
|
|
|
LargeOps.push_back(getMulExpr(LargeMulOps));
|
|
|
|
} else {
|
|
|
|
Ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Ok) {
|
|
|
|
// Evaluate the expression in the larger type.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Fold = getAddExpr(LargeOps);
|
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.insert(Ops.end(), Add->op_begin(), Add->op_end());
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
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
|
|
|
|
// any operands we just aquired.
|
|
|
|
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,
|
|
|
|
Ops, APInt(BitWidth, 1), *this)) {
|
|
|
|
// 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;
|
|
|
|
for (SmallVector<const SCEV *, 8>::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())
|
|
|
|
return getIntegerSCEV(0, Ty);
|
|
|
|
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);
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned AddOp = 0, e = Ops.size(); AddOp != e; ++AddOp)
|
2009-06-15 06:47:23 +08:00
|
|
|
if (MulOpSCEV == Ops[AddOp] && !isa<SCEVConstant>(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.
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(), Mul->op_end());
|
2004-04-03 04:23:17 +08:00
|
|
|
MulOps.erase(MulOps.begin()+MulOp);
|
2007-10-23 02:31:58 +08:00
|
|
|
InnerMul = getMulExpr(MulOps);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *One = getIntegerSCEV(1, Ty);
|
|
|
|
const SCEV *AddOne = getAddExpr(InnerMul, One);
|
|
|
|
const SCEV *OuterMul = getMulExpr(AddOne, Ops[AddOp]);
|
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(),
|
|
|
|
Mul->op_end());
|
2004-04-03 04:23:17 +08:00
|
|
|
MulOps.erase(MulOps.begin()+MulOp);
|
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(),
|
|
|
|
OtherMul->op_end());
|
2004-04-03 04:23:17 +08:00
|
|
|
MulOps.erase(MulOps.begin()+OMulOp);
|
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;
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
Ops.erase(Ops.begin()+OtherMulIdx-1);
|
|
|
|
Ops.push_back(OuterMul);
|
2007-10-23 02:31:58 +08:00
|
|
|
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]);
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
if (Ops[i]->isLoopInvariant(AddRec->getLoop())) {
|
|
|
|
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-06-15 06:47:23 +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
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewRec = getAddRecExpr(AddRecOps, AddRec->getLoop());
|
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;
|
|
|
|
OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);++OtherIdx)
|
|
|
|
if (OtherIdx != Idx) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *OtherAddRec = cast<SCEVAddRecExpr>(Ops[OtherIdx]);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (AddRec->getLoop() == OtherAddRec->getLoop()) {
|
|
|
|
// Other + {A,+,B} + {C,+,D} --> Other + {A+C,+,B+D}
|
2009-06-24 12:48:43 +08:00
|
|
|
SmallVector<const SCEV *, 4> NewOps(AddRec->op_begin(),
|
|
|
|
AddRec->op_end());
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = OtherAddRec->getNumOperands(); i != e; ++i) {
|
|
|
|
if (i >= NewOps.size()) {
|
|
|
|
NewOps.insert(NewOps.end(), OtherAddRec->op_begin()+i,
|
|
|
|
OtherAddRec->op_end());
|
|
|
|
break;
|
|
|
|
}
|
2007-10-23 02:31:58 +08:00
|
|
|
NewOps[i] = getAddExpr(NewOps[i], OtherAddRec->getOperand(i));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewAddRec = getAddRecExpr(NewOps, AddRec->getLoop());
|
2004-04-03 04:23:17 +08:00
|
|
|
|
|
|
|
if (Ops.size() == 2) return NewAddRec;
|
|
|
|
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
Ops.erase(Ops.begin()+OtherIdx-1);
|
|
|
|
Ops.push_back(NewAddRec);
|
2007-10-23 02:31:58 +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);
|
|
|
|
ID.AddInteger(Ops.size());
|
|
|
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVAddExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVAddExpr(ID, Ops);
|
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
|
|
|
/// getMulExpr - Get a canonical multiply expression, or something simpler if
|
|
|
|
/// possible.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getMulExpr(SmallVectorImpl<const SCEV *> &Ops) {
|
2004-04-03 04:23:17 +08:00
|
|
|
assert(!Ops.empty() && "Cannot get empty mul!");
|
2009-05-18 23:44:58 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) ==
|
|
|
|
getEffectiveSCEVType(Ops[0]->getType()) &&
|
|
|
|
"SCEVMulExpr operand types don't match!");
|
|
|
|
#endif
|
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];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Skip over the add expression until we get to a multiply.
|
|
|
|
while (Idx < Ops.size() && Ops[Idx]->getSCEVType() < scMulExpr)
|
|
|
|
++Idx;
|
|
|
|
|
|
|
|
if (Ops.size() == 1)
|
|
|
|
return Ops[0];
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// 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.insert(Ops.end(), Mul->op_begin(), Mul->op_end());
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
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
|
|
|
|
// any operands we just aquired.
|
|
|
|
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]);
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
|
|
|
|
if (Ops[i]->isLoopInvariant(AddRec->getLoop())) {
|
|
|
|
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());
|
|
|
|
if (LIOps.size() == 1) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEV *Scale = LIOps[0];
|
2004-04-03 04:23:17 +08:00
|
|
|
for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i)
|
2007-10-23 02:31:58 +08:00
|
|
|
NewOps.push_back(getMulExpr(Scale, AddRec->getOperand(i)));
|
2004-04-03 04:23:17 +08:00
|
|
|
} else {
|
|
|
|
for (unsigned i = 0, e = AddRec->getNumOperands(); i != e; ++i) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> MulOps(LIOps.begin(), LIOps.end());
|
2004-04-03 04:23:17 +08:00
|
|
|
MulOps.push_back(AddRec->getOperand(i));
|
2007-10-23 02:31:58 +08:00
|
|
|
NewOps.push_back(getMulExpr(MulOps));
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewRec = getAddRecExpr(NewOps, AddRec->getLoop());
|
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;
|
|
|
|
OtherIdx < Ops.size() && isa<SCEVAddRecExpr>(Ops[OtherIdx]);++OtherIdx)
|
|
|
|
if (OtherIdx != Idx) {
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *OtherAddRec = cast<SCEVAddRecExpr>(Ops[OtherIdx]);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (AddRec->getLoop() == OtherAddRec->getLoop()) {
|
|
|
|
// F * G --> {A,+,B} * {C,+,D} --> {A*C,+,F*D + G*B + B*D}
|
2009-05-05 06:30:44 +08:00
|
|
|
const SCEVAddRecExpr *F = AddRec, *G = OtherAddRec;
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewStart = getMulExpr(F->getStart(),
|
2004-04-03 04:23:17 +08:00
|
|
|
G->getStart());
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *B = F->getStepRecurrence(*this);
|
|
|
|
const SCEV *D = G->getStepRecurrence(*this);
|
|
|
|
const SCEV *NewStep = getAddExpr(getMulExpr(F, D),
|
2007-10-23 02:31:58 +08:00
|
|
|
getMulExpr(G, B),
|
|
|
|
getMulExpr(B, D));
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewAddRec = getAddRecExpr(NewStart, NewStep,
|
2007-10-23 02:31:58 +08:00
|
|
|
F->getLoop());
|
2004-04-03 04:23:17 +08:00
|
|
|
if (Ops.size() == 2) return NewAddRec;
|
|
|
|
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
Ops.erase(Ops.begin()+OtherIdx-1);
|
|
|
|
Ops.push_back(NewAddRec);
|
2007-10-23 02:31:58 +08:00
|
|
|
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);
|
|
|
|
ID.AddInteger(Ops.size());
|
|
|
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVMulExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVMulExpr(ID, Ops);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
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-01-13 17:18:58 +08:00
|
|
|
return LHS; // X udiv 1 --> x
|
2009-05-09 04:18:49 +08:00
|
|
|
if (RHSC->isZero())
|
|
|
|
return getIntegerSCEV(0, LHS->getType()); // value is undefined
|
|
|
|
|
|
|
|
// 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();
|
|
|
|
unsigned MaxShiftAmt = getTypeSizeInBits(Ty) - LZ;
|
|
|
|
// 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 =
|
2009-08-14 05:58:54 +08:00
|
|
|
IntegerType::get(getContext(), getTypeSizeInBits(Ty) + MaxShiftAmt);
|
2009-05-09 04:18:49 +08:00
|
|
|
// {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()) &&
|
2009-05-09 07:11:16 +08:00
|
|
|
getZeroExtendExpr(AR, ExtTy) ==
|
|
|
|
getAddRecExpr(getZeroExtendExpr(AR->getStart(), ExtTy),
|
|
|
|
getZeroExtendExpr(Step, ExtTy),
|
|
|
|
AR->getLoop())) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
2009-05-09 04:18:49 +08:00
|
|
|
for (unsigned i = 0, e = AR->getNumOperands(); i != e; ++i)
|
|
|
|
Operands.push_back(getUDivExpr(AR->getOperand(i), RHS));
|
|
|
|
return getAddRecExpr(Operands, AR->getLoop());
|
|
|
|
}
|
|
|
|
// (A*B)/C --> A*(B/C) if safe and B/C can be folded.
|
2009-05-09 07:11:16 +08:00
|
|
|
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(LHS)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
2009-05-09 07:11:16 +08:00
|
|
|
for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i)
|
|
|
|
Operands.push_back(getZeroExtendExpr(M->getOperand(i), ExtTy));
|
|
|
|
if (getZeroExtendExpr(M, ExtTy) == getMulExpr(Operands))
|
2009-05-09 04:18:49 +08:00
|
|
|
// Find an operand that's safely divisible.
|
|
|
|
for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Op = M->getOperand(i);
|
|
|
|
const SCEV *Div = getUDivExpr(Op, RHSC);
|
2009-05-09 04:18:49 +08:00
|
|
|
if (!isa<SCEVUDivExpr>(Div) && getMulExpr(Div, RHSC) == Op) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SmallVectorImpl<const SCEV *> &MOperands = M->getOperands();
|
|
|
|
Operands = SmallVector<const SCEV *, 4>(MOperands.begin(),
|
2009-06-15 06:47:23 +08:00
|
|
|
MOperands.end());
|
2009-05-09 04:18:49 +08:00
|
|
|
Operands[i] = Div;
|
|
|
|
return getMulExpr(Operands);
|
|
|
|
}
|
|
|
|
}
|
2009-05-09 07:11:16 +08:00
|
|
|
}
|
2009-05-09 04:18:49 +08:00
|
|
|
// (A+B)/C --> (A/C + B/C) if safe and A/C and B/C can be folded.
|
2009-05-09 07:11:16 +08:00
|
|
|
if (const SCEVAddRecExpr *A = dyn_cast<SCEVAddRecExpr>(LHS)) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> Operands;
|
2009-05-09 07:11:16 +08:00
|
|
|
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();
|
2009-05-09 04:18:49 +08:00
|
|
|
for (unsigned i = 0, e = A->getNumOperands(); i != e; ++i) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Op = getUDivExpr(A->getOperand(i), RHS);
|
2009-05-09 04:18:49 +08:00
|
|
|
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 07:11:16 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-05-09 04:18:49 +08:00
|
|
|
// Fold if both operands are constant.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
Constant *LHSCV = LHSC->getValue();
|
|
|
|
Constant *RHSCV = RHSC->getValue();
|
2009-07-30 02:55:55 +08:00
|
|
|
return getConstant(cast<ConstantInt>(ConstantExpr::getUDiv(LHSCV,
|
2009-06-24 08:38:39 +08:00
|
|
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVUDivExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVUDivExpr(ID, 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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getAddRecExpr(const SCEV *Start,
|
2009-07-24 09:03:59 +08:00
|
|
|
const SCEV *Step, const Loop *L) {
|
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) {
|
|
|
|
Operands.insert(Operands.end(), StepChrec->op_begin(),
|
|
|
|
StepChrec->op_end());
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddRecExpr(Operands, L);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Operands.push_back(Step);
|
2007-10-23 02:31:58 +08:00
|
|
|
return getAddRecExpr(Operands, L);
|
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,
|
2009-06-24 12:48:43 +08:00
|
|
|
const Loop *L) {
|
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
|
|
|
|
for (unsigned i = 1, e = Operands.size(); i != e; ++i)
|
|
|
|
assert(getEffectiveSCEVType(Operands[i]->getType()) ==
|
|
|
|
getEffectiveSCEVType(Operands[0]->getType()) &&
|
|
|
|
"SCEVAddRecExpr operand types don't match!");
|
|
|
|
#endif
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2008-06-19 00:23:07 +08:00
|
|
|
if (Operands.back()->isZero()) {
|
|
|
|
Operands.pop_back();
|
2008-09-15 01:21:12 +08:00
|
|
|
return getAddRecExpr(Operands, L); // {X,+,0} --> X
|
2008-06-19 00:23:07 +08:00
|
|
|
}
|
2004-04-03 04:23:17 +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])) {
|
2008-08-09 02:33:12 +08:00
|
|
|
const Loop* NestedLoop = NestedAR->getLoop();
|
|
|
|
if (L->getLoopDepth() < NestedLoop->getLoopDepth()) {
|
2009-07-08 01:06:11 +08:00
|
|
|
SmallVector<const SCEV *, 4> NestedOperands(NestedAR->op_begin(),
|
2009-06-15 06:47:23 +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)
|
|
|
|
if (!Operands[i]->isLoopInvariant(L)) {
|
|
|
|
AllInvariant = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (AllInvariant) {
|
|
|
|
NestedOperands[0] = getAddRecExpr(Operands, L);
|
|
|
|
AllInvariant = true;
|
|
|
|
for (unsigned i = 0, e = NestedOperands.size(); i != e; ++i)
|
|
|
|
if (!NestedOperands[i]->isLoopInvariant(NestedLoop)) {
|
|
|
|
AllInvariant = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (AllInvariant)
|
|
|
|
// Ok, both add recurrences are valid after the transformation.
|
|
|
|
return getAddRecExpr(NestedOperands, NestedLoop);
|
|
|
|
}
|
|
|
|
// Reset Operands to its original state.
|
|
|
|
Operands[0] = NestedAR;
|
2008-08-09 02:33:12 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-28 05:21:31 +08:00
|
|
|
FoldingSetNodeID ID;
|
|
|
|
ID.AddInteger(scAddRecExpr);
|
|
|
|
ID.AddInteger(Operands.size());
|
|
|
|
for (unsigned i = 0, e = Operands.size(); i != e; ++i)
|
|
|
|
ID.AddPointer(Operands[i]);
|
|
|
|
ID.AddPointer(L);
|
|
|
|
void *IP = 0;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVAddRecExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVAddRecExpr(ID, Operands, L);
|
2009-06-28 05:21:31 +08:00
|
|
|
UniqueSCEVs.InsertNode(S, IP);
|
|
|
|
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
|
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) ==
|
|
|
|
getEffectiveSCEVType(Ops[0]->getType()) &&
|
|
|
|
"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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
|
|
|
|
// 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.insert(Ops.end(), SMax->op_begin(), SMax->op_end());
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
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)
|
|
|
|
if (Ops[i] == Ops[i+1]) { // X smax Y smax Y --> X smax Y
|
|
|
|
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);
|
|
|
|
ID.AddInteger(Ops.size());
|
|
|
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVSMaxExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVSMaxExpr(ID, Ops);
|
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
|
|
|
|
for (unsigned i = 1, e = Ops.size(); i != e; ++i)
|
|
|
|
assert(getEffectiveSCEVType(Ops[i]->getType()) ==
|
|
|
|
getEffectiveSCEVType(Ops[0]->getType()) &&
|
|
|
|
"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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Ops.size() == 1) return Ops[0];
|
|
|
|
|
|
|
|
// 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.insert(Ops.end(), UMax->op_begin(), UMax->op_end());
|
|
|
|
Ops.erase(Ops.begin()+Idx);
|
|
|
|
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)
|
|
|
|
if (Ops[i] == Ops[i+1]) { // X umax Y umax Y --> X umax Y
|
|
|
|
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);
|
|
|
|
ID.AddInteger(Ops.size());
|
|
|
|
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;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVUMaxExpr>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVUMaxExpr(ID, Ops);
|
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)));
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
|
|
|
|
SCEV *S = SCEVAllocator.Allocate<SCEVUnknown>();
|
2009-07-14 04:50:19 +08:00
|
|
|
new (S) SCEVUnknown(ID, V);
|
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-04-21 09:07:12 +08:00
|
|
|
// Integers are always SCEVable.
|
|
|
|
if (Ty->isInteger())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Pointers are SCEVable if TargetData information is available
|
|
|
|
// to provide pointer size information.
|
|
|
|
if (isa<PointerType>(Ty))
|
|
|
|
return TD != NULL;
|
|
|
|
|
|
|
|
// Otherwise it's not SCEVable.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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);
|
|
|
|
|
|
|
|
// Otherwise, we support only integer types.
|
|
|
|
assert(Ty->isInteger() && "isSCEVable permitted a non-SCEVable type!");
|
|
|
|
return Ty->getPrimitiveSizeInBits();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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!");
|
|
|
|
|
|
|
|
if (Ty->isInteger())
|
|
|
|
return Ty;
|
|
|
|
|
|
|
|
assert(isa<PointerType>(Ty) && "Unexpected non-pointer non-integer type!");
|
2009-08-14 05:58:54 +08:00
|
|
|
return TD->getIntPtrType(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
|
|
|
|
2009-07-08 01:06:11 +08:00
|
|
|
std::map<SCEVCallbackVH, const SCEV *>::iterator I = Scalars.find(V);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (I != Scalars.end()) return I->second;
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *S = createSCEV(V);
|
2009-05-05 06:30:44 +08:00
|
|
|
Scalars.insert(std::make_pair(SCEVCallbackVH(V, this), S));
|
2004-04-03 04:23:17 +08:00
|
|
|
return S;
|
|
|
|
}
|
|
|
|
|
2009-06-24 08:54:57 +08:00
|
|
|
/// getIntegerSCEV - Given a SCEVable type, create a constant for the
|
2009-04-16 11:18:22 +08:00
|
|
|
/// specified signed integer value and return a SCEV for the constant.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ScalarEvolution::getIntegerSCEV(int Val, const Type *Ty) {
|
2009-06-24 08:54:57 +08:00
|
|
|
const IntegerType *ITy = cast<IntegerType>(getEffectiveSCEVType(Ty));
|
2009-07-25 07:12:02 +08:00
|
|
|
return getConstant(ConstantInt::get(ITy, Val));
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getMinusSCEV - Return a SCEV corresponding to LHS - RHS.
|
|
|
|
///
|
2009-06-24 22:49:00 +08:00
|
|
|
const SCEV *ScalarEvolution::getMinusSCEV(const SCEV *LHS,
|
|
|
|
const SCEV *RHS) {
|
2009-04-16 11:18:22 +08:00
|
|
|
// X - Y --> X + -Y
|
2009-04-22 07:15:49 +08:00
|
|
|
return getAddExpr(LHS, getNegativeSCEV(RHS));
|
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 *
|
|
|
|
ScalarEvolution::getTruncateOrZeroExtend(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();
|
2009-04-21 09:07:12 +08:00
|
|
|
assert((SrcTy->isInteger() || (TD && isa<PointerType>(SrcTy))) &&
|
|
|
|
(Ty->isInteger() || (TD && isa<PointerType>(Ty))) &&
|
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();
|
2009-04-21 09:07:12 +08:00
|
|
|
assert((SrcTy->isInteger() || (TD && isa<PointerType>(SrcTy))) &&
|
|
|
|
(Ty->isInteger() || (TD && isa<PointerType>(Ty))) &&
|
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();
|
|
|
|
assert((SrcTy->isInteger() || (TD && isa<PointerType>(SrcTy))) &&
|
|
|
|
(Ty->isInteger() || (TD && isa<PointerType>(Ty))) &&
|
|
|
|
"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();
|
|
|
|
assert((SrcTy->isInteger() || (TD && isa<PointerType>(SrcTy))) &&
|
|
|
|
(Ty->isInteger() || (TD && isa<PointerType>(Ty))) &&
|
|
|
|
"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();
|
|
|
|
assert((SrcTy->isInteger() || (TD && isa<PointerType>(SrcTy))) &&
|
|
|
|
(Ty->isInteger() || (TD && isa<PointerType>(Ty))) &&
|
|
|
|
"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();
|
|
|
|
assert((SrcTy->isInteger() || (TD && isa<PointerType>(SrcTy))) &&
|
|
|
|
(Ty->isInteger() || (TD && isa<PointerType>(Ty))) &&
|
|
|
|
"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)
|
|
|
|
Worklist.push_back(cast<Instruction>(UI));
|
|
|
|
}
|
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
|
|
|
|
/// the Scalars map if they reference SymName. This is used during PHI
|
|
|
|
/// resolution.
|
|
|
|
void
|
|
|
|
ScalarEvolution::ForgetSymbolicName(Instruction *I, const SCEV *SymName) {
|
|
|
|
SmallVector<Instruction *, 16> Worklist;
|
|
|
|
PushDefUseChildren(I, Worklist);
|
|
|
|
|
|
|
|
SmallPtrSet<Instruction *, 8> Visited;
|
|
|
|
Visited.insert(I);
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Instruction *I = Worklist.pop_back_val();
|
|
|
|
if (!Visited.insert(I)) continue;
|
|
|
|
|
|
|
|
std::map<SCEVCallbackVH, const SCEV*>::iterator It =
|
|
|
|
Scalars.find(static_cast<Value *>(I));
|
|
|
|
if (It != Scalars.end()) {
|
|
|
|
// Short-circuit the def-use traversal if the symbolic name
|
|
|
|
// ceases to appear in expressions.
|
|
|
|
if (!It->second->hasOperand(SymName))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// 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>(It->second))
|
|
|
|
Scalars.erase(It);
|
|
|
|
ValuesAtScopes.erase(I);
|
|
|
|
}
|
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) {
|
2004-04-03 04:23:17 +08:00
|
|
|
if (PN->getNumIncomingValues() == 2) // The loops have been canonicalized.
|
2009-04-22 07:15:49 +08:00
|
|
|
if (const Loop *L = LI->getLoopFor(PN->getParent()))
|
2004-04-03 04:23:17 +08:00
|
|
|
if (L->getHeader() == PN->getParent()) {
|
|
|
|
// If it lives in the loop header, it has two incoming values, one
|
|
|
|
// from outside the loop, and one from inside.
|
|
|
|
unsigned IncomingEdge = L->contains(PN->getIncomingBlock(0));
|
|
|
|
unsigned BackEdge = IncomingEdge^1;
|
2005-04-22 05:13:18 +08:00
|
|
|
|
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);
|
2004-04-03 04:23:17 +08:00
|
|
|
assert(Scalars.find(PN) == Scalars.end() &&
|
|
|
|
"PHI node already processed?");
|
2009-05-05 06:30:44 +08:00
|
|
|
Scalars.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
|
|
|
Value *BEValueV = PN->getIncomingValue(BackEdge);
|
|
|
|
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.
|
|
|
|
if (Accum->isLoopInvariant(L) ||
|
|
|
|
(isa<SCEVAddRecExpr>(Accum) &&
|
|
|
|
cast<SCEVAddRecExpr>(Accum)->getLoop() == L)) {
|
2009-06-24 12:48:43 +08:00
|
|
|
const SCEV *StartVal =
|
|
|
|
getSCEV(PN->getIncomingValue(IncomingEdge));
|
2009-07-25 09:22:26 +08:00
|
|
|
const SCEVAddRecExpr *PHISCEV =
|
|
|
|
cast<SCEVAddRecExpr>(getAddRecExpr(StartVal, Accum, L));
|
|
|
|
|
|
|
|
// 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->getOperand(0) == PN &&
|
|
|
|
getSCEV(OBO->getOperand(1)) ==
|
|
|
|
PHISCEV->getStepRecurrence(*this)) {
|
|
|
|
const SCEVAddRecExpr *PostInc = PHISCEV->getPostIncExpr(*this);
|
|
|
|
if (OBO->hasNoUnsignedOverflow()) {
|
|
|
|
const_cast<SCEVAddRecExpr *>(PHISCEV)
|
|
|
|
->setHasNoUnsignedOverflow(true);
|
|
|
|
const_cast<SCEVAddRecExpr *>(PostInc)
|
|
|
|
->setHasNoUnsignedOverflow(true);
|
|
|
|
}
|
|
|
|
if (OBO->hasNoSignedOverflow()) {
|
|
|
|
const_cast<SCEVAddRecExpr *>(PHISCEV)
|
|
|
|
->setHasNoSignedOverflow(true);
|
|
|
|
const_cast<SCEVAddRecExpr *>(PostInc)
|
|
|
|
->setHasNoSignedOverflow(true);
|
|
|
|
}
|
|
|
|
}
|
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);
|
|
|
|
Scalars[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()) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *StartVal = getSCEV(PN->getIncomingValue(IncomingEdge));
|
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),
|
2007-10-23 02:31:58 +08:00
|
|
|
AddRec->getOperand(1))) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *PHISCEV =
|
2009-04-22 07:15:49 +08:00
|
|
|
getAddRecExpr(StartVal, AddRec->getOperand(1), L);
|
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);
|
|
|
|
Scalars[SCEVCallbackVH(PN, this)] = PHISCEV;
|
2004-04-03 04:23:17 +08:00
|
|
|
return PHISCEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return SymbolicName;
|
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
2009-07-14 22:06:25 +08:00
|
|
|
// It's tempting to recognize PHIs with a unique incoming value, however
|
|
|
|
// this leads passes like indvars to break LCSSA form. Fortunately, such
|
|
|
|
// PHIs are rare, as instcombine zaps them.
|
|
|
|
|
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-07-18 04:47:02 +08:00
|
|
|
const SCEV *ScalarEvolution::createNodeForGEP(Operator *GEP) {
|
2009-05-09 04:26:55 +08:00
|
|
|
|
2009-08-14 05:58:54 +08:00
|
|
|
const Type *IntPtrTy = TD->getIntPtrType(getContext());
|
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);
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *TotalOffset = getIntegerSCEV(0, IntPtrTy);
|
2009-05-09 04:36:47 +08:00
|
|
|
gep_type_iterator GTI = gep_type_begin(GEP);
|
|
|
|
for (GetElementPtrInst::op_iterator I = next(GEP->op_begin()),
|
|
|
|
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.
|
|
|
|
const StructLayout &SL = *TD->getStructLayout(STy);
|
|
|
|
unsigned FieldNo = cast<ConstantInt>(Index)->getZExtValue();
|
|
|
|
uint64_t Offset = SL.getElementOffset(FieldNo);
|
2009-07-14 05:35:55 +08:00
|
|
|
TotalOffset = getAddExpr(TotalOffset, getIntegerSCEV(Offset, IntPtrTy));
|
2009-05-09 04:26:55 +08:00
|
|
|
} else {
|
|
|
|
// For an array, add the element offset, explicitly scaled.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *LocalOffset = getSCEV(Index);
|
2009-05-09 04:26:55 +08:00
|
|
|
if (!isa<PointerType>(LocalOffset->getType()))
|
|
|
|
// Getelementptr indicies are signed.
|
2009-07-14 05:35:55 +08:00
|
|
|
LocalOffset = getTruncateOrSignExtend(LocalOffset, IntPtrTy);
|
2009-05-09 04:26:55 +08:00
|
|
|
LocalOffset =
|
|
|
|
getMulExpr(LocalOffset,
|
2009-07-14 05:35:55 +08:00
|
|
|
getIntegerSCEV(TD->getTypeAllocSize(*GTI), IntPtrTy));
|
2009-05-09 04:26:55 +08:00
|
|
|
TotalOffset = getAddExpr(TotalOffset, LocalOffset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return getAddExpr(getSCEV(Base), TotalOffset);
|
|
|
|
}
|
|
|
|
|
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) {
|
2009-06-20 07:29:04 +08:00
|
|
|
|
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
|
2009-07-14 05:35:55 +08:00
|
|
|
return ConstantRange(C->getValue()->getValue());
|
|
|
|
|
|
|
|
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)));
|
|
|
|
return X;
|
|
|
|
}
|
|
|
|
|
|
|
|
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)));
|
|
|
|
return X;
|
|
|
|
}
|
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)));
|
|
|
|
return X;
|
|
|
|
}
|
|
|
|
|
|
|
|
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)));
|
|
|
|
return X;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(UDiv->getLHS());
|
|
|
|
ConstantRange Y = getUnsignedRange(UDiv->getRHS());
|
|
|
|
return X.udiv(Y);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(ZExt->getOperand());
|
|
|
|
return X.zeroExtend(cast<IntegerType>(ZExt->getType())->getBitWidth());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(SExt->getOperand());
|
|
|
|
return X.signExtend(cast<IntegerType>(SExt->getType())->getBitWidth());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
|
|
|
|
ConstantRange X = getUnsignedRange(Trunc->getOperand());
|
|
|
|
return X.truncate(cast<IntegerType>(Trunc->getType())->getBitWidth());
|
|
|
|
}
|
|
|
|
|
|
|
|
ConstantRange FullSet(getTypeSizeInBits(S->getType()), true);
|
|
|
|
|
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
|
|
|
|
const SCEV *T = getBackedgeTakenCount(AddRec->getLoop());
|
|
|
|
const SCEVConstant *Trip = dyn_cast<SCEVConstant>(T);
|
|
|
|
if (!Trip) return FullSet;
|
|
|
|
|
|
|
|
// TODO: non-affine addrec
|
|
|
|
if (AddRec->isAffine()) {
|
|
|
|
const Type *Ty = AddRec->getType();
|
|
|
|
const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
|
|
|
|
if (getTypeSizeInBits(MaxBECount->getType()) <= getTypeSizeInBits(Ty)) {
|
|
|
|
MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
|
|
|
|
|
|
|
|
const SCEV *Start = AddRec->getStart();
|
2009-07-21 08:42:47 +08:00
|
|
|
const SCEV *Step = AddRec->getStepRecurrence(*this);
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *End = AddRec->evaluateAtIteration(MaxBECount, *this);
|
|
|
|
|
|
|
|
// Check for overflow.
|
2009-07-21 08:42:47 +08:00
|
|
|
// TODO: This is very conservative.
|
|
|
|
if (!(Step->isOne() &&
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_ULT, Start, End)) &&
|
|
|
|
!(Step->isAllOnesValue() &&
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_UGT, Start, End)))
|
2009-07-14 05:35:55 +08:00
|
|
|
return FullSet;
|
|
|
|
|
|
|
|
ConstantRange StartRange = getUnsignedRange(Start);
|
|
|
|
ConstantRange EndRange = getUnsignedRange(End);
|
|
|
|
APInt Min = APIntOps::umin(StartRange.getUnsignedMin(),
|
|
|
|
EndRange.getUnsignedMin());
|
|
|
|
APInt Max = APIntOps::umax(StartRange.getUnsignedMax(),
|
|
|
|
EndRange.getUnsignedMax());
|
|
|
|
if (Min.isMinValue() && Max.isMaxValue())
|
2009-07-21 06:41:51 +08:00
|
|
|
return FullSet;
|
2009-07-14 05:35:55 +08:00
|
|
|
return ConstantRange(Min, Max+1);
|
|
|
|
}
|
|
|
|
}
|
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, TD);
|
2009-07-21 06:34:18 +08:00
|
|
|
if (Ones == ~Zeros + 1)
|
|
|
|
return FullSet;
|
|
|
|
return ConstantRange(Ones, ~Zeros + 1);
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
return FullSet;
|
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) {
|
2009-07-11 00:42:52 +08:00
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(S))
|
|
|
|
return ConstantRange(C->getValue()->getValue());
|
|
|
|
|
|
|
|
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)));
|
|
|
|
return 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)));
|
|
|
|
return 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)));
|
|
|
|
return X;
|
|
|
|
}
|
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)));
|
|
|
|
return X;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVUDivExpr *UDiv = dyn_cast<SCEVUDivExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(UDiv->getLHS());
|
|
|
|
ConstantRange Y = getSignedRange(UDiv->getRHS());
|
|
|
|
return X.udiv(Y);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVZeroExtendExpr *ZExt = dyn_cast<SCEVZeroExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(ZExt->getOperand());
|
|
|
|
return X.zeroExtend(cast<IntegerType>(ZExt->getType())->getBitWidth());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVSignExtendExpr *SExt = dyn_cast<SCEVSignExtendExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(SExt->getOperand());
|
|
|
|
return X.signExtend(cast<IntegerType>(SExt->getType())->getBitWidth());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const SCEVTruncateExpr *Trunc = dyn_cast<SCEVTruncateExpr>(S)) {
|
|
|
|
ConstantRange X = getSignedRange(Trunc->getOperand());
|
|
|
|
return X.truncate(cast<IntegerType>(Trunc->getType())->getBitWidth());
|
|
|
|
}
|
|
|
|
|
|
|
|
ConstantRange FullSet(getTypeSizeInBits(S->getType()), true);
|
|
|
|
|
|
|
|
if (const SCEVAddRecExpr *AddRec = dyn_cast<SCEVAddRecExpr>(S)) {
|
|
|
|
const SCEV *T = getBackedgeTakenCount(AddRec->getLoop());
|
|
|
|
const SCEVConstant *Trip = dyn_cast<SCEVConstant>(T);
|
|
|
|
if (!Trip) return FullSet;
|
|
|
|
|
|
|
|
// TODO: non-affine addrec
|
|
|
|
if (AddRec->isAffine()) {
|
|
|
|
const Type *Ty = AddRec->getType();
|
|
|
|
const SCEV *MaxBECount = getMaxBackedgeTakenCount(AddRec->getLoop());
|
|
|
|
if (getTypeSizeInBits(MaxBECount->getType()) <= getTypeSizeInBits(Ty)) {
|
|
|
|
MaxBECount = getNoopOrZeroExtend(MaxBECount, Ty);
|
|
|
|
|
|
|
|
const SCEV *Start = AddRec->getStart();
|
|
|
|
const SCEV *Step = AddRec->getStepRecurrence(*this);
|
|
|
|
const SCEV *End = AddRec->evaluateAtIteration(MaxBECount, *this);
|
|
|
|
|
|
|
|
// Check for overflow.
|
2009-07-21 08:42:47 +08:00
|
|
|
// TODO: This is very conservative.
|
|
|
|
if (!(Step->isOne() &&
|
2009-07-14 05:35:55 +08:00
|
|
|
isKnownPredicate(ICmpInst::ICMP_SLT, Start, End)) &&
|
2009-07-21 08:42:47 +08:00
|
|
|
!(Step->isAllOnesValue() &&
|
2009-07-14 05:35:55 +08:00
|
|
|
isKnownPredicate(ICmpInst::ICMP_SGT, Start, End)))
|
|
|
|
return FullSet;
|
|
|
|
|
|
|
|
ConstantRange StartRange = getSignedRange(Start);
|
|
|
|
ConstantRange EndRange = getSignedRange(End);
|
|
|
|
APInt Min = APIntOps::smin(StartRange.getSignedMin(),
|
|
|
|
EndRange.getSignedMin());
|
|
|
|
APInt Max = APIntOps::smax(StartRange.getSignedMax(),
|
|
|
|
EndRange.getSignedMax());
|
|
|
|
if (Min.isMinSignedValue() && Max.isMaxSignedValue())
|
2009-07-21 08:37:45 +08:00
|
|
|
return FullSet;
|
2009-07-14 05:35:55 +08:00
|
|
|
return ConstantRange(Min, Max+1);
|
|
|
|
}
|
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.
|
2009-07-14 05:35:55 +08:00
|
|
|
unsigned BitWidth = getTypeSizeInBits(U->getType());
|
|
|
|
unsigned NS = ComputeNumSignBits(U->getValue(), TD);
|
|
|
|
if (NS == 1)
|
|
|
|
return FullSet;
|
|
|
|
return
|
|
|
|
ConstantRange(APInt::getSignedMinValue(BitWidth).ashr(NS - 1),
|
|
|
|
APInt::getSignedMaxValue(BitWidth).ashr(NS - 1)+1);
|
2009-06-20 07:29:04 +08:00
|
|
|
}
|
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
return FullSet;
|
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;
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(V))
|
|
|
|
Opcode = I->getOpcode();
|
|
|
|
else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
|
|
|
|
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))
|
|
|
|
return getIntegerSCEV(0, V->getType());
|
|
|
|
else if (isa<UndefValue>(V))
|
|
|
|
return getIntegerSCEV(0, V->getType());
|
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) {
|
|
|
|
case Instruction::Add:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getAddExpr(getSCEV(U->getOperand(0)),
|
|
|
|
getSCEV(U->getOperand(1)));
|
2008-06-23 03:56:46 +08:00
|
|
|
case Instruction::Mul:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getMulExpr(getSCEV(U->getOperand(0)),
|
|
|
|
getSCEV(U->getOperand(1)));
|
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) >=
|
2008-06-23 03:56:46 +08:00
|
|
|
(CIVal.getBitWidth() - CIVal.countLeadingZeros()))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getAddExpr(LHS, getSCEV(U->getOperand(1)));
|
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);
|
|
|
|
|
|
|
|
// If C is a low-bits mask, the zero extend is zerving to
|
|
|
|
// 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.
|
|
|
|
APInt Trunc = APInt(CI->getValue()).trunc(Z0TySize);
|
|
|
|
if (APInt(Trunc).zext(getTypeSizeInBits(UTy)) == CI->getValue() &&
|
|
|
|
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))) {
|
|
|
|
uint32_t BitWidth = cast<IntegerType>(V->getType())->getBitWidth();
|
2009-07-25 07:12:02 +08:00
|
|
|
Constant *X = ConstantInt::get(getContext(),
|
2008-06-23 03:56:46 +08:00
|
|
|
APInt(BitWidth, 1).shl(SA->getLimitedValue(BitWidth)));
|
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))) {
|
|
|
|
uint32_t BitWidth = cast<IntegerType>(V->getType())->getBitWidth();
|
2009-07-25 07:12:02 +08:00
|
|
|
Constant *X = ConstantInt::get(getContext(),
|
2008-07-07 14:15:49 +08:00
|
|
|
APInt(BitWidth, 1).shl(SA->getLimitedValue(BitWidth)));
|
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)))
|
|
|
|
if (Instruction *L = dyn_cast<Instruction>(U->getOperand(0)))
|
|
|
|
if (L->getOpcode() == Instruction::Shl &&
|
|
|
|
L->getOperand(1) == U->getOperand(1)) {
|
2009-04-26 01:05:40 +08:00
|
|
|
unsigned BitWidth = getTypeSizeInBits(U->getType());
|
|
|
|
uint64_t Amt = BitWidth - CI->getZExtValue();
|
|
|
|
if (Amt == BitWidth)
|
|
|
|
return getSCEV(L->getOperand(0)); // shift by zero --> noop
|
|
|
|
if (Amt > BitWidth)
|
|
|
|
return getIntegerSCEV(0, U->getType()); // value is undefined
|
2009-04-21 10:26:00 +08:00
|
|
|
return
|
2009-04-22 07:15:49 +08:00
|
|
|
getSignExtendExpr(getTruncateExpr(getSCEV(L->getOperand(0)),
|
2009-08-14 05:58:54 +08:00
|
|
|
IntegerType::get(getContext(), Amt)),
|
2009-04-21 10:26:00 +08:00
|
|
|
U->getType());
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
2009-07-21 01:43:30 +08:00
|
|
|
// It's tempting to handle inttoptr and ptrtoint, however this can
|
|
|
|
// lead to pointer expressions which cannot be expanded to GEPs
|
|
|
|
// (because they may overflow). For now, the only pointer-typed
|
|
|
|
// expressions we handle are GEPs and address literals.
|
2009-04-16 11:18:22 +08:00
|
|
|
|
2009-05-09 04:26:55 +08:00
|
|
|
case Instruction::GetElementPtr:
|
2009-04-21 09:07:12 +08:00
|
|
|
if (!TD) break; // Without TD we can't analyze pointers.
|
2009-05-09 04:58:38 +08:00
|
|
|
return createNodeForGEP(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:
|
|
|
|
if (LHS == U->getOperand(1) && RHS == U->getOperand(2))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getSMaxExpr(getSCEV(LHS), getSCEV(RHS));
|
2008-06-23 03:56:46 +08:00
|
|
|
else if (LHS == U->getOperand(2) && RHS == U->getOperand(1))
|
2009-06-22 11:18:45 +08:00
|
|
|
return getSMinExpr(getSCEV(LHS), getSCEV(RHS));
|
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:
|
|
|
|
if (LHS == U->getOperand(1) && RHS == U->getOperand(2))
|
2009-04-22 07:15:49 +08:00
|
|
|
return getUMaxExpr(getSCEV(LHS), getSCEV(RHS));
|
2008-06-23 03:56:46 +08:00
|
|
|
else if (LHS == U->getOperand(2) && RHS == U->getOperand(1))
|
2009-06-22 11:18:45 +08:00
|
|
|
return getUMinExpr(getSCEV(LHS), getSCEV(RHS));
|
2008-06-23 03:56:46 +08:00
|
|
|
break;
|
2009-06-19 04:21:07 +08:00
|
|
|
case ICmpInst::ICMP_NE:
|
|
|
|
// n != 0 ? n : 1 -> umax(n, 1)
|
|
|
|
if (LHS == U->getOperand(1) &&
|
|
|
|
isa<ConstantInt>(U->getOperand(2)) &&
|
|
|
|
cast<ConstantInt>(U->getOperand(2))->isOne() &&
|
|
|
|
isa<ConstantInt>(RHS) &&
|
|
|
|
cast<ConstantInt>(RHS)->isZero())
|
|
|
|
return getUMaxExpr(getSCEV(LHS), getSCEV(U->getOperand(2)));
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_EQ:
|
|
|
|
// n == 0 ? 1 : n -> umax(n, 1)
|
|
|
|
if (LHS == U->getOperand(2) &&
|
|
|
|
isa<ConstantInt>(U->getOperand(1)) &&
|
|
|
|
cast<ConstantInt>(U->getOperand(1))->isOne() &&
|
|
|
|
isa<ConstantInt>(RHS) &&
|
|
|
|
cast<ConstantInt>(RHS)->isZero())
|
|
|
|
return getUMaxExpr(getSCEV(LHS), getSCEV(U->getOperand(1)));
|
|
|
|
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
|
|
|
|
// succeeds, procede to actually compute a backedge-taken count and
|
|
|
|
// 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-05-01 04:47:05 +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()));
|
|
|
|
if (Pair.second) {
|
2009-05-01 04:47:05 +08:00
|
|
|
BackedgeTakenInfo ItCount = ComputeBackedgeTakenCount(L);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (ItCount.Exact != getCouldNotCompute()) {
|
2009-05-01 04:47:05 +08:00
|
|
|
assert(ItCount.Exact->isLoopInvariant(L) &&
|
|
|
|
ItCount.Max->isLoopInvariant(L) &&
|
2004-04-03 04:23:17 +08:00
|
|
|
"Computed trip count isn't loop invariant for loop!");
|
|
|
|
++NumTripCountsComputed;
|
2009-04-28 04:16:15 +08:00
|
|
|
|
|
|
|
// Update the value in the map.
|
|
|
|
Pair.first->second = ItCount;
|
2009-06-22 08:31:57 +08:00
|
|
|
} else {
|
2009-06-28 05:21:31 +08:00
|
|
|
if (ItCount.Max != getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
// Update the value in the map.
|
|
|
|
Pair.first->second = ItCount;
|
|
|
|
if (isa<PHINode>(L->getHeader()->begin()))
|
|
|
|
// Only count loops that have phi nodes as not being computable.
|
|
|
|
++NumTripCountsNotComputed;
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2009-05-01 04:47:05 +08:00
|
|
|
|
|
|
|
// 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
|
2009-07-09 03:23:34 +08:00
|
|
|
// conservative estimates made without the benefit of trip count
|
|
|
|
// information. This is similar to the code in
|
|
|
|
// forgetLoopBackedgeTakenCount, except that it handles SCEVUnknown PHI
|
|
|
|
// nodes specially.
|
|
|
|
if (ItCount.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;
|
|
|
|
|
|
|
|
std::map<SCEVCallbackVH, const SCEV*>::iterator It =
|
|
|
|
Scalars.find(static_cast<Value *>(I));
|
|
|
|
if (It != Scalars.end()) {
|
|
|
|
// 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
|
2009-07-14 06:04:06 +08:00
|
|
|
// 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.
|
2009-07-09 03:23:34 +08:00
|
|
|
if (!isa<PHINode>(I) || !isa<SCEVUnknown>(It->second))
|
|
|
|
Scalars.erase(It);
|
|
|
|
ValuesAtScopes.erase(I);
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
ConstantEvolutionLoopExitValue.erase(PN);
|
|
|
|
}
|
|
|
|
|
|
|
|
PushDefUseChildren(I, Worklist);
|
|
|
|
}
|
|
|
|
}
|
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-02-25 02:55:53 +08:00
|
|
|
/// forgetLoopBackedgeTakenCount - This method should be called by the
|
2009-02-18 04:49:49 +08:00
|
|
|
/// client when it has changed a loop in a way that may effect
|
2009-02-25 02:55:53 +08:00
|
|
|
/// ScalarEvolution's ability to compute a trip count, or if the loop
|
|
|
|
/// is deleted.
|
2009-04-22 07:15:49 +08:00
|
|
|
void ScalarEvolution::forgetLoopBackedgeTakenCount(const Loop *L) {
|
2009-02-25 02:55:53 +08:00
|
|
|
BackedgeTakenCounts.erase(L);
|
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;
|
|
|
|
|
|
|
|
std::map<SCEVCallbackVH, const SCEV*>::iterator It =
|
|
|
|
Scalars.find(static_cast<Value *>(I));
|
|
|
|
if (It != Scalars.end()) {
|
|
|
|
Scalars.erase(It);
|
|
|
|
ValuesAtScopes.erase(I);
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
ConstantEvolutionLoopExitValue.erase(PN);
|
|
|
|
}
|
|
|
|
|
|
|
|
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-06-22 08:31:57 +08:00
|
|
|
SmallVector<BasicBlock*, 8> ExitingBlocks;
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
// Procede to the next level to examine the exit condition expression.
|
|
|
|
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 {
|
|
|
|
// Both conditions must be true for the loop to exit.
|
|
|
|
assert(L->contains(FBB) && "Loop block has no successor in loop!");
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Exact != getCouldNotCompute() &&
|
|
|
|
BTI1.Exact != getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
BECount = getUMaxFromMismatchedTypes(BTI0.Exact, BTI1.Exact);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Max != getCouldNotCompute() &&
|
|
|
|
BTI1.Max != getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
MaxBECount = getUMaxFromMismatchedTypes(BTI0.Max, BTI1.Max);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 {
|
|
|
|
// Both conditions must be false for the loop to exit.
|
|
|
|
assert(L->contains(TBB) && "Loop block has no successor in loop!");
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Exact != getCouldNotCompute() &&
|
|
|
|
BTI1.Exact != getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
BECount = getUMaxFromMismatchedTypes(BTI0.Exact, BTI1.Exact);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (BTI0.Max != getCouldNotCompute() &&
|
|
|
|
BTI1.Max != getCouldNotCompute())
|
2009-06-22 08:31:57 +08:00
|
|
|
MaxBECount = getUMaxFromMismatchedTypes(BTI0.Max, BTI1.Max);
|
|
|
|
}
|
|
|
|
|
|
|
|
return BackedgeTakenInfo(BECount, MaxBECount);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// With an icmp, it may be feasible to compute an exact backedge-taken count.
|
|
|
|
// Procede to the next level to examine the icmp.
|
|
|
|
if (ICmpInst *ExitCondICmp = dyn_cast<ICmpInst>(ExitCond))
|
|
|
|
return ComputeBackedgeTakenCountFromExitCondICmp(L, ExitCondICmp, TBB, FBB);
|
2006-12-23 14:05:41 +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));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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))) {
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *ItCnt =
|
2009-02-25 02:55:53 +08:00
|
|
|
ComputeLoadConstantCompareBackedgeTakenCount(LI, RHS, L, Cond);
|
2009-06-22 08:31:57 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(ItCnt)) {
|
|
|
|
unsigned BitWidth = getTypeSizeInBits(ItCnt->getType());
|
|
|
|
return BackedgeTakenInfo(ItCnt,
|
|
|
|
isa<SCEVConstant>(ItCnt) ? ItCnt :
|
|
|
|
getConstant(APInt::getMaxValue(BitWidth)-1));
|
|
|
|
}
|
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.
|
2008-09-17 02:52:57 +08:00
|
|
|
if (LHS->isLoopInvariant(L) && !RHS->isLoopInvariant(L)) {
|
|
|
|
// 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
|
|
|
}
|
|
|
|
|
|
|
|
// 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)
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *TC = HowFarToZero(getMinusSCEV(LHS, RHS), L);
|
2006-12-23 14:05:41 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(TC)) return TC;
|
2004-04-03 04:23:17 +08:00
|
|
|
break;
|
2006-12-23 14:05:41 +08:00
|
|
|
}
|
|
|
|
case ICmpInst::ICMP_EQ: {
|
2004-04-03 04:23:17 +08:00
|
|
|
// Convert to: while (X-Y == 0) // while (X == Y)
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *TC = HowFarToNonZero(getMinusSCEV(LHS, RHS), L);
|
2006-12-23 14:05:41 +08:00
|
|
|
if (!isa<SCEVCouldNotCompute>(TC)) return TC;
|
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-04-21 08:47:46 +08:00
|
|
|
errs() << "ComputeBackedgeTakenCount ";
|
2004-04-03 04:23:17 +08:00
|
|
|
if (ExitCond->getOperand(0)->getType()->isUnsigned())
|
2009-04-21 08:47:46 +08:00
|
|
|
errs() << "[unsigned] ";
|
|
|
|
errs() << *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-07-22 08:24:57 +08:00
|
|
|
GetAddressedElementFromGlobal(LLVMContext &Context, 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.
|
2009-06-24 12:48:43 +08:00
|
|
|
const SCEV *
|
|
|
|
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.
|
|
|
|
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));
|
|
|
|
if (!GV || !GV->isConstant() || !GV->hasInitializer() ||
|
|
|
|
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);
|
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 (!IdxExpr || !IdxExpr->isAffine() || IdxExpr->isLoopInvariant(L) ||
|
|
|
|
!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-07-22 08:24:57 +08:00
|
|
|
Constant *Result = GetAddressedElementFromGlobal(getContext(), 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-04-21 08:47:46 +08:00
|
|
|
errs() << "\n***\n*** Computed loop count " << *ItCst
|
|
|
|
<< "\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);
|
|
|
|
if (I == 0 || !L->contains(I->getParent())) return 0;
|
|
|
|
|
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)
|
2004-04-18 02:36:24 +08:00
|
|
|
if (!(isa<Constant>(I->getOperand(Op)) ||
|
2004-04-18 06:58:41 +08:00
|
|
|
isa<GlobalValue>(I->getOperand(Op)))) {
|
|
|
|
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.
|
|
|
|
static Constant *EvaluateExpression(Value *V, Constant *PHIVal) {
|
|
|
|
if (isa<PHINode>(V)) return PHIVal;
|
2004-07-18 08:18:30 +08:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) return C;
|
2009-04-16 11:18:22 +08:00
|
|
|
if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) return GV;
|
2004-04-18 02:36:24 +08:00
|
|
|
Instruction *I = cast<Instruction>(V);
|
2009-07-22 08:24:57 +08:00
|
|
|
LLVMContext &Context = I->getParent()->getContext();
|
2004-04-18 02:36:24 +08:00
|
|
|
|
|
|
|
std::vector<Constant*> Operands;
|
|
|
|
Operands.resize(I->getNumOperands());
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
|
|
|
|
Operands[i] = EvaluateExpression(I->getOperand(i), PHIVal);
|
|
|
|
if (Operands[i] == 0) return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-11 06:53:04 +08:00
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(I))
|
|
|
|
return ConstantFoldCompareInstOperands(CI->getPredicate(),
|
2009-07-07 02:42:36 +08:00
|
|
|
&Operands[0], Operands.size(),
|
|
|
|
Context);
|
2007-12-11 06:53:04 +08:00
|
|
|
else
|
|
|
|
return ConstantFoldInstOperands(I->getOpcode(), I->getType(),
|
2009-07-07 02:42:36 +08:00
|
|
|
&Operands[0], Operands.size(),
|
|
|
|
Context);
|
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,
|
|
|
|
const APInt& BEs,
|
|
|
|
const Loop *L) {
|
2004-04-18 06:58:41 +08:00
|
|
|
std::map<PHINode*, Constant*>::iterator I =
|
|
|
|
ConstantEvolutionLoopExitValue.find(PN);
|
|
|
|
if (I != ConstantEvolutionLoopExitValue.end())
|
|
|
|
return I->second;
|
2004-04-18 02:36:24 +08:00
|
|
|
|
2009-02-25 02:55:53 +08:00
|
|
|
if (BEs.ugt(APInt(BEs.getBitWidth(),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);
|
|
|
|
PHINode *PN2 = getConstantEvolvingPHI(BEValue, L);
|
|
|
|
if (PN2 != PN)
|
|
|
|
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.
|
|
|
|
Constant *NextPHI = EvaluateExpression(BEValue, PHIVal);
|
|
|
|
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
|
|
|
|
|
|
|
// 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));
|
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);
|
|
|
|
PHINode *PN2 = getConstantEvolvingPHI(BEValue, L);
|
2009-06-28 05:21:31 +08:00
|
|
|
if (PN2 != PN) 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 =
|
|
|
|
dyn_cast_or_null<ConstantInt>(EvaluateExpression(Cond, PHIVal));
|
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.
|
|
|
|
Constant *NextPHI = EvaluateExpression(BEValue, PHIVal);
|
|
|
|
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-05-09 04:38:54 +08:00
|
|
|
/// getSCEVAtScope - Return a SCEV expression handle for the specified value
|
|
|
|
/// 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) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// FIXME: this should be turned into a virtual method on SCEV!
|
|
|
|
|
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)) {
|
2009-05-09 04:47:27 +08:00
|
|
|
// Check to see if we've folded this instruction at this loop before.
|
|
|
|
std::map<const Loop *, Constant *> &Values = ValuesAtScopes[I];
|
|
|
|
std::pair<std::map<const Loop *, Constant *>::iterator, bool> Pair =
|
|
|
|
Values.insert(std::make_pair(L, static_cast<Constant *>(0)));
|
|
|
|
if (!Pair.second)
|
2009-06-30 05:31:18 +08:00
|
|
|
return Pair.first->second ? &*getSCEV(Pair.first->second) : V;
|
2009-05-09 04:47:27 +08:00
|
|
|
|
2004-04-18 06:58:41 +08:00
|
|
|
std::vector<Constant*> Operands;
|
|
|
|
Operands.reserve(I->getNumOperands());
|
|
|
|
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);
|
|
|
|
} else {
|
2007-11-23 16:46:22 +08:00
|
|
|
// If any of the operands is non-constant and if they are
|
2009-04-16 11:18:22 +08:00
|
|
|
// non-integer and non-pointer, don't even try to analyze them
|
|
|
|
// with scev techniques.
|
2009-05-01 00:40:30 +08:00
|
|
|
if (!isSCEVable(Op->getType()))
|
2007-11-23 16:46:22 +08:00
|
|
|
return V;
|
2009-04-16 11:18:22 +08:00
|
|
|
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV* OpV = getSCEVAtScope(Op, L);
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *SC = dyn_cast<SCEVConstant>(OpV)) {
|
2009-05-01 00:40:30 +08:00
|
|
|
Constant *C = SC->getValue();
|
|
|
|
if (C->getType() != Op->getType())
|
|
|
|
C = ConstantExpr::getCast(CastInst::getCastOpcode(C, false,
|
|
|
|
Op->getType(),
|
|
|
|
false),
|
|
|
|
C, Op->getType());
|
|
|
|
Operands.push_back(C);
|
2009-05-05 06:02:23 +08:00
|
|
|
} else if (const SCEVUnknown *SU = dyn_cast<SCEVUnknown>(OpV)) {
|
2009-05-01 00:40:30 +08:00
|
|
|
if (Constant *C = dyn_cast<Constant>(SU->getValue())) {
|
|
|
|
if (C->getType() != Op->getType())
|
|
|
|
C =
|
|
|
|
ConstantExpr::getCast(CastInst::getCastOpcode(C, false,
|
|
|
|
Op->getType(),
|
|
|
|
false),
|
|
|
|
C, Op->getType());
|
|
|
|
Operands.push_back(C);
|
|
|
|
} else
|
2004-04-18 06:58:41 +08:00
|
|
|
return V;
|
|
|
|
} else {
|
|
|
|
return V;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-06-24 12:48:43 +08:00
|
|
|
|
2007-12-11 06:53:04 +08:00
|
|
|
Constant *C;
|
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(I))
|
|
|
|
C = ConstantFoldCompareInstOperands(CI->getPredicate(),
|
2009-07-07 02:42:36 +08:00
|
|
|
&Operands[0], Operands.size(),
|
2009-07-22 08:24:57 +08:00
|
|
|
getContext());
|
2007-12-11 06:53:04 +08:00
|
|
|
else
|
|
|
|
C = ConstantFoldInstOperands(I->getOpcode(), I->getType(),
|
2009-07-22 08:24:57 +08:00
|
|
|
&Operands[0], Operands.size(),
|
|
|
|
getContext());
|
2009-05-09 04:47:27 +08:00
|
|
|
Pair.first->second = C;
|
2009-06-30 05:31:18 +08:00
|
|
|
return getSCEV(C);
|
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)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
if (!L || !AddRec->getLoop()->contains(L->getHeader())) {
|
|
|
|
// 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
|
|
|
}
|
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);
|
|
|
|
Mod.set(BW - Mult2); // Mod = N / D
|
|
|
|
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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *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
|
|
|
|
|
|
|
if (AddRec->isAffine()) {
|
2008-07-20 23:55:14 +08:00
|
|
|
// 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)
|
2004-04-03 04:23:17 +08:00
|
|
|
//
|
2008-07-20 23:55:14 +08:00
|
|
|
// equivalent to:
|
2004-04-03 04:23:17 +08:00
|
|
|
//
|
2008-07-20 23:55:14 +08:00
|
|
|
// Step*N = -Start (mod 2^BW)
|
|
|
|
//
|
|
|
|
// where BW is the common bit width of Start and Step.
|
|
|
|
|
2004-04-03 04:23:17 +08:00
|
|
|
// Get the initial value for the loop.
|
2009-06-24 12:48:43 +08:00
|
|
|
const SCEV *Start = getSCEVAtScope(AddRec->getStart(),
|
|
|
|
L->getParentLoop());
|
|
|
|
const SCEV *Step = getSCEVAtScope(AddRec->getOperand(1),
|
|
|
|
L->getParentLoop());
|
2004-04-03 04:23:17 +08:00
|
|
|
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *StepC = dyn_cast<SCEVConstant>(Step)) {
|
2008-07-20 23:55:14 +08:00
|
|
|
// For now we handle only constant steps.
|
|
|
|
|
|
|
|
// First, handle unitary steps.
|
|
|
|
if (StepC->getValue()->equalsInt(1)) // 1*N = -Start (mod 2^BW), so:
|
2009-04-22 07:15:49 +08:00
|
|
|
return getNegativeSCEV(Start); // N = -Start (as unsigned)
|
2008-07-20 23:55:14 +08:00
|
|
|
if (StepC->getValue()->isAllOnesValue()) // -1*N = -Start (mod 2^BW), so:
|
|
|
|
return Start; // N = Start (as unsigned)
|
|
|
|
|
|
|
|
// Then, try to solve the above equation provided that Start is constant.
|
2009-05-05 06:02:23 +08:00
|
|
|
if (const SCEVConstant *StartC = dyn_cast<SCEVConstant>(Start))
|
2008-07-20 23:55:14 +08:00
|
|
|
return SolveLinEquationWithOverflow(StepC->getValue()->getValue(),
|
2009-04-22 07:15:49 +08:00
|
|
|
-StartC->getValue()->getValue(),
|
|
|
|
*this);
|
2004-04-03 04:23:17 +08:00
|
|
|
}
|
2007-01-15 10:27:26 +08:00
|
|
|
} else if (AddRec->isQuadratic() && AddRec->getType()->isInteger()) {
|
2004-04-03 04:23:17 +08:00
|
|
|
// If this is a quadratic (3-term) AddRec {L,+,M,+,N}, find the roots of
|
|
|
|
// the quadratic equation to solve it.
|
2009-07-08 01:06:11 +08:00
|
|
|
std::pair<const SCEV *,const SCEV *> Roots = SolveQuadraticEquation(AddRec,
|
2009-04-22 07:15:49 +08:00
|
|
|
*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);
|
2004-04-03 04:23:17 +08:00
|
|
|
if (R1) {
|
2004-04-03 04:26:46 +08:00
|
|
|
#if 0
|
2009-04-21 08:47:46 +08:00
|
|
|
errs() << "HFTZ: " << *V << " - sol#1: " << *R1
|
|
|
|
<< " 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 =
|
2009-07-30 02:55:55 +08:00
|
|
|
dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
|
2006-12-23 14:05:41 +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
|
|
|
// 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
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-04-22 05:13:18 +08:00
|
|
|
|
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
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *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())
|
2009-04-22 07:15:49 +08:00
|
|
|
return getIntegerSCEV(0, C->getType());
|
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
|
|
|
}
|
|
|
|
|
2009-05-18 23:36:09 +08:00
|
|
|
/// getLoopPredecessor - If the given loop's header has exactly one unique
|
|
|
|
/// predecessor outside the loop, return it. Otherwise return null.
|
|
|
|
///
|
|
|
|
BasicBlock *ScalarEvolution::getLoopPredecessor(const Loop *L) {
|
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
BasicBlock *Pred = 0;
|
|
|
|
for (pred_iterator PI = pred_begin(Header), E = pred_end(Header);
|
|
|
|
PI != E; ++PI)
|
|
|
|
if (!L->contains(*PI)) {
|
|
|
|
if (Pred && Pred != *PI) return 0; // Multiple predecessors.
|
|
|
|
Pred = *PI;
|
|
|
|
}
|
|
|
|
return Pred;
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
///
|
|
|
|
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())
|
|
|
|
return Pred;
|
|
|
|
|
|
|
|
// 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))
|
2009-05-18 23:36:09 +08:00
|
|
|
return getLoopPredecessor(L);
|
2008-09-16 06:18:04 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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()))
|
|
|
|
if (AI->isIdenticalTo(BI))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise assume they may have a different value.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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) {
|
|
|
|
|
|
|
|
if (HasSameValue(LHS, RHS))
|
|
|
|
return ICmpInst::isTrueWhenEqual(Pred);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2009-07-22 07:03:19 +08:00
|
|
|
return isImpliedCond(LoopContinuePredicate->getCondition(), Pred, LHS, RHS,
|
|
|
|
LoopContinuePredicate->getSuccessor(0) != L->getHeader());
|
2009-07-14 05:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// isLoopGuardedByCond - Test whether entry to the loop is protected
|
|
|
|
/// by a conditional between LHS and RHS. This is used to help avoid max
|
|
|
|
/// expressions in loop trip counts, and to eliminate casts.
|
|
|
|
bool
|
|
|
|
ScalarEvolution::isLoopGuardedByCond(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
|
|
|
BasicBlock *Predecessor = getLoopPredecessor(L);
|
|
|
|
BasicBlock *PredecessorDest = L->getHeader();
|
2008-07-12 15:41:32 +08:00
|
|
|
|
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.
|
2009-05-18 23:36:09 +08:00
|
|
|
for (; Predecessor;
|
|
|
|
PredecessorDest = Predecessor,
|
|
|
|
Predecessor = getPredecessorWithUniqueSuccessorForBB(Predecessor)) {
|
2008-07-12 15:41:32 +08:00
|
|
|
|
2008-08-13 04:17:31 +08:00
|
|
|
BranchInst *LoopEntryPredicate =
|
2009-05-18 23:36:09 +08:00
|
|
|
dyn_cast<BranchInst>(Predecessor->getTerminator());
|
2008-08-13 04:17:31 +08:00
|
|
|
if (!LoopEntryPredicate ||
|
|
|
|
LoopEntryPredicate->isUnconditional())
|
|
|
|
continue;
|
|
|
|
|
2009-07-22 07:03:19 +08:00
|
|
|
if (isImpliedCond(LoopEntryPredicate->getCondition(), Pred, LHS, RHS,
|
|
|
|
LoopEntryPredicate->getSuccessor(0) != PredecessorDest))
|
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.
|
|
|
|
bool ScalarEvolution::isImpliedCond(Value *CondValue,
|
|
|
|
ICmpInst::Predicate Pred,
|
|
|
|
const SCEV *LHS, const SCEV *RHS,
|
|
|
|
bool Inverse) {
|
2009-06-24 09:18:18 +08:00
|
|
|
// Recursivly handle And and Or conditions.
|
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CondValue)) {
|
|
|
|
if (BO->getOpcode() == Instruction::And) {
|
|
|
|
if (!Inverse)
|
2009-07-22 07:03:19 +08:00
|
|
|
return isImpliedCond(BO->getOperand(0), Pred, LHS, RHS, Inverse) ||
|
|
|
|
isImpliedCond(BO->getOperand(1), Pred, LHS, RHS, Inverse);
|
2009-06-24 09:18:18 +08:00
|
|
|
} else if (BO->getOpcode() == Instruction::Or) {
|
|
|
|
if (Inverse)
|
2009-07-22 07:03:19 +08:00
|
|
|
return isImpliedCond(BO->getOperand(0), Pred, LHS, RHS, Inverse) ||
|
|
|
|
isImpliedCond(BO->getOperand(1), Pred, LHS, RHS, Inverse);
|
2009-06-24 09:18:18 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ICmpInst *ICI = dyn_cast<ICmpInst>(CondValue);
|
|
|
|
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.
|
|
|
|
// First, put a constant operand on the right.
|
|
|
|
if (isa<SCEVConstant>(LHS)) {
|
|
|
|
std::swap(LHS, RHS);
|
|
|
|
Pred = ICmpInst::getSwappedPredicate(Pred);
|
|
|
|
}
|
|
|
|
// Then, canonicalize comparisons with boundary cases.
|
|
|
|
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);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinValue()) return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULE:
|
|
|
|
if ((RA + 1).isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxValue()) return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGE:
|
|
|
|
if ((RA - 1).isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinSignedValue()) return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SLE:
|
|
|
|
if ((RA + 1).isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxSignedValue()) return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_UGT:
|
|
|
|
if (RA.isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA + 1).isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxValue()) return false;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULT:
|
|
|
|
if (RA.isMaxValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA - 1).isMinValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinValue()) return false;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGT:
|
|
|
|
if (RA.isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA + 1).isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA + 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMaxSignedValue()) return false;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SLT:
|
|
|
|
if (RA.isMaxSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_NE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((RA - 1).isMinSignedValue()) {
|
|
|
|
Pred = ICmpInst::ICMP_EQ;
|
|
|
|
RHS = getConstant(RA - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (RA.isMinSignedValue()) return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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,
|
|
|
|
/// LHS, and RHS is true whenever the condition desribed by Pred, FoundLHS,
|
|
|
|
/// 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
|
|
|
|
/// Pred, LHS, and RHS is true whenever the condition desribed by Pred,
|
|
|
|
/// 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:
|
2009-07-14 05:35:55 +08:00
|
|
|
if (isKnownPredicate(ICmpInst::ICMP_SLE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_SGE, RHS, FoundRHS))
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_SGT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_SGE:
|
2009-07-14 05:35:55 +08:00
|
|
|
if (isKnownPredicate(ICmpInst::ICMP_SGE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_SLE, RHS, FoundRHS))
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_ULT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_ULE:
|
2009-07-14 05:35:55 +08:00
|
|
|
if (isKnownPredicate(ICmpInst::ICMP_ULE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_UGE, RHS, FoundRHS))
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
case ICmpInst::ICMP_UGT:
|
2009-07-17 01:34:36 +08:00
|
|
|
case ICmpInst::ICMP_UGE:
|
2009-07-14 05:35:55 +08:00
|
|
|
if (isKnownPredicate(ICmpInst::ICMP_UGE, LHS, FoundLHS) &&
|
|
|
|
isKnownPredicate(ICmpInst::ICMP_ULE, RHS, FoundRHS))
|
|
|
|
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,
|
|
|
|
const SCEV *Step) {
|
2009-06-22 07:46:38 +08:00
|
|
|
const Type *Ty = Start->getType();
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NegOne = getIntegerSCEV(-1, Ty);
|
|
|
|
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
|
|
|
|
|
|
|
// Check Add for unsigned overflow.
|
|
|
|
// TODO: More sophisticated things could be done here.
|
2009-08-14 05:58:54 +08:00
|
|
|
const Type *WideTy = IntegerType::get(getContext(),
|
|
|
|
getTypeSizeInBits(Ty) + 1);
|
2009-07-14 05:35:55 +08:00
|
|
|
const SCEV *EDiff = getZeroExtendExpr(Diff, WideTy);
|
|
|
|
const SCEV *ERoundUp = getZeroExtendExpr(RoundUp, WideTy);
|
|
|
|
const SCEV *OperandExtendedAdd = getAddExpr(EDiff, ERoundUp);
|
2009-06-22 07:46:38 +08:00
|
|
|
if (getZeroExtendExpr(Add, WideTy) != OperandExtendedAdd)
|
2009-06-28 05:21:31 +08:00
|
|
|
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".
|
2009-06-28 05:21:31 +08:00
|
|
|
if (!RHS->isLoopInvariant(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
|
|
|
|
|
|
|
if (AddRec->isAffine()) {
|
2009-01-13 17:18:58 +08:00
|
|
|
// FORNOW: We only support unit strides.
|
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
|
|
|
|
|
|
|
// TODO: handle non-constant strides.
|
|
|
|
const SCEVConstant *CStep = dyn_cast<SCEVConstant>(Step);
|
|
|
|
if (!CStep || CStep->isZero())
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-05-18 23:22:39 +08:00
|
|
|
if (CStep->isOne()) {
|
2009-05-01 04:47:05 +08:00
|
|
|
// With unit stride, the iteration never steps past the limit value.
|
|
|
|
} else if (CStep->getValue()->getValue().isStrictlyPositive()) {
|
|
|
|
if (const SCEVConstant *CLimit = dyn_cast<SCEVConstant>(RHS)) {
|
|
|
|
// Test whether a positive iteration iteration can step past the limit
|
|
|
|
// value and past the maximum value for its type in a single step.
|
|
|
|
if (isSigned) {
|
|
|
|
APInt Max = APInt::getSignedMaxValue(BitWidth);
|
|
|
|
if ((Max - CStep->getValue()->getValue())
|
|
|
|
.slt(CLimit->getValue()->getValue()))
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-05-01 04:47:05 +08:00
|
|
|
} else {
|
|
|
|
APInt Max = APInt::getMaxValue(BitWidth);
|
|
|
|
if ((Max - CStep->getValue()->getValue())
|
|
|
|
.ult(CLimit->getValue()->getValue()))
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-05-01 04:47:05 +08:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
// TODO: handle non-constant limit values below.
|
2009-06-28 05:21:31 +08:00
|
|
|
return getCouldNotCompute();
|
2009-05-01 04:47:05 +08:00
|
|
|
} else
|
|
|
|
// TODO: handle negative strides 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;
|
2009-05-01 04:47:05 +08:00
|
|
|
if (!isLoopGuardedByCond(L,
|
2009-07-14 05:35:55 +08:00
|
|
|
isSigned ? ICmpInst::ICMP_SLT :
|
|
|
|
ICmpInst::ICMP_ULT,
|
2009-05-01 04:47:05 +08:00
|
|
|
getMinusSCEV(Start, Step), RHS))
|
|
|
|
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
|
|
|
|
|
|
|
// Finally, we subtract these two values and divide, rounding up, to get
|
|
|
|
// the number of times the backedge is executed.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *BECount = getBECount(Start, End, Step);
|
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.
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *MaxBECount = getBECount(MinStart, MaxEnd, Step);
|
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());
|
2007-10-23 02:31:58 +08:00
|
|
|
Operands[0] = SE.getIntegerSCEV(0, SC->getType());
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *Shifted = SE.getAddRecExpr(Operands, getLoop());
|
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)))
|
2009-06-16 06:12:54 +08:00
|
|
|
return SE.getIntegerSCEV(0, getType());
|
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()));
|
2009-07-08 01:06:11 +08:00
|
|
|
const SCEV *NewAddRec = SE.getAddRecExpr(NewOps, getLoop());
|
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);
|
2009-05-09 04:47:27 +08:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(getValPtr()))
|
|
|
|
SE->ValuesAtScopes.erase(I);
|
2009-05-05 06:30:44 +08:00
|
|
|
SE->Scalars.erase(getValPtr());
|
|
|
|
// this now dangles!
|
|
|
|
}
|
|
|
|
|
2009-05-20 03:22:47 +08:00
|
|
|
void ScalarEvolution::SCEVCallbackVH::allUsesReplacedWith(Value *) {
|
2009-07-14 06:20:53 +08:00
|
|
|
assert(SE && "SCEVCallbackVH called with a null ScalarEvolution!");
|
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.
|
|
|
|
SmallVector<User *, 16> Worklist;
|
2009-07-14 22:34:04 +08:00
|
|
|
SmallPtrSet<User *, 8> Visited;
|
2009-05-05 06:30:44 +08:00
|
|
|
Value *Old = getValPtr();
|
|
|
|
bool DeleteOld = false;
|
|
|
|
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.
|
|
|
|
if (U == Old) {
|
|
|
|
DeleteOld = true;
|
|
|
|
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);
|
2009-05-09 04:47:27 +08:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(U))
|
|
|
|
SE->ValuesAtScopes.erase(I);
|
2009-07-14 22:34:04 +08:00
|
|
|
SE->Scalars.erase(U);
|
|
|
|
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
|
|
|
}
|
2009-07-14 22:34:04 +08:00
|
|
|
// Delete the Old value if it (indirectly) references itself.
|
2009-05-05 06:30:44 +08:00
|
|
|
if (DeleteOld) {
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(Old))
|
|
|
|
SE->ConstantEvolutionLoopExitValue.erase(PN);
|
2009-05-09 04:47:27 +08:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(Old))
|
|
|
|
SE->ValuesAtScopes.erase(I);
|
2009-05-05 06:30:44 +08:00
|
|
|
SE->Scalars.erase(Old);
|
|
|
|
// this now dangles!
|
|
|
|
}
|
|
|
|
// this may dangle!
|
|
|
|
}
|
|
|
|
|
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()
|
2009-06-28 05:21:31 +08:00
|
|
|
: FunctionPass(&ID) {
|
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>();
|
2004-04-03 04:23:17 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ScalarEvolution::releaseMemory() {
|
2009-04-22 07:15:49 +08:00
|
|
|
Scalars.clear();
|
|
|
|
BackedgeTakenCounts.clear();
|
|
|
|
ConstantEvolutionLoopExitValue.clear();
|
2009-05-09 04:47:27 +08:00
|
|
|
ValuesAtScopes.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>();
|
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
|
|
|
|
2008-01-02 10:49:20 +08:00
|
|
|
OS << "Loop " << L->getHeader()->getName() << ": ";
|
2004-04-19 06:14:10 +08:00
|
|
|
|
2007-08-21 08:31:24 +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
|
|
|
}
|
|
|
|
|
2009-06-24 08:33:16 +08:00
|
|
|
OS << "\n";
|
|
|
|
OS << "Loop " << L->getHeader()->getName() << ": ";
|
|
|
|
|
|
|
|
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-04-21 08:47:46 +08:00
|
|
|
void ScalarEvolution::print(raw_ostream &OS, const Module* ) const {
|
2009-04-22 07:15:49 +08:00
|
|
|
// ScalarEvolution's implementaiton of the print method is to print
|
|
|
|
// 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-04-22 07:15:49 +08:00
|
|
|
ScalarEvolution &SE = *const_cast<ScalarEvolution*>(this);
|
|
|
|
|
|
|
|
OS << "Classifying expressions for: " << F->getName() << "\n";
|
2004-04-03 04:23:17 +08:00
|
|
|
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
|
2009-04-30 09:30:18 +08:00
|
|
|
if (isSCEVable(I->getType())) {
|
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());
|
2009-05-25 07:25:42 +08:00
|
|
|
if (!ExitValue->isLoopInvariant(L)) {
|
2004-04-03 04:23:17 +08:00
|
|
|
OS << "<<Unknown>>";
|
|
|
|
} else {
|
|
|
|
OS << *ExitValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << "\n";
|
|
|
|
}
|
|
|
|
|
2009-04-22 07:15:49 +08:00
|
|
|
OS << "Determining loop execution counts for: " << F->getName() << "\n";
|
|
|
|
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
|
|
|
|
|
|
|
void ScalarEvolution::print(std::ostream &o, const Module *M) const {
|
|
|
|
raw_os_ostream OS(o);
|
|
|
|
print(OS, M);
|
|
|
|
}
|