2001-12-03 17:28:42 +00:00
|
|
|
//===- IndVarSimplify.cpp - Induction Variable Elimination ----------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-12-03 17:28:42 +00:00
|
|
|
//
|
2004-04-02 20:24:31 +00:00
|
|
|
// This transformation analyzes and transforms the induction variables (and
|
|
|
|
// computations derived from them) into simpler forms suitable for subsequent
|
|
|
|
// analysis and transformation.
|
|
|
|
//
|
2006-08-18 09:01:07 +00:00
|
|
|
// This transformation makes the following changes to each loop with an
|
2004-04-02 20:24:31 +00:00
|
|
|
// identifiable induction variable:
|
|
|
|
// 1. All loops are transformed to have a SINGLE canonical induction variable
|
|
|
|
// which starts at zero and steps by one.
|
|
|
|
// 2. The canonical induction variable is guaranteed to be the first PHI node
|
|
|
|
// in the loop header block.
|
|
|
|
// 3. Any pointer arithmetic recurrences are raised to use array subscripts.
|
|
|
|
//
|
|
|
|
// If the trip count of a loop is computable, this pass also makes the following
|
|
|
|
// changes:
|
|
|
|
// 1. The exit condition for the loop is canonicalized to compare the
|
|
|
|
// induction value against the exit value. This turns loops like:
|
|
|
|
// 'for (i = 7; i*i < 1000; ++i)' into 'for (i = 0; i != 25; ++i)'
|
|
|
|
// 2. Any use outside of the loop of an expression derived from the indvar
|
|
|
|
// is changed to compute the derived value outside of the loop, eliminating
|
|
|
|
// the dependence on the exit value of the induction variable. If the only
|
|
|
|
// purpose of the loop is to compute the exit value of some derived
|
|
|
|
// expression, this transformation will make the loop dead.
|
|
|
|
//
|
|
|
|
// This transformation should be followed by strength reduction after all of the
|
|
|
|
// desired loop transformations have been performed. Additionally, on targets
|
|
|
|
// where it is profitable, the loop could be transformed to count down to zero
|
|
|
|
// (the "do loop" optimization).
|
2001-12-03 17:28:42 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
#define DEBUG_TYPE "indvars"
|
2002-05-07 20:03:00 +00:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2004-04-02 20:24:31 +00:00
|
|
|
#include "llvm/BasicBlock.h"
|
Change the canonical induction variable that we insert.
Instead of producing code like this:
Loop:
X = phi 0, X2
...
X2 = X + 1
if (X != N-1) goto Loop
We now generate code that looks like this:
Loop:
X = phi 0, X2
...
X2 = X + 1
if (X2 != N) goto Loop
This has two big advantages:
1. The trip count of the loop is now explicit in the code, allowing
the direct implementation of Loop::getTripCount()
2. This reduces register pressure in the loop, and allows X and X2 to be
put into the same register.
As a consequence of the second point, the code we generate for loops went
from:
.LBB2: # no_exit.1
...
mov %EDI, %ESI
inc %EDI
cmp %ESI, 2
mov %ESI, %EDI
jne .LBB2 # PC rel: no_exit.1
To:
.LBB2: # no_exit.1
...
inc %ESI
cmp %ESI, 3
jne .LBB2 # PC rel: no_exit.1
... which has two fewer moves, and uses one less register.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12961 91177308-0d34-0410-b5e6-96231b3b80d8
2004-04-15 15:21:43 +00:00
|
|
|
#include "llvm/Constants.h"
|
2003-12-22 05:02:01 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2004-04-02 20:24:31 +00:00
|
|
|
#include "llvm/Type.h"
|
2005-07-30 00:12:19 +00:00
|
|
|
#include "llvm/Analysis/ScalarEvolutionExpander.h"
|
2003-12-18 17:19:19 +00:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2007-03-07 06:39:01 +00:00
|
|
|
#include "llvm/Analysis/LoopPass.h"
|
2002-02-12 22:39:50 +00:00
|
|
|
#include "llvm/Support/CFG.h"
|
2007-02-05 23:32:05 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2007-01-07 01:14:12 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
Handle a common case more carefully. In particular, instead of transforming
pointer recurrences into expressions from this:
%P_addr.0.i.0 = phi sbyte* [ getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), %entry ], [ %inc.0.i, %no_exit.i ]
%inc.0.i = getelementptr sbyte* %P_addr.0.i.0, int 1 ; <sbyte*> [#uses=2]
into this:
%inc.0.i = getelementptr sbyte* getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), int %inc.0.i.rec
Actually create something nice, like this:
%inc.0.i = getelementptr [8 x sbyte]* %.str_1, int 0, int %inc.0.i.rec
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16924 91177308-0d34-0410-b5e6-96231b3b80d8
2004-10-11 23:06:50 +00:00
|
|
|
#include "llvm/Support/GetElementPtrTypeIterator.h"
|
2003-12-18 17:19:19 +00:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2009-02-12 22:19:27 +00:00
|
|
|
#include "llvm/ADT/SetVector.h"
|
2008-11-16 07:17:51 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2003-12-18 17:19:19 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
STATISTIC(NumRemoved , "Number of aux indvars removed");
|
|
|
|
STATISTIC(NumPointer , "Number of pointer indvars promoted");
|
|
|
|
STATISTIC(NumInserted, "Number of canonical indvars added");
|
|
|
|
STATISTIC(NumReplaced, "Number of exit values replaced");
|
|
|
|
STATISTIC(NumLFTR , "Number of loop exit tests replaced");
|
2003-12-22 03:58:44 +00:00
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
namespace {
|
2007-03-07 06:39:01 +00:00
|
|
|
class VISIBILITY_HIDDEN IndVarSimplify : public LoopPass {
|
2004-04-02 20:24:31 +00:00
|
|
|
LoopInfo *LI;
|
|
|
|
ScalarEvolution *SE;
|
2003-12-23 07:47:09 +00:00
|
|
|
bool Changed;
|
2003-12-22 03:58:44 +00:00
|
|
|
public:
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2007-05-06 13:37:16 +00:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2008-09-04 17:05:41 +00:00
|
|
|
IndVarSimplify() : LoopPass(&ID) {}
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2007-03-07 06:39:01 +00:00
|
|
|
bool runOnLoop(Loop *L, LPPassManager &LPM);
|
|
|
|
bool doInitialization(Loop *L, LPPassManager &LPM);
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
2007-09-10 18:08:23 +00:00
|
|
|
AU.addRequired<ScalarEvolution>();
|
2007-03-07 06:39:01 +00:00
|
|
|
AU.addRequiredID(LCSSAID);
|
|
|
|
AU.addRequiredID(LoopSimplifyID);
|
|
|
|
AU.addRequired<LoopInfo>();
|
|
|
|
AU.addPreservedID(LoopSimplifyID);
|
|
|
|
AU.addPreservedID(LCSSAID);
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
}
|
2003-12-22 03:58:44 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
private:
|
2007-03-07 06:39:01 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
void EliminatePointerRecurrence(PHINode *PN, BasicBlock *Preheader,
|
2008-11-16 07:17:51 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> &DeadInsts);
|
2009-02-17 15:57:39 +00:00
|
|
|
void LinearFunctionTestReplace(Loop *L, SCEVHandle IterationCount,
|
|
|
|
Value *IndVar,
|
2009-02-12 22:19:27 +00:00
|
|
|
BasicBlock *ExitingBlock,
|
|
|
|
BranchInst *BI,
|
|
|
|
SCEVExpander &Rewriter);
|
2008-08-05 22:34:21 +00:00
|
|
|
void RewriteLoopExitValues(Loop *L, SCEV *IterationCount);
|
2004-04-02 20:24:31 +00:00
|
|
|
|
2008-11-16 07:17:51 +00:00
|
|
|
void DeleteTriviallyDeadInstructions(SmallPtrSet<Instruction*, 16> &Insts);
|
2008-09-09 21:41:07 +00:00
|
|
|
|
2009-02-17 19:13:57 +00:00
|
|
|
void HandleFloatingPointIV(Loop *L, PHINode *PH,
|
2008-11-17 21:32:02 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> &DeadInsts);
|
2003-12-22 03:58:44 +00:00
|
|
|
};
|
2002-09-10 05:24:05 +00:00
|
|
|
}
|
2001-12-04 04:32:29 +00:00
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
char IndVarSimplify::ID = 0;
|
|
|
|
static RegisterPass<IndVarSimplify>
|
|
|
|
X("indvars", "Canonicalize Induction Variables");
|
|
|
|
|
2008-10-22 23:32:42 +00:00
|
|
|
Pass *llvm::createIndVarSimplifyPass() {
|
2003-12-22 03:58:44 +00:00
|
|
|
return new IndVarSimplify();
|
2001-12-04 04:32:29 +00:00
|
|
|
}
|
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
/// DeleteTriviallyDeadInstructions - If any of the instructions is the
|
|
|
|
/// specified set are trivially dead, delete them and see if this makes any of
|
|
|
|
/// their operands subsequently dead.
|
|
|
|
void IndVarSimplify::
|
2008-11-16 07:17:51 +00:00
|
|
|
DeleteTriviallyDeadInstructions(SmallPtrSet<Instruction*, 16> &Insts) {
|
2004-04-02 20:24:31 +00:00
|
|
|
while (!Insts.empty()) {
|
|
|
|
Instruction *I = *Insts.begin();
|
2008-11-16 07:17:51 +00:00
|
|
|
Insts.erase(I);
|
2004-04-02 20:24:31 +00:00
|
|
|
if (isInstructionTriviallyDead(I)) {
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
|
|
|
|
if (Instruction *U = dyn_cast<Instruction>(I->getOperand(i)))
|
|
|
|
Insts.insert(U);
|
2007-06-19 14:28:31 +00:00
|
|
|
SE->deleteValueFromRecords(I);
|
2007-01-07 01:14:12 +00:00
|
|
|
DOUT << "INDVARS: Deleting: " << *I;
|
Handle a common case more carefully. In particular, instead of transforming
pointer recurrences into expressions from this:
%P_addr.0.i.0 = phi sbyte* [ getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), %entry ], [ %inc.0.i, %no_exit.i ]
%inc.0.i = getelementptr sbyte* %P_addr.0.i.0, int 1 ; <sbyte*> [#uses=2]
into this:
%inc.0.i = getelementptr sbyte* getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), int %inc.0.i.rec
Actually create something nice, like this:
%inc.0.i = getelementptr [8 x sbyte]* %.str_1, int 0, int %inc.0.i.rec
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16924 91177308-0d34-0410-b5e6-96231b3b80d8
2004-10-11 23:06:50 +00:00
|
|
|
I->eraseFromParent();
|
2004-04-02 20:24:31 +00:00
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-12-22 03:58:44 +00:00
|
|
|
|
2001-12-03 17:28:42 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
/// EliminatePointerRecurrence - Check to see if this is a trivial GEP pointer
|
|
|
|
/// recurrence. If so, change it into an integer recurrence, permitting
|
|
|
|
/// analysis by the SCEV routines.
|
2005-04-21 23:48:37 +00:00
|
|
|
void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN,
|
2004-04-02 20:24:31 +00:00
|
|
|
BasicBlock *Preheader,
|
2008-11-16 07:17:51 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> &DeadInsts) {
|
2004-04-02 20:24:31 +00:00
|
|
|
assert(PN->getNumIncomingValues() == 2 && "Noncanonicalized loop!");
|
|
|
|
unsigned PreheaderIdx = PN->getBasicBlockIndex(Preheader);
|
|
|
|
unsigned BackedgeIdx = PreheaderIdx^1;
|
|
|
|
if (GetElementPtrInst *GEPI =
|
2005-08-10 01:12:06 +00:00
|
|
|
dyn_cast<GetElementPtrInst>(PN->getIncomingValue(BackedgeIdx)))
|
2004-04-02 20:24:31 +00:00
|
|
|
if (GEPI->getOperand(0) == PN) {
|
2005-08-10 01:12:06 +00:00
|
|
|
assert(GEPI->getNumOperands() == 2 && "GEP types must match!");
|
2007-01-07 01:14:12 +00:00
|
|
|
DOUT << "INDVARS: Eliminating pointer recurrence: " << *GEPI;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Okay, we found a pointer recurrence. Transform this pointer
|
|
|
|
// recurrence into an integer recurrence. Compute the value that gets
|
|
|
|
// added to the pointer at every iteration.
|
|
|
|
Value *AddedVal = GEPI->getOperand(1);
|
|
|
|
|
|
|
|
// Insert a new integer PHI node into the top of the block.
|
2008-04-06 20:25:17 +00:00
|
|
|
PHINode *NewPhi = PHINode::Create(AddedVal->getType(),
|
|
|
|
PN->getName()+".rec", PN);
|
2004-06-20 05:04:01 +00:00
|
|
|
NewPhi->addIncoming(Constant::getNullValue(NewPhi->getType()), Preheader);
|
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Create the new add instruction.
|
2008-05-16 19:29:10 +00:00
|
|
|
Value *NewAdd = BinaryOperator::CreateAdd(NewPhi, AddedVal,
|
2004-06-20 05:04:01 +00:00
|
|
|
GEPI->getName()+".rec", GEPI);
|
2004-04-02 20:24:31 +00:00
|
|
|
NewPhi->addIncoming(NewAdd, PN->getIncomingBlock(BackedgeIdx));
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Update the existing GEP to use the recurrence.
|
|
|
|
GEPI->setOperand(0, PN->getIncomingValue(PreheaderIdx));
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Update the GEP to use the new recurrence we just inserted.
|
|
|
|
GEPI->setOperand(1, NewAdd);
|
|
|
|
|
Handle a common case more carefully. In particular, instead of transforming
pointer recurrences into expressions from this:
%P_addr.0.i.0 = phi sbyte* [ getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), %entry ], [ %inc.0.i, %no_exit.i ]
%inc.0.i = getelementptr sbyte* %P_addr.0.i.0, int 1 ; <sbyte*> [#uses=2]
into this:
%inc.0.i = getelementptr sbyte* getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), int %inc.0.i.rec
Actually create something nice, like this:
%inc.0.i = getelementptr [8 x sbyte]* %.str_1, int 0, int %inc.0.i.rec
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16924 91177308-0d34-0410-b5e6-96231b3b80d8
2004-10-11 23:06:50 +00:00
|
|
|
// If the incoming value is a constant expr GEP, try peeling out the array
|
|
|
|
// 0 index if possible to make things simpler.
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(GEPI->getOperand(0)))
|
|
|
|
if (CE->getOpcode() == Instruction::GetElementPtr) {
|
|
|
|
unsigned NumOps = CE->getNumOperands();
|
|
|
|
assert(NumOps > 1 && "CE folding didn't work!");
|
|
|
|
if (CE->getOperand(NumOps-1)->isNullValue()) {
|
|
|
|
// Check to make sure the last index really is an array index.
|
2005-11-18 18:30:47 +00:00
|
|
|
gep_type_iterator GTI = gep_type_begin(CE);
|
2005-11-17 19:35:42 +00:00
|
|
|
for (unsigned i = 1, e = CE->getNumOperands()-1;
|
Handle a common case more carefully. In particular, instead of transforming
pointer recurrences into expressions from this:
%P_addr.0.i.0 = phi sbyte* [ getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), %entry ], [ %inc.0.i, %no_exit.i ]
%inc.0.i = getelementptr sbyte* %P_addr.0.i.0, int 1 ; <sbyte*> [#uses=2]
into this:
%inc.0.i = getelementptr sbyte* getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), int %inc.0.i.rec
Actually create something nice, like this:
%inc.0.i = getelementptr [8 x sbyte]* %.str_1, int 0, int %inc.0.i.rec
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16924 91177308-0d34-0410-b5e6-96231b3b80d8
2004-10-11 23:06:50 +00:00
|
|
|
i != e; ++i, ++GTI)
|
|
|
|
/*empty*/;
|
|
|
|
if (isa<SequentialType>(*GTI)) {
|
|
|
|
// Pull the last index out of the constant expr GEP.
|
2007-01-31 04:40:53 +00:00
|
|
|
SmallVector<Value*, 8> CEIdxs(CE->op_begin()+1, CE->op_end()-1);
|
Handle a common case more carefully. In particular, instead of transforming
pointer recurrences into expressions from this:
%P_addr.0.i.0 = phi sbyte* [ getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), %entry ], [ %inc.0.i, %no_exit.i ]
%inc.0.i = getelementptr sbyte* %P_addr.0.i.0, int 1 ; <sbyte*> [#uses=2]
into this:
%inc.0.i = getelementptr sbyte* getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), int %inc.0.i.rec
Actually create something nice, like this:
%inc.0.i = getelementptr [8 x sbyte]* %.str_1, int 0, int %inc.0.i.rec
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16924 91177308-0d34-0410-b5e6-96231b3b80d8
2004-10-11 23:06:50 +00:00
|
|
|
Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0),
|
2007-01-31 04:40:53 +00:00
|
|
|
&CEIdxs[0],
|
|
|
|
CEIdxs.size());
|
2007-09-04 15:46:09 +00:00
|
|
|
Value *Idx[2];
|
|
|
|
Idx[0] = Constant::getNullValue(Type::Int32Ty);
|
|
|
|
Idx[1] = NewAdd;
|
2008-04-06 20:25:17 +00:00
|
|
|
GetElementPtrInst *NGEPI = GetElementPtrInst::Create(
|
2009-02-17 19:13:57 +00:00
|
|
|
NCE, Idx, Idx + 2,
|
2007-03-02 00:28:52 +00:00
|
|
|
GEPI->getName(), GEPI);
|
2007-06-19 14:28:31 +00:00
|
|
|
SE->deleteValueFromRecords(GEPI);
|
Handle a common case more carefully. In particular, instead of transforming
pointer recurrences into expressions from this:
%P_addr.0.i.0 = phi sbyte* [ getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), %entry ], [ %inc.0.i, %no_exit.i ]
%inc.0.i = getelementptr sbyte* %P_addr.0.i.0, int 1 ; <sbyte*> [#uses=2]
into this:
%inc.0.i = getelementptr sbyte* getelementptr ([8 x sbyte]* %.str_1, int 0, int 0), int %inc.0.i.rec
Actually create something nice, like this:
%inc.0.i = getelementptr [8 x sbyte]* %.str_1, int 0, int %inc.0.i.rec
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16924 91177308-0d34-0410-b5e6-96231b3b80d8
2004-10-11 23:06:50 +00:00
|
|
|
GEPI->replaceAllUsesWith(NGEPI);
|
|
|
|
GEPI->eraseFromParent();
|
|
|
|
GEPI = NGEPI;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Finally, if there are any other users of the PHI node, we must
|
|
|
|
// insert a new GEP instruction that uses the pre-incremented version
|
|
|
|
// of the induction amount.
|
|
|
|
if (!PN->use_empty()) {
|
|
|
|
BasicBlock::iterator InsertPos = PN; ++InsertPos;
|
|
|
|
while (isa<PHINode>(InsertPos)) ++InsertPos;
|
|
|
|
Value *PreInc =
|
2008-04-06 20:25:17 +00:00
|
|
|
GetElementPtrInst::Create(PN->getIncomingValue(PreheaderIdx),
|
|
|
|
NewPhi, "", InsertPos);
|
2007-02-11 01:23:03 +00:00
|
|
|
PreInc->takeName(PN);
|
2004-04-02 20:24:31 +00:00
|
|
|
PN->replaceAllUsesWith(PreInc);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete the old PHI for sure, and the GEP if its otherwise unused.
|
|
|
|
DeadInsts.insert(PN);
|
2003-12-22 03:58:44 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
++NumPointer;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
2003-12-22 03:58:44 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
/// LinearFunctionTestReplace - This method rewrites the exit condition of the
|
Change the canonical induction variable that we insert.
Instead of producing code like this:
Loop:
X = phi 0, X2
...
X2 = X + 1
if (X != N-1) goto Loop
We now generate code that looks like this:
Loop:
X = phi 0, X2
...
X2 = X + 1
if (X2 != N) goto Loop
This has two big advantages:
1. The trip count of the loop is now explicit in the code, allowing
the direct implementation of Loop::getTripCount()
2. This reduces register pressure in the loop, and allows X and X2 to be
put into the same register.
As a consequence of the second point, the code we generate for loops went
from:
.LBB2: # no_exit.1
...
mov %EDI, %ESI
inc %EDI
cmp %ESI, 2
mov %ESI, %EDI
jne .LBB2 # PC rel: no_exit.1
To:
.LBB2: # no_exit.1
...
inc %ESI
cmp %ESI, 3
jne .LBB2 # PC rel: no_exit.1
... which has two fewer moves, and uses one less register.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12961 91177308-0d34-0410-b5e6-96231b3b80d8
2004-04-15 15:21:43 +00:00
|
|
|
/// loop to be a canonical != comparison against the incremented loop induction
|
|
|
|
/// variable. This pass is able to rewrite the exit tests of any loop where the
|
|
|
|
/// SCEV analysis can determine a loop-invariant trip count of the loop, which
|
|
|
|
/// is actually a much broader range than just linear tests.
|
2009-02-12 22:19:27 +00:00
|
|
|
void IndVarSimplify::LinearFunctionTestReplace(Loop *L,
|
|
|
|
SCEVHandle IterationCount,
|
|
|
|
Value *IndVar,
|
|
|
|
BasicBlock *ExitingBlock,
|
|
|
|
BranchInst *BI,
|
|
|
|
SCEVExpander &Rewriter) {
|
2004-04-15 20:26:22 +00:00
|
|
|
// If the exiting block is not the same as the backedge block, we must compare
|
|
|
|
// against the preincremented value, otherwise we prefer to compare against
|
|
|
|
// the post-incremented value.
|
2009-02-12 22:19:27 +00:00
|
|
|
Value *CmpIndVar;
|
|
|
|
if (ExitingBlock == L->getLoopLatch()) {
|
|
|
|
// What ScalarEvolution calls the "iteration count" is actually the
|
|
|
|
// number of times the branch is taken. Add one to get the number
|
|
|
|
// of times the branch is executed. If this addition may overflow,
|
|
|
|
// we have to be more pessimistic and cast the induction variable
|
|
|
|
// before doing the add.
|
|
|
|
SCEVHandle Zero = SE->getIntegerSCEV(0, IterationCount->getType());
|
|
|
|
SCEVHandle N =
|
|
|
|
SE->getAddExpr(IterationCount,
|
|
|
|
SE->getIntegerSCEV(1, IterationCount->getType()));
|
|
|
|
if ((isa<SCEVConstant>(N) && !N->isZero()) ||
|
|
|
|
SE->isLoopGuardedByCond(L, ICmpInst::ICMP_NE, N, Zero)) {
|
|
|
|
// No overflow. Cast the sum.
|
|
|
|
IterationCount = SE->getTruncateOrZeroExtend(N, IndVar->getType());
|
|
|
|
} else {
|
|
|
|
// Potential overflow. Cast before doing the add.
|
|
|
|
IterationCount = SE->getTruncateOrZeroExtend(IterationCount,
|
|
|
|
IndVar->getType());
|
|
|
|
IterationCount =
|
|
|
|
SE->getAddExpr(IterationCount,
|
|
|
|
SE->getIntegerSCEV(1, IndVar->getType()));
|
|
|
|
}
|
|
|
|
|
2004-04-15 20:26:22 +00:00
|
|
|
// The IterationCount expression contains the number of times that the
|
|
|
|
// backedge actually branches to the loop header. This is one less than the
|
|
|
|
// number of times the loop executes, so add one to it.
|
2009-02-12 22:19:27 +00:00
|
|
|
CmpIndVar = L->getCanonicalInductionVariableIncrement();
|
2004-04-15 20:26:22 +00:00
|
|
|
} else {
|
|
|
|
// We have to use the preincremented value...
|
2009-02-12 22:19:27 +00:00
|
|
|
IterationCount = SE->getTruncateOrZeroExtend(IterationCount,
|
|
|
|
IndVar->getType());
|
|
|
|
CmpIndVar = IndVar;
|
2004-04-15 20:26:22 +00:00
|
|
|
}
|
Change the canonical induction variable that we insert.
Instead of producing code like this:
Loop:
X = phi 0, X2
...
X2 = X + 1
if (X != N-1) goto Loop
We now generate code that looks like this:
Loop:
X = phi 0, X2
...
X2 = X + 1
if (X2 != N) goto Loop
This has two big advantages:
1. The trip count of the loop is now explicit in the code, allowing
the direct implementation of Loop::getTripCount()
2. This reduces register pressure in the loop, and allows X and X2 to be
put into the same register.
As a consequence of the second point, the code we generate for loops went
from:
.LBB2: # no_exit.1
...
mov %EDI, %ESI
inc %EDI
cmp %ESI, 2
mov %ESI, %EDI
jne .LBB2 # PC rel: no_exit.1
To:
.LBB2: # no_exit.1
...
inc %ESI
cmp %ESI, 3
jne .LBB2 # PC rel: no_exit.1
... which has two fewer moves, and uses one less register.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12961 91177308-0d34-0410-b5e6-96231b3b80d8
2004-04-15 15:21:43 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Expand the code for the iteration count into the preheader of the loop.
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
2009-02-12 22:19:27 +00:00
|
|
|
Value *ExitCnt = Rewriter.expandCodeFor(IterationCount,
|
|
|
|
Preheader->getTerminator());
|
2004-04-02 20:24:31 +00:00
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
// Insert a new icmp_ne or icmp_eq instruction before the branch.
|
|
|
|
ICmpInst::Predicate Opcode;
|
2004-04-02 20:24:31 +00:00
|
|
|
if (L->contains(BI->getSuccessor(0)))
|
2006-12-23 06:05:41 +00:00
|
|
|
Opcode = ICmpInst::ICMP_NE;
|
2004-04-02 20:24:31 +00:00
|
|
|
else
|
2006-12-23 06:05:41 +00:00
|
|
|
Opcode = ICmpInst::ICMP_EQ;
|
2004-04-02 20:24:31 +00:00
|
|
|
|
2009-02-12 22:19:27 +00:00
|
|
|
DOUT << "INDVARS: Rewriting loop exit condition to:\n"
|
|
|
|
<< " LHS:" << *CmpIndVar // includes a newline
|
|
|
|
<< " op:\t"
|
2009-02-14 02:26:50 +00:00
|
|
|
<< (Opcode == ICmpInst::ICMP_NE ? "!=" : "==") << "\n"
|
2009-02-12 22:19:27 +00:00
|
|
|
<< " RHS:\t" << *IterationCount << "\n";
|
|
|
|
|
|
|
|
Value *Cond = new ICmpInst(Opcode, CmpIndVar, ExitCnt, "exitcond", BI);
|
2004-04-02 20:24:31 +00:00
|
|
|
BI->setCondition(Cond);
|
|
|
|
++NumLFTR;
|
|
|
|
Changed = true;
|
|
|
|
}
|
2003-12-22 03:58:44 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
/// RewriteLoopExitValues - Check to see if this loop has a computable
|
|
|
|
/// loop-invariant execution count. If so, this means that we can compute the
|
|
|
|
/// final value of any expressions that are recurrent in the loop, and
|
|
|
|
/// substitute the exit values from the loop into any instructions outside of
|
|
|
|
/// the loop that use the final values of the current expressions.
|
2008-08-05 22:34:21 +00:00
|
|
|
void IndVarSimplify::RewriteLoopExitValues(Loop *L, SCEV *IterationCount) {
|
2004-04-02 20:24:31 +00:00
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
|
|
|
|
|
|
|
// Scan all of the instructions in the loop, looking at those that have
|
|
|
|
// extra-loop users and which are recurrences.
|
2004-04-23 21:29:48 +00:00
|
|
|
SCEVExpander Rewriter(*SE, *LI);
|
2004-04-02 20:24:31 +00:00
|
|
|
|
|
|
|
// We insert the code into the preheader of the loop if the loop contains
|
|
|
|
// multiple exit blocks, or in the exit block if there is exactly one.
|
|
|
|
BasicBlock *BlockToInsertInto;
|
2007-08-21 00:31:24 +00:00
|
|
|
SmallVector<BasicBlock*, 8> ExitBlocks;
|
2007-03-04 03:43:23 +00:00
|
|
|
L->getUniqueExitBlocks(ExitBlocks);
|
2004-04-18 22:14:10 +00:00
|
|
|
if (ExitBlocks.size() == 1)
|
|
|
|
BlockToInsertInto = ExitBlocks[0];
|
2004-04-02 20:24:31 +00:00
|
|
|
else
|
|
|
|
BlockToInsertInto = Preheader;
|
2008-05-23 21:05:58 +00:00
|
|
|
BasicBlock::iterator InsertPt = BlockToInsertInto->getFirstNonPHI();
|
2004-04-02 20:24:31 +00:00
|
|
|
|
2008-08-05 22:34:21 +00:00
|
|
|
bool HasConstantItCount = isa<SCEVConstant>(IterationCount);
|
2004-04-17 18:44:09 +00:00
|
|
|
|
2008-11-16 07:17:51 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> InstructionsToDelete;
|
2007-03-04 03:43:23 +00:00
|
|
|
std::map<Instruction*, Value*> ExitValues;
|
|
|
|
|
|
|
|
// Find all values that are computed inside the loop, but used outside of it.
|
|
|
|
// Because of LCSSA, these values will only occur in LCSSA PHI Nodes. Scan
|
|
|
|
// the exit blocks of the loop to find them.
|
|
|
|
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
|
|
|
|
BasicBlock *ExitBB = ExitBlocks[i];
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// If there are no PHI nodes in this exit block, then no values defined
|
|
|
|
// inside the loop are used on this path, skip it.
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(ExitBB->begin());
|
|
|
|
if (!PN) continue;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
unsigned NumPreds = PN->getNumIncomingValues();
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// Iterate over all of the PHI nodes.
|
|
|
|
BasicBlock::iterator BBI = ExitBB->begin();
|
|
|
|
while ((PN = dyn_cast<PHINode>(BBI++))) {
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// Iterate over all of the values in all the PHI nodes.
|
|
|
|
for (unsigned i = 0; i != NumPreds; ++i) {
|
|
|
|
// If the value being merged in is not integer or is not defined
|
|
|
|
// in the loop, skip it.
|
|
|
|
Value *InVal = PN->getIncomingValue(i);
|
|
|
|
if (!isa<Instruction>(InVal) ||
|
|
|
|
// SCEV only supports integer expressions for now.
|
|
|
|
!isa<IntegerType>(InVal->getType()))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If this pred is for a subloop, not L itself, skip it.
|
2009-02-17 19:13:57 +00:00
|
|
|
if (LI->getLoopFor(PN->getIncomingBlock(i)) != L)
|
2007-03-04 03:43:23 +00:00
|
|
|
continue; // The Block is in a subloop, skip it.
|
|
|
|
|
|
|
|
// Check that InVal is defined in the loop.
|
|
|
|
Instruction *Inst = cast<Instruction>(InVal);
|
|
|
|
if (!L->contains(Inst->getParent()))
|
|
|
|
continue;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// We require that this value either have a computable evolution or that
|
|
|
|
// the loop have a constant iteration count. In the case where the loop
|
|
|
|
// has a constant iteration count, we can sometimes force evaluation of
|
|
|
|
// the exit value through brute force.
|
|
|
|
SCEVHandle SH = SE->getSCEV(Inst);
|
|
|
|
if (!SH->hasComputableLoopEvolution(L) && !HasConstantItCount)
|
|
|
|
continue; // Cannot get exit evolution for the loop value.
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// Okay, this instruction has a user outside of the current loop
|
|
|
|
// and varies predictably *inside* the loop. Evaluate the value it
|
|
|
|
// contains when the loop exits, if possible.
|
|
|
|
SCEVHandle ExitValue = SE->getSCEVAtScope(Inst, L->getParentLoop());
|
|
|
|
if (isa<SCEVCouldNotCompute>(ExitValue) ||
|
|
|
|
!ExitValue->isLoopInvariant(L))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Changed = true;
|
|
|
|
++NumReplaced;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// See if we already computed the exit value for the instruction, if so,
|
|
|
|
// just reuse it.
|
|
|
|
Value *&ExitVal = ExitValues[Inst];
|
|
|
|
if (!ExitVal)
|
2007-06-15 14:38:12 +00:00
|
|
|
ExitVal = Rewriter.expandCodeFor(ExitValue, InsertPt);
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
DOUT << "INDVARS: RLEV: AfterLoopVal = " << *ExitVal
|
|
|
|
<< " LoopVal = " << *Inst << "\n";
|
2007-03-04 01:00:28 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
PN->setIncomingValue(i, ExitVal);
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// If this instruction is dead now, schedule it to be removed.
|
|
|
|
if (Inst->use_empty())
|
|
|
|
InstructionsToDelete.insert(Inst);
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2007-03-04 03:43:23 +00:00
|
|
|
// See if this is a single-entry LCSSA PHI node. If so, we can (and
|
|
|
|
// have to) remove
|
2007-03-04 01:00:28 +00:00
|
|
|
// the PHI entirely. This is safe, because the NewVal won't be variant
|
|
|
|
// in the loop, so we don't need an LCSSA phi node anymore.
|
2007-03-04 03:43:23 +00:00
|
|
|
if (NumPreds == 1) {
|
2007-06-19 14:28:31 +00:00
|
|
|
SE->deleteValueFromRecords(PN);
|
2007-03-04 03:43:23 +00:00
|
|
|
PN->replaceAllUsesWith(ExitVal);
|
|
|
|
PN->eraseFromParent();
|
|
|
|
break;
|
2007-03-03 22:48:48 +00:00
|
|
|
}
|
2005-06-15 21:29:31 +00:00
|
|
|
}
|
2007-03-03 22:48:48 +00:00
|
|
|
}
|
|
|
|
}
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
DeleteTriviallyDeadInstructions(InstructionsToDelete);
|
|
|
|
}
|
2003-12-23 07:47:09 +00:00
|
|
|
|
2007-03-07 06:39:01 +00:00
|
|
|
bool IndVarSimplify::doInitialization(Loop *L, LPPassManager &LPM) {
|
2003-12-23 07:47:09 +00:00
|
|
|
|
2007-03-07 06:39:01 +00:00
|
|
|
Changed = false;
|
2004-04-02 20:24:31 +00:00
|
|
|
// First step. Check to see if there are any trivial GEP pointer recurrences.
|
|
|
|
// If there are, change them into integer recurrences, permitting analysis by
|
|
|
|
// the SCEV routines.
|
2003-12-23 07:47:09 +00:00
|
|
|
//
|
2004-04-02 20:24:31 +00:00
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
2007-03-07 06:39:01 +00:00
|
|
|
SE = &LPM.getAnalysis<ScalarEvolution>();
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2008-11-16 07:17:51 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> DeadInsts;
|
2004-09-15 17:06:42 +00:00
|
|
|
for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2004-04-02 20:24:31 +00:00
|
|
|
if (isa<PointerType>(PN->getType()))
|
|
|
|
EliminatePointerRecurrence(PN, Preheader, DeadInsts);
|
2008-11-17 21:32:02 +00:00
|
|
|
else
|
|
|
|
HandleFloatingPointIV(L, PN, DeadInsts);
|
2004-09-15 17:06:42 +00:00
|
|
|
}
|
2003-12-23 07:47:09 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
if (!DeadInsts.empty())
|
|
|
|
DeleteTriviallyDeadInstructions(DeadInsts);
|
2001-12-04 04:32:29 +00:00
|
|
|
|
2007-03-07 06:39:01 +00:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2009-02-12 22:19:27 +00:00
|
|
|
/// getEffectiveIndvarType - Determine the widest type that the
|
|
|
|
/// induction-variable PHINode Phi is cast to.
|
|
|
|
///
|
|
|
|
static const Type *getEffectiveIndvarType(const PHINode *Phi) {
|
|
|
|
const Type *Ty = Phi->getType();
|
|
|
|
|
|
|
|
for (Value::use_const_iterator UI = Phi->use_begin(), UE = Phi->use_end();
|
|
|
|
UI != UE; ++UI) {
|
|
|
|
const Type *CandidateType = NULL;
|
|
|
|
if (const ZExtInst *ZI = dyn_cast<ZExtInst>(UI))
|
|
|
|
CandidateType = ZI->getDestTy();
|
|
|
|
else if (const SExtInst *SI = dyn_cast<SExtInst>(UI))
|
|
|
|
CandidateType = SI->getDestTy();
|
|
|
|
if (CandidateType &&
|
|
|
|
CandidateType->getPrimitiveSizeInBits() >
|
|
|
|
Ty->getPrimitiveSizeInBits())
|
|
|
|
Ty = CandidateType;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Ty;
|
|
|
|
}
|
2007-03-07 06:39:01 +00:00
|
|
|
|
2009-02-14 02:31:09 +00:00
|
|
|
/// TestOrigIVForWrap - Analyze the original induction variable
|
|
|
|
/// in the loop to determine whether it would ever undergo signed
|
|
|
|
/// or unsigned overflow.
|
2009-02-12 22:19:27 +00:00
|
|
|
///
|
|
|
|
/// TODO: This duplicates a fair amount of ScalarEvolution logic.
|
2009-02-14 02:31:09 +00:00
|
|
|
/// Perhaps this can be merged with ScalarEvolution::getIterationCount
|
|
|
|
/// and/or ScalarEvolution::get{Sign,Zero}ExtendExpr.
|
2009-02-12 22:19:27 +00:00
|
|
|
///
|
2009-02-14 02:31:09 +00:00
|
|
|
static void TestOrigIVForWrap(const Loop *L,
|
|
|
|
const BranchInst *BI,
|
|
|
|
const Instruction *OrigCond,
|
|
|
|
bool &NoSignedWrap,
|
|
|
|
bool &NoUnsignedWrap) {
|
2009-02-12 22:19:27 +00:00
|
|
|
// Verify that the loop is sane and find the exit condition.
|
|
|
|
const ICmpInst *Cmp = dyn_cast<ICmpInst>(OrigCond);
|
2009-02-14 02:31:09 +00:00
|
|
|
if (!Cmp) return;
|
|
|
|
|
|
|
|
const Value *CmpLHS = Cmp->getOperand(0);
|
|
|
|
const Value *CmpRHS = Cmp->getOperand(1);
|
|
|
|
const BasicBlock *TrueBB = BI->getSuccessor(0);
|
|
|
|
const BasicBlock *FalseBB = BI->getSuccessor(1);
|
|
|
|
ICmpInst::Predicate Pred = Cmp->getPredicate();
|
|
|
|
|
|
|
|
// Canonicalize a constant to the RHS.
|
|
|
|
if (isa<ConstantInt>(CmpLHS)) {
|
|
|
|
Pred = ICmpInst::getSwappedPredicate(Pred);
|
|
|
|
std::swap(CmpLHS, CmpRHS);
|
|
|
|
}
|
|
|
|
// Canonicalize SLE to SLT.
|
|
|
|
if (Pred == ICmpInst::ICMP_SLE)
|
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS))
|
|
|
|
if (!CI->getValue().isMaxSignedValue()) {
|
|
|
|
CmpRHS = ConstantInt::get(CI->getValue() + 1);
|
|
|
|
Pred = ICmpInst::ICMP_SLT;
|
|
|
|
}
|
|
|
|
// Canonicalize SGT to SGE.
|
|
|
|
if (Pred == ICmpInst::ICMP_SGT)
|
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS))
|
|
|
|
if (!CI->getValue().isMaxSignedValue()) {
|
|
|
|
CmpRHS = ConstantInt::get(CI->getValue() + 1);
|
|
|
|
Pred = ICmpInst::ICMP_SGE;
|
|
|
|
}
|
|
|
|
// Canonicalize SGE to SLT.
|
|
|
|
if (Pred == ICmpInst::ICMP_SGE) {
|
|
|
|
std::swap(TrueBB, FalseBB);
|
|
|
|
Pred = ICmpInst::ICMP_SLT;
|
|
|
|
}
|
|
|
|
// Canonicalize ULE to ULT.
|
|
|
|
if (Pred == ICmpInst::ICMP_ULE)
|
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS))
|
|
|
|
if (!CI->getValue().isMaxValue()) {
|
|
|
|
CmpRHS = ConstantInt::get(CI->getValue() + 1);
|
|
|
|
Pred = ICmpInst::ICMP_ULT;
|
|
|
|
}
|
|
|
|
// Canonicalize UGT to UGE.
|
|
|
|
if (Pred == ICmpInst::ICMP_UGT)
|
|
|
|
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CmpRHS))
|
|
|
|
if (!CI->getValue().isMaxValue()) {
|
|
|
|
CmpRHS = ConstantInt::get(CI->getValue() + 1);
|
|
|
|
Pred = ICmpInst::ICMP_UGE;
|
|
|
|
}
|
|
|
|
// Canonicalize UGE to ULT.
|
|
|
|
if (Pred == ICmpInst::ICMP_UGE) {
|
|
|
|
std::swap(TrueBB, FalseBB);
|
|
|
|
Pred = ICmpInst::ICMP_ULT;
|
|
|
|
}
|
|
|
|
// For now, analyze only LT loops for signed overflow.
|
|
|
|
if (Pred != ICmpInst::ICMP_SLT && Pred != ICmpInst::ICMP_ULT)
|
|
|
|
return;
|
2009-02-12 22:19:27 +00:00
|
|
|
|
2009-02-14 02:31:09 +00:00
|
|
|
bool isSigned = Pred == ICmpInst::ICMP_SLT;
|
2009-02-12 22:19:27 +00:00
|
|
|
|
2009-02-14 02:31:09 +00:00
|
|
|
// Get the increment instruction. Look past casts if we will
|
2009-02-12 22:19:27 +00:00
|
|
|
// be able to prove that the original induction variable doesn't
|
2009-02-14 02:31:09 +00:00
|
|
|
// undergo signed or unsigned overflow, respectively.
|
|
|
|
const Value *IncrVal = CmpLHS;
|
|
|
|
if (isSigned) {
|
|
|
|
if (const SExtInst *SI = dyn_cast<SExtInst>(CmpLHS)) {
|
|
|
|
if (!isa<ConstantInt>(CmpRHS) ||
|
|
|
|
!cast<ConstantInt>(CmpRHS)->getValue()
|
|
|
|
.isSignedIntN(IncrVal->getType()->getPrimitiveSizeInBits()))
|
|
|
|
return;
|
|
|
|
IncrVal = SI->getOperand(0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (const ZExtInst *ZI = dyn_cast<ZExtInst>(CmpLHS)) {
|
|
|
|
if (!isa<ConstantInt>(CmpRHS) ||
|
|
|
|
!cast<ConstantInt>(CmpRHS)->getValue()
|
|
|
|
.isIntN(IncrVal->getType()->getPrimitiveSizeInBits()))
|
|
|
|
return;
|
|
|
|
IncrVal = ZI->getOperand(0);
|
|
|
|
}
|
2009-02-12 22:19:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// For now, only analyze induction variables that have simple increments.
|
|
|
|
const BinaryOperator *IncrOp = dyn_cast<BinaryOperator>(IncrVal);
|
|
|
|
if (!IncrOp ||
|
|
|
|
IncrOp->getOpcode() != Instruction::Add ||
|
|
|
|
!isa<ConstantInt>(IncrOp->getOperand(1)) ||
|
|
|
|
!cast<ConstantInt>(IncrOp->getOperand(1))->equalsInt(1))
|
2009-02-14 02:31:09 +00:00
|
|
|
return;
|
2009-02-12 22:19:27 +00:00
|
|
|
|
|
|
|
// Make sure the PHI looks like a normal IV.
|
|
|
|
const PHINode *PN = dyn_cast<PHINode>(IncrOp->getOperand(0));
|
|
|
|
if (!PN || PN->getNumIncomingValues() != 2)
|
2009-02-14 02:31:09 +00:00
|
|
|
return;
|
2009-02-12 22:19:27 +00:00
|
|
|
unsigned IncomingEdge = L->contains(PN->getIncomingBlock(0));
|
|
|
|
unsigned BackEdge = !IncomingEdge;
|
|
|
|
if (!L->contains(PN->getIncomingBlock(BackEdge)) ||
|
|
|
|
PN->getIncomingValue(BackEdge) != IncrOp)
|
2009-02-14 02:31:09 +00:00
|
|
|
return;
|
|
|
|
if (!L->contains(TrueBB))
|
|
|
|
return;
|
2009-02-12 22:19:27 +00:00
|
|
|
|
|
|
|
// For now, only analyze loops with a constant start value, so that
|
2009-02-14 02:31:09 +00:00
|
|
|
// we can easily determine if the start value is not a maximum value
|
|
|
|
// which would wrap on the first iteration.
|
2009-02-12 22:19:27 +00:00
|
|
|
const Value *InitialVal = PN->getIncomingValue(IncomingEdge);
|
2009-02-14 02:31:09 +00:00
|
|
|
if (!isa<ConstantInt>(InitialVal))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// The original induction variable will start at some non-max value,
|
|
|
|
// it counts up by one, and the loop iterates only while it remans
|
|
|
|
// less than some value in the same type. As such, it will never wrap.
|
|
|
|
if (isSigned &&
|
|
|
|
!cast<ConstantInt>(InitialVal)->getValue().isMaxSignedValue())
|
|
|
|
NoSignedWrap = true;
|
|
|
|
else if (!isSigned &&
|
|
|
|
!cast<ConstantInt>(InitialVal)->getValue().isMaxValue())
|
|
|
|
NoUnsignedWrap = true;
|
2009-02-12 22:19:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IndVarSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
|
2007-03-07 06:39:01 +00:00
|
|
|
LI = &getAnalysis<LoopInfo>();
|
|
|
|
SE = &getAnalysis<ScalarEvolution>();
|
2001-12-04 04:32:29 +00:00
|
|
|
|
2007-03-07 06:39:01 +00:00
|
|
|
Changed = false;
|
2009-02-12 22:19:27 +00:00
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
BasicBlock *ExitingBlock = L->getExitingBlock();
|
2008-11-16 07:17:51 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> DeadInsts;
|
2009-02-12 22:19:27 +00:00
|
|
|
|
2007-03-04 01:00:28 +00:00
|
|
|
// Verify the input to the pass in already in LCSSA form.
|
|
|
|
assert(L->isLCSSAForm());
|
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Check to see if this loop has a computable loop-invariant execution count.
|
|
|
|
// If so, this means that we can compute the final value of any expressions
|
|
|
|
// that are recurrent in the loop, and substitute the exit values from the
|
|
|
|
// loop into any instructions outside of the loop that use the final values of
|
|
|
|
// the current expressions.
|
2001-12-04 04:32:29 +00:00
|
|
|
//
|
2004-04-02 20:24:31 +00:00
|
|
|
SCEVHandle IterationCount = SE->getIterationCount(L);
|
|
|
|
if (!isa<SCEVCouldNotCompute>(IterationCount))
|
2008-08-05 22:34:21 +00:00
|
|
|
RewriteLoopExitValues(L, IterationCount);
|
2004-04-02 20:24:31 +00:00
|
|
|
|
|
|
|
// Next, analyze all of the induction variables in the loop, canonicalizing
|
|
|
|
// auxillary induction variables.
|
|
|
|
std::vector<std::pair<PHINode*, SCEVHandle> > IndVars;
|
|
|
|
|
2004-09-15 17:06:42 +00:00
|
|
|
for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2007-01-15 02:27:26 +00:00
|
|
|
if (PN->getType()->isInteger()) { // FIXME: when we have fast-math, enable!
|
2004-04-02 20:24:31 +00:00
|
|
|
SCEVHandle SCEV = SE->getSCEV(PN);
|
2009-02-14 02:25:19 +00:00
|
|
|
// FIXME: It is an extremely bad idea to indvar substitute anything more
|
|
|
|
// complex than affine induction variables. Doing so will put expensive
|
|
|
|
// polynomial evaluations inside of the loop, and the str reduction pass
|
|
|
|
// currently can only reduce affine polynomials. For now just disable
|
|
|
|
// indvar subst on anything more complex than an affine addrec.
|
|
|
|
if (SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(SCEV))
|
|
|
|
if (AR->getLoop() == L && AR->isAffine())
|
|
|
|
IndVars.push_back(std::make_pair(PN, SCEV));
|
2004-04-02 20:24:31 +00:00
|
|
|
}
|
2004-09-15 17:06:42 +00:00
|
|
|
}
|
2002-05-22 17:17:27 +00:00
|
|
|
|
2009-02-12 22:19:27 +00:00
|
|
|
// Compute the type of the largest recurrence expression, and collect
|
|
|
|
// the set of the types of the other recurrence expressions.
|
|
|
|
const Type *LargestType = 0;
|
|
|
|
SmallSetVector<const Type *, 4> SizesToInsert;
|
|
|
|
if (!isa<SCEVCouldNotCompute>(IterationCount)) {
|
|
|
|
LargestType = IterationCount->getType();
|
|
|
|
SizesToInsert.insert(IterationCount->getType());
|
2004-04-17 18:08:33 +00:00
|
|
|
}
|
2009-02-12 22:19:27 +00:00
|
|
|
for (unsigned i = 0, e = IndVars.size(); i != e; ++i) {
|
|
|
|
const PHINode *PN = IndVars[i].first;
|
|
|
|
SizesToInsert.insert(PN->getType());
|
|
|
|
const Type *EffTy = getEffectiveIndvarType(PN);
|
|
|
|
SizesToInsert.insert(EffTy);
|
|
|
|
if (!LargestType ||
|
|
|
|
EffTy->getPrimitiveSizeInBits() >
|
|
|
|
LargestType->getPrimitiveSizeInBits())
|
|
|
|
LargestType = EffTy;
|
2003-12-22 09:53:29 +00:00
|
|
|
}
|
2001-12-04 04:32:29 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Create a rewriter object which we'll use to transform the code with.
|
2004-04-23 21:29:48 +00:00
|
|
|
SCEVExpander Rewriter(*SE, *LI);
|
2004-04-02 20:24:31 +00:00
|
|
|
|
|
|
|
// Now that we know the largest of of the induction variables in this loop,
|
|
|
|
// insert a canonical induction variable of the largest size.
|
2009-02-12 22:19:27 +00:00
|
|
|
Value *IndVar = 0;
|
|
|
|
if (!SizesToInsert.empty()) {
|
|
|
|
IndVar = Rewriter.getOrInsertCanonicalInductionVariable(L,LargestType);
|
|
|
|
++NumInserted;
|
|
|
|
Changed = true;
|
|
|
|
DOUT << "INDVARS: New CanIV: " << *IndVar;
|
2007-06-15 14:38:12 +00:00
|
|
|
}
|
2004-04-02 20:24:31 +00:00
|
|
|
|
2009-02-12 22:19:27 +00:00
|
|
|
// If we have a trip count expression, rewrite the loop's exit condition
|
|
|
|
// using it. We can currently only handle loops with a single exit.
|
2009-02-14 02:31:09 +00:00
|
|
|
bool NoSignedWrap = false;
|
|
|
|
bool NoUnsignedWrap = false;
|
2009-02-12 22:19:27 +00:00
|
|
|
if (!isa<SCEVCouldNotCompute>(IterationCount) && ExitingBlock)
|
|
|
|
// Can't rewrite non-branch yet.
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator())) {
|
|
|
|
if (Instruction *OrigCond = dyn_cast<Instruction>(BI->getCondition())) {
|
2009-02-14 02:31:09 +00:00
|
|
|
// Determine if the OrigIV will ever undergo overflow.
|
|
|
|
TestOrigIVForWrap(L, BI, OrigCond,
|
|
|
|
NoSignedWrap, NoUnsignedWrap);
|
2009-02-12 22:19:27 +00:00
|
|
|
|
|
|
|
// We'll be replacing the original condition, so it'll be dead.
|
|
|
|
DeadInsts.insert(OrigCond);
|
|
|
|
}
|
|
|
|
|
|
|
|
LinearFunctionTestReplace(L, IterationCount, IndVar,
|
|
|
|
ExitingBlock, BI, Rewriter);
|
|
|
|
}
|
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Now that we have a canonical induction variable, we can rewrite any
|
|
|
|
// recurrences in terms of the induction variable. Start with the auxillary
|
|
|
|
// induction variables, and recursively rewrite any of their uses.
|
2008-05-23 21:05:58 +00:00
|
|
|
BasicBlock::iterator InsertPt = Header->getFirstNonPHI();
|
2004-04-02 20:24:31 +00:00
|
|
|
|
2004-04-22 14:59:40 +00:00
|
|
|
// If there were induction variables of other sizes, cast the primary
|
|
|
|
// induction variable to the right size for them, avoiding the need for the
|
|
|
|
// code evaluation methods to insert induction variables of different sizes.
|
2009-02-12 22:19:27 +00:00
|
|
|
for (unsigned i = 0, e = SizesToInsert.size(); i != e; ++i) {
|
|
|
|
const Type *Ty = SizesToInsert[i];
|
|
|
|
if (Ty != LargestType) {
|
|
|
|
Instruction *New = new TruncInst(IndVar, Ty, "indvar", InsertPt);
|
|
|
|
Rewriter.addInsertedValue(New, SE->getSCEV(New));
|
|
|
|
DOUT << "INDVARS: Made trunc IV for type " << *Ty << ": "
|
|
|
|
<< *New << "\n";
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
}
|
2004-04-22 14:59:40 +00:00
|
|
|
}
|
|
|
|
|
2007-01-07 01:14:12 +00:00
|
|
|
// Rewrite all induction variables in terms of the canonical induction
|
|
|
|
// variable.
|
2004-04-02 20:24:31 +00:00
|
|
|
while (!IndVars.empty()) {
|
|
|
|
PHINode *PN = IndVars.back().first;
|
2009-02-17 00:10:53 +00:00
|
|
|
SCEVAddRecExpr *AR = cast<SCEVAddRecExpr>(IndVars.back().second);
|
|
|
|
Value *NewVal = Rewriter.expandCodeFor(AR, InsertPt);
|
|
|
|
DOUT << "INDVARS: Rewrote IV '" << *AR << "' " << *PN
|
2007-01-07 01:14:12 +00:00
|
|
|
<< " into = " << *NewVal << "\n";
|
2007-02-11 01:23:03 +00:00
|
|
|
NewVal->takeName(PN);
|
Implement a fixme. The helps loops that have induction variables of different
types in them. Instead of creating an induction variable for all types, it
creates a single induction variable and casts to the other sizes. This generates
this code:
no_exit: ; preds = %entry, %no_exit
%indvar = phi uint [ %indvar.next, %no_exit ], [ 0, %entry ] ; <uint> [#uses=4]
*** %j.0.0 = cast uint %indvar to short ; <short> [#uses=1]
%indvar = cast uint %indvar to int ; <int> [#uses=1]
%tmp.7 = getelementptr short* %P, uint %indvar ; <short*> [#uses=1]
store short %j.0.0, short* %tmp.7
%inc.0 = add int %indvar, 1 ; <int> [#uses=2]
%tmp.2 = setlt int %inc.0, %N ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1 ; <uint> [#uses=1]
br bool %tmp.2, label %no_exit, label %loopexit
instead of:
no_exit: ; preds = %entry, %no_exit
%indvar = phi ushort [ %indvar.next, %no_exit ], [ 0, %entry ] ; <ushort> [#uses=2]
*** %indvar = phi uint [ %indvar.next, %no_exit ], [ 0, %entry ] ; <uint> [#uses=3]
%indvar = cast uint %indvar to int ; <int> [#uses=1]
%indvar = cast ushort %indvar to short ; <short> [#uses=1]
%tmp.7 = getelementptr short* %P, uint %indvar ; <short*> [#uses=1]
store short %indvar, short* %tmp.7
%inc.0 = add int %indvar, 1 ; <int> [#uses=2]
%tmp.2 = setlt int %inc.0, %N ; <bool> [#uses=1]
%indvar.next = add uint %indvar, 1
*** %indvar.next = add ushort %indvar, 1
br bool %tmp.2, label %no_exit, label %loopexit
This is an improvement in register pressure, but probably doesn't happen that
often.
The more important fix will be to get rid of the redundant add.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@13101 91177308-0d34-0410-b5e6-96231b3b80d8
2004-04-21 22:22:01 +00:00
|
|
|
|
2009-02-12 22:19:27 +00:00
|
|
|
/// If the new canonical induction variable is wider than the original,
|
|
|
|
/// and the original has uses that are casts to wider types, see if the
|
|
|
|
/// truncate and extend can be omitted.
|
2009-02-14 02:31:09 +00:00
|
|
|
if (PN->getType() != LargestType)
|
2009-02-12 22:19:27 +00:00
|
|
|
for (Value::use_iterator UI = PN->use_begin(), UE = PN->use_end();
|
2009-02-14 02:31:09 +00:00
|
|
|
UI != UE; ++UI) {
|
|
|
|
if (isa<SExtInst>(UI) && NoSignedWrap) {
|
|
|
|
SCEVHandle ExtendedStart =
|
2009-02-17 00:10:53 +00:00
|
|
|
SE->getSignExtendExpr(AR->getStart(), LargestType);
|
2009-02-14 02:31:09 +00:00
|
|
|
SCEVHandle ExtendedStep =
|
2009-02-17 00:10:53 +00:00
|
|
|
SE->getSignExtendExpr(AR->getStepRecurrence(*SE), LargestType);
|
2009-02-14 02:31:09 +00:00
|
|
|
SCEVHandle ExtendedAddRec =
|
|
|
|
SE->getAddRecExpr(ExtendedStart, ExtendedStep, L);
|
|
|
|
if (LargestType != UI->getType())
|
|
|
|
ExtendedAddRec = SE->getTruncateExpr(ExtendedAddRec, UI->getType());
|
|
|
|
Value *TruncIndVar = Rewriter.expandCodeFor(ExtendedAddRec, InsertPt);
|
2009-02-12 22:19:27 +00:00
|
|
|
UI->replaceAllUsesWith(TruncIndVar);
|
|
|
|
if (Instruction *DeadUse = dyn_cast<Instruction>(*UI))
|
|
|
|
DeadInsts.insert(DeadUse);
|
|
|
|
}
|
2009-02-14 02:31:09 +00:00
|
|
|
if (isa<ZExtInst>(UI) && NoUnsignedWrap) {
|
|
|
|
SCEVHandle ExtendedStart =
|
2009-02-17 00:10:53 +00:00
|
|
|
SE->getZeroExtendExpr(AR->getStart(), LargestType);
|
2009-02-14 02:31:09 +00:00
|
|
|
SCEVHandle ExtendedStep =
|
2009-02-17 00:10:53 +00:00
|
|
|
SE->getZeroExtendExpr(AR->getStepRecurrence(*SE), LargestType);
|
2009-02-14 02:31:09 +00:00
|
|
|
SCEVHandle ExtendedAddRec =
|
|
|
|
SE->getAddRecExpr(ExtendedStart, ExtendedStep, L);
|
|
|
|
if (LargestType != UI->getType())
|
|
|
|
ExtendedAddRec = SE->getTruncateExpr(ExtendedAddRec, UI->getType());
|
|
|
|
Value *TruncIndVar = Rewriter.expandCodeFor(ExtendedAddRec, InsertPt);
|
|
|
|
UI->replaceAllUsesWith(TruncIndVar);
|
|
|
|
if (Instruction *DeadUse = dyn_cast<Instruction>(*UI))
|
|
|
|
DeadInsts.insert(DeadUse);
|
|
|
|
}
|
|
|
|
}
|
2009-02-12 22:19:27 +00:00
|
|
|
|
2004-04-02 20:24:31 +00:00
|
|
|
// Replace the old PHI Node with the inserted computation.
|
2004-04-22 14:59:40 +00:00
|
|
|
PN->replaceAllUsesWith(NewVal);
|
2004-04-02 20:24:31 +00:00
|
|
|
DeadInsts.insert(PN);
|
|
|
|
IndVars.pop_back();
|
|
|
|
++NumRemoved;
|
|
|
|
Changed = true;
|
2003-12-22 09:53:29 +00:00
|
|
|
}
|
2003-12-10 18:06:47 +00:00
|
|
|
|
2004-04-21 23:36:08 +00:00
|
|
|
DeleteTriviallyDeadInstructions(DeadInsts);
|
2007-03-04 01:00:28 +00:00
|
|
|
assert(L->isLCSSAForm());
|
2007-03-07 06:39:01 +00:00
|
|
|
return Changed;
|
2001-12-03 17:28:42 +00:00
|
|
|
}
|
2008-09-09 21:41:07 +00:00
|
|
|
|
2008-11-18 00:40:02 +00:00
|
|
|
/// Return true if it is OK to use SIToFPInst for an inducation variable
|
|
|
|
/// with given inital and exit values.
|
|
|
|
static bool useSIToFPInst(ConstantFP &InitV, ConstantFP &ExitV,
|
|
|
|
uint64_t intIV, uint64_t intEV) {
|
|
|
|
|
2009-02-17 19:13:57 +00:00
|
|
|
if (InitV.getValueAPF().isNegative() || ExitV.getValueAPF().isNegative())
|
2008-11-18 00:40:02 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// If the iteration range can be handled by SIToFPInst then use it.
|
|
|
|
APInt Max = APInt::getSignedMaxValue(32);
|
2008-11-18 10:57:27 +00:00
|
|
|
if (Max.getZExtValue() > static_cast<uint64_t>(abs(intEV - intIV)))
|
2008-11-18 00:40:02 +00:00
|
|
|
return true;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-18 00:40:02 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// convertToInt - Convert APF to an integer, if possible.
|
2008-11-17 23:27:13 +00:00
|
|
|
static bool convertToInt(const APFloat &APF, uint64_t *intVal) {
|
|
|
|
|
|
|
|
bool isExact = false;
|
2008-11-26 01:11:57 +00:00
|
|
|
if (&APF.getSemantics() == &APFloat::PPCDoubleDouble)
|
|
|
|
return false;
|
2009-02-17 19:13:57 +00:00
|
|
|
if (APF.convertToInteger(intVal, 32, APF.isNegative(),
|
2008-11-17 23:27:13 +00:00
|
|
|
APFloat::rmTowardZero, &isExact)
|
|
|
|
!= APFloat::opOK)
|
|
|
|
return false;
|
2009-02-17 19:13:57 +00:00
|
|
|
if (!isExact)
|
2008-11-17 23:27:13 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-11-03 18:32:19 +00:00
|
|
|
/// HandleFloatingPointIV - If the loop has floating induction variable
|
|
|
|
/// then insert corresponding integer induction variable if possible.
|
2008-11-17 21:32:02 +00:00
|
|
|
/// For example,
|
|
|
|
/// for(double i = 0; i < 10000; ++i)
|
|
|
|
/// bar(i)
|
|
|
|
/// is converted into
|
|
|
|
/// for(int i = 0; i < 10000; ++i)
|
|
|
|
/// bar((double)i);
|
|
|
|
///
|
2009-02-17 19:13:57 +00:00
|
|
|
void IndVarSimplify::HandleFloatingPointIV(Loop *L, PHINode *PH,
|
2008-11-17 21:32:02 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> &DeadInsts) {
|
|
|
|
|
|
|
|
unsigned IncomingEdge = L->contains(PH->getIncomingBlock(0));
|
|
|
|
unsigned BackEdge = IncomingEdge^1;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 21:32:02 +00:00
|
|
|
// Check incoming value.
|
2008-11-17 23:27:13 +00:00
|
|
|
ConstantFP *InitValue = dyn_cast<ConstantFP>(PH->getIncomingValue(IncomingEdge));
|
|
|
|
if (!InitValue) return;
|
|
|
|
uint64_t newInitValue = Type::Int32Ty->getPrimitiveSizeInBits();
|
|
|
|
if (!convertToInt(InitValue->getValueAPF(), &newInitValue))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Check IV increment. Reject this PH if increement operation is not
|
|
|
|
// an add or increment value can not be represented by an integer.
|
2009-02-17 19:13:57 +00:00
|
|
|
BinaryOperator *Incr =
|
2008-11-17 21:32:02 +00:00
|
|
|
dyn_cast<BinaryOperator>(PH->getIncomingValue(BackEdge));
|
|
|
|
if (!Incr) return;
|
|
|
|
if (Incr->getOpcode() != Instruction::Add) return;
|
|
|
|
ConstantFP *IncrValue = NULL;
|
|
|
|
unsigned IncrVIndex = 1;
|
|
|
|
if (Incr->getOperand(1) == PH)
|
|
|
|
IncrVIndex = 0;
|
|
|
|
IncrValue = dyn_cast<ConstantFP>(Incr->getOperand(IncrVIndex));
|
|
|
|
if (!IncrValue) return;
|
2008-11-17 23:27:13 +00:00
|
|
|
uint64_t newIncrValue = Type::Int32Ty->getPrimitiveSizeInBits();
|
|
|
|
if (!convertToInt(IncrValue->getValueAPF(), &newIncrValue))
|
|
|
|
return;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 23:27:13 +00:00
|
|
|
// Check Incr uses. One user is PH and the other users is exit condition used
|
|
|
|
// by the conditional terminator.
|
2008-11-17 21:32:02 +00:00
|
|
|
Value::use_iterator IncrUse = Incr->use_begin();
|
|
|
|
Instruction *U1 = cast<Instruction>(IncrUse++);
|
|
|
|
if (IncrUse == Incr->use_end()) return;
|
|
|
|
Instruction *U2 = cast<Instruction>(IncrUse++);
|
|
|
|
if (IncrUse != Incr->use_end()) return;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 21:32:02 +00:00
|
|
|
// Find exit condition.
|
|
|
|
FCmpInst *EC = dyn_cast<FCmpInst>(U1);
|
|
|
|
if (!EC)
|
|
|
|
EC = dyn_cast<FCmpInst>(U2);
|
|
|
|
if (!EC) return;
|
|
|
|
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(EC->getParent()->getTerminator())) {
|
|
|
|
if (!BI->isConditional()) return;
|
|
|
|
if (BI->getCondition() != EC) return;
|
2008-11-03 18:32:19 +00:00
|
|
|
}
|
2008-11-17 21:32:02 +00:00
|
|
|
|
2008-11-17 23:27:13 +00:00
|
|
|
// Find exit value. If exit value can not be represented as an interger then
|
|
|
|
// do not handle this floating point PH.
|
2008-11-17 21:32:02 +00:00
|
|
|
ConstantFP *EV = NULL;
|
|
|
|
unsigned EVIndex = 1;
|
|
|
|
if (EC->getOperand(1) == Incr)
|
|
|
|
EVIndex = 0;
|
|
|
|
EV = dyn_cast<ConstantFP>(EC->getOperand(EVIndex));
|
|
|
|
if (!EV) return;
|
|
|
|
uint64_t intEV = Type::Int32Ty->getPrimitiveSizeInBits();
|
2008-11-17 23:27:13 +00:00
|
|
|
if (!convertToInt(EV->getValueAPF(), &intEV))
|
2008-11-17 21:32:02 +00:00
|
|
|
return;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 21:32:02 +00:00
|
|
|
// Find new predicate for integer comparison.
|
|
|
|
CmpInst::Predicate NewPred = CmpInst::BAD_ICMP_PREDICATE;
|
|
|
|
switch (EC->getPredicate()) {
|
|
|
|
case CmpInst::FCMP_OEQ:
|
|
|
|
case CmpInst::FCMP_UEQ:
|
|
|
|
NewPred = CmpInst::ICMP_EQ;
|
|
|
|
break;
|
|
|
|
case CmpInst::FCMP_OGT:
|
|
|
|
case CmpInst::FCMP_UGT:
|
|
|
|
NewPred = CmpInst::ICMP_UGT;
|
|
|
|
break;
|
|
|
|
case CmpInst::FCMP_OGE:
|
|
|
|
case CmpInst::FCMP_UGE:
|
|
|
|
NewPred = CmpInst::ICMP_UGE;
|
|
|
|
break;
|
|
|
|
case CmpInst::FCMP_OLT:
|
|
|
|
case CmpInst::FCMP_ULT:
|
|
|
|
NewPred = CmpInst::ICMP_ULT;
|
|
|
|
break;
|
|
|
|
case CmpInst::FCMP_OLE:
|
|
|
|
case CmpInst::FCMP_ULE:
|
|
|
|
NewPred = CmpInst::ICMP_ULE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2008-11-03 18:32:19 +00:00
|
|
|
}
|
2008-11-17 21:32:02 +00:00
|
|
|
if (NewPred == CmpInst::BAD_ICMP_PREDICATE) return;
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 21:32:02 +00:00
|
|
|
// Insert new integer induction variable.
|
|
|
|
PHINode *NewPHI = PHINode::Create(Type::Int32Ty,
|
|
|
|
PH->getName()+".int", PH);
|
2008-11-17 23:27:13 +00:00
|
|
|
NewPHI->addIncoming(ConstantInt::get(Type::Int32Ty, newInitValue),
|
2008-11-17 21:32:02 +00:00
|
|
|
PH->getIncomingBlock(IncomingEdge));
|
|
|
|
|
2009-02-17 19:13:57 +00:00
|
|
|
Value *NewAdd = BinaryOperator::CreateAdd(NewPHI,
|
|
|
|
ConstantInt::get(Type::Int32Ty,
|
2008-11-17 23:27:13 +00:00
|
|
|
newIncrValue),
|
2008-11-17 21:32:02 +00:00
|
|
|
Incr->getName()+".int", Incr);
|
|
|
|
NewPHI->addIncoming(NewAdd, PH->getIncomingBlock(BackEdge));
|
|
|
|
|
|
|
|
ConstantInt *NewEV = ConstantInt::get(Type::Int32Ty, intEV);
|
|
|
|
Value *LHS = (EVIndex == 1 ? NewPHI->getIncomingValue(BackEdge) : NewEV);
|
|
|
|
Value *RHS = (EVIndex == 1 ? NewEV : NewPHI->getIncomingValue(BackEdge));
|
2009-02-17 19:13:57 +00:00
|
|
|
ICmpInst *NewEC = new ICmpInst(NewPred, LHS, RHS, EC->getNameStart(),
|
2008-11-17 21:32:02 +00:00
|
|
|
EC->getParent()->getTerminator());
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 21:32:02 +00:00
|
|
|
// Delete old, floating point, exit comparision instruction.
|
|
|
|
EC->replaceAllUsesWith(NewEC);
|
|
|
|
DeadInsts.insert(EC);
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-17 21:32:02 +00:00
|
|
|
// Delete old, floating point, increment instruction.
|
|
|
|
Incr->replaceAllUsesWith(UndefValue::get(Incr->getType()));
|
|
|
|
DeadInsts.insert(Incr);
|
2009-02-17 19:13:57 +00:00
|
|
|
|
2008-11-18 00:40:02 +00:00
|
|
|
// Replace floating induction variable. Give SIToFPInst preference over
|
|
|
|
// UIToFPInst because it is faster on platforms that are widely used.
|
|
|
|
if (useSIToFPInst(*InitValue, *EV, newInitValue, intEV)) {
|
2009-02-17 19:13:57 +00:00
|
|
|
SIToFPInst *Conv = new SIToFPInst(NewPHI, PH->getType(), "indvar.conv",
|
2008-11-17 23:27:13 +00:00
|
|
|
PH->getParent()->getFirstNonPHI());
|
|
|
|
PH->replaceAllUsesWith(Conv);
|
|
|
|
} else {
|
2009-02-17 19:13:57 +00:00
|
|
|
UIToFPInst *Conv = new UIToFPInst(NewPHI, PH->getType(), "indvar.conv",
|
2008-11-17 23:27:13 +00:00
|
|
|
PH->getParent()->getFirstNonPHI());
|
|
|
|
PH->replaceAllUsesWith(Conv);
|
|
|
|
}
|
2008-11-17 21:32:02 +00:00
|
|
|
DeadInsts.insert(PH);
|
2008-11-03 18:32:19 +00:00
|
|
|
}
|
|
|
|
|