2001-12-04 01:28:42 +08:00
|
|
|
//===- IndVarSimplify.cpp - Induction Variable Elimination ----------------===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-12-04 01:28:42 +08:00
|
|
|
//
|
2004-04-03 04:24:31 +08: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 17:01:07 +08:00
|
|
|
// This transformation makes the following changes to each loop with an
|
2004-04-03 04:24:31 +08: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-04 01:28:42 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-12-20 05:40:18 +08:00
|
|
|
#define DEBUG_TYPE "indvars"
|
2002-05-08 04:03:00 +08:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2004-04-03 04:24:31 +08: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.
llvm-svn: 12961
2004-04-15 23:21:43 +08:00
|
|
|
#include "llvm/Constants.h"
|
2003-12-22 13:02:01 +08:00
|
|
|
#include "llvm/Instructions.h"
|
2004-04-03 04:24:31 +08:00
|
|
|
#include "llvm/Type.h"
|
2005-07-30 08:12:19 +08:00
|
|
|
#include "llvm/Analysis/ScalarEvolutionExpander.h"
|
2003-12-19 01:19:19 +08:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2007-03-07 14:39:01 +08:00
|
|
|
#include "llvm/Analysis/LoopPass.h"
|
2002-02-13 06:39:50 +08:00
|
|
|
#include "llvm/Support/CFG.h"
|
2007-02-06 07:32:05 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2007-01-07 09:14:12 +08: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
llvm-svn: 16924
2004-10-12 07:06:50 +08:00
|
|
|
#include "llvm/Support/GetElementPtrTypeIterator.h"
|
2003-12-19 01:19:19 +08:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2004-09-02 06:55:40 +08: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.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2004-09-02 06:55:40 +08:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2003-12-19 01:19:19 +08:00
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2006-12-20 05:40:18 +08: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 11:58:44 +08:00
|
|
|
|
2006-12-20 05:40:18 +08:00
|
|
|
namespace {
|
2007-03-07 14:39:01 +08:00
|
|
|
class VISIBILITY_HIDDEN IndVarSimplify : public LoopPass {
|
2004-04-03 04:24:31 +08:00
|
|
|
LoopInfo *LI;
|
|
|
|
ScalarEvolution *SE;
|
2003-12-23 15:47:09 +08:00
|
|
|
bool Changed;
|
2003-12-22 11:58:44 +08:00
|
|
|
public:
|
2007-03-07 14:39:01 +08:00
|
|
|
|
|
|
|
bool runOnLoop(Loop *L, LPPassManager &LPM);
|
|
|
|
bool doInitialization(Loop *L, LPPassManager &LPM);
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.addRequiredID(LCSSAID);
|
|
|
|
AU.addRequiredID(LoopSimplifyID);
|
|
|
|
AU.addRequired<ScalarEvolution>();
|
|
|
|
AU.addRequired<LoopInfo>();
|
|
|
|
AU.addPreservedID(LoopSimplifyID);
|
|
|
|
AU.addPreservedID(LCSSAID);
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
}
|
2003-12-22 11:58:44 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
private:
|
2007-03-07 14:39:01 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
void EliminatePointerRecurrence(PHINode *PN, BasicBlock *Preheader,
|
|
|
|
std::set<Instruction*> &DeadInsts);
|
2006-09-21 13:12:20 +08:00
|
|
|
Instruction *LinearFunctionTestReplace(Loop *L, SCEV *IterationCount,
|
|
|
|
SCEVExpander &RW);
|
2004-04-03 04:24:31 +08:00
|
|
|
void RewriteLoopExitValues(Loop *L);
|
|
|
|
|
|
|
|
void DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts);
|
2003-12-22 11:58:44 +08:00
|
|
|
};
|
2006-08-28 06:42:52 +08:00
|
|
|
RegisterPass<IndVarSimplify> X("indvars", "Canonicalize Induction Variables");
|
2002-09-10 13:24:05 +08:00
|
|
|
}
|
2001-12-04 12:32:29 +08:00
|
|
|
|
2007-03-07 14:39:01 +08:00
|
|
|
LoopPass *llvm::createIndVarSimplifyPass() {
|
2003-12-22 11:58:44 +08:00
|
|
|
return new IndVarSimplify();
|
2001-12-04 12:32:29 +08:00
|
|
|
}
|
|
|
|
|
2004-04-03 04:24:31 +08: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::
|
|
|
|
DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts) {
|
|
|
|
while (!Insts.empty()) {
|
|
|
|
Instruction *I = *Insts.begin();
|
|
|
|
Insts.erase(Insts.begin());
|
|
|
|
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);
|
|
|
|
SE->deleteInstructionFromRecords(I);
|
2007-01-07 09:14:12 +08: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
llvm-svn: 16924
2004-10-12 07:06:50 +08:00
|
|
|
I->eraseFromParent();
|
2004-04-03 04:24:31 +08:00
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-12-22 11:58:44 +08:00
|
|
|
|
2001-12-04 01:28:42 +08:00
|
|
|
|
2004-04-03 04:24:31 +08: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-22 07:48:37 +08:00
|
|
|
void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN,
|
2004-04-03 04:24:31 +08:00
|
|
|
BasicBlock *Preheader,
|
|
|
|
std::set<Instruction*> &DeadInsts) {
|
|
|
|
assert(PN->getNumIncomingValues() == 2 && "Noncanonicalized loop!");
|
|
|
|
unsigned PreheaderIdx = PN->getBasicBlockIndex(Preheader);
|
|
|
|
unsigned BackedgeIdx = PreheaderIdx^1;
|
|
|
|
if (GetElementPtrInst *GEPI =
|
2005-08-10 09:12:06 +08:00
|
|
|
dyn_cast<GetElementPtrInst>(PN->getIncomingValue(BackedgeIdx)))
|
2004-04-03 04:24:31 +08:00
|
|
|
if (GEPI->getOperand(0) == PN) {
|
2005-08-10 09:12:06 +08:00
|
|
|
assert(GEPI->getNumOperands() == 2 && "GEP types must match!");
|
2007-01-07 09:14:12 +08:00
|
|
|
DOUT << "INDVARS: Eliminating pointer recurrence: " << *GEPI;
|
|
|
|
|
2004-04-03 04:24:31 +08: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.
|
|
|
|
PHINode *NewPhi = new PHINode(AddedVal->getType(),
|
|
|
|
PN->getName()+".rec", PN);
|
2004-06-20 13:04:01 +08:00
|
|
|
NewPhi->addIncoming(Constant::getNullValue(NewPhi->getType()), Preheader);
|
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// Create the new add instruction.
|
2004-06-20 13:04:01 +08:00
|
|
|
Value *NewAdd = BinaryOperator::createAdd(NewPhi, AddedVal,
|
|
|
|
GEPI->getName()+".rec", GEPI);
|
2004-04-03 04:24:31 +08:00
|
|
|
NewPhi->addIncoming(NewAdd, PN->getIncomingBlock(BackedgeIdx));
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// Update the existing GEP to use the recurrence.
|
|
|
|
GEPI->setOperand(0, PN->getIncomingValue(PreheaderIdx));
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2004-04-03 04:24:31 +08: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
llvm-svn: 16924
2004-10-12 07:06:50 +08: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-19 02:30:47 +08:00
|
|
|
gep_type_iterator GTI = gep_type_begin(CE);
|
2005-11-18 03:35:42 +08: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
llvm-svn: 16924
2004-10-12 07:06:50 +08:00
|
|
|
i != e; ++i, ++GTI)
|
|
|
|
/*empty*/;
|
|
|
|
if (isa<SequentialType>(*GTI)) {
|
|
|
|
// Pull the last index out of the constant expr GEP.
|
2007-01-31 12:40:53 +08: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
llvm-svn: 16924
2004-10-12 07:06:50 +08:00
|
|
|
Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0),
|
2007-01-31 12:40:53 +08:00
|
|
|
&CEIdxs[0],
|
|
|
|
CEIdxs.size());
|
2007-03-02 08:28:52 +08:00
|
|
|
GetElementPtrInst *NGEPI = new GetElementPtrInst(
|
|
|
|
NCE, Constant::getNullValue(Type::Int32Ty), NewAdd,
|
|
|
|
GEPI->getName(), 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
llvm-svn: 16924
2004-10-12 07:06:50 +08:00
|
|
|
GEPI->replaceAllUsesWith(NGEPI);
|
|
|
|
GEPI->eraseFromParent();
|
|
|
|
GEPI = NGEPI;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-04-03 04:24:31 +08: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 =
|
|
|
|
new GetElementPtrInst(PN->getIncomingValue(PreheaderIdx),
|
2007-02-11 09:23:03 +08:00
|
|
|
NewPhi, "", InsertPos);
|
|
|
|
PreInc->takeName(PN);
|
2004-04-03 04:24:31 +08:00
|
|
|
PN->replaceAllUsesWith(PreInc);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delete the old PHI for sure, and the GEP if its otherwise unused.
|
|
|
|
DeadInsts.insert(PN);
|
2003-12-22 11:58:44 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
++NumPointer;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
2003-12-22 11:58:44 +08:00
|
|
|
|
2004-04-03 04:24:31 +08: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.
llvm-svn: 12961
2004-04-15 23:21:43 +08: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.
|
2006-09-21 13:12:20 +08:00
|
|
|
///
|
|
|
|
/// This method returns a "potentially dead" instruction whose computation chain
|
|
|
|
/// should be deleted when convenient.
|
|
|
|
Instruction *IndVarSimplify::LinearFunctionTestReplace(Loop *L,
|
|
|
|
SCEV *IterationCount,
|
|
|
|
SCEVExpander &RW) {
|
2004-04-03 04:24:31 +08:00
|
|
|
// Find the exit block for the loop. We can currently only handle loops with
|
|
|
|
// a single exit.
|
2004-04-19 06:14:10 +08:00
|
|
|
std::vector<BasicBlock*> ExitBlocks;
|
|
|
|
L->getExitBlocks(ExitBlocks);
|
2006-09-21 13:12:20 +08:00
|
|
|
if (ExitBlocks.size() != 1) return 0;
|
2004-04-19 06:14:10 +08:00
|
|
|
BasicBlock *ExitBlock = ExitBlocks[0];
|
2004-04-03 04:24:31 +08:00
|
|
|
|
|
|
|
// Make sure there is only one predecessor block in the loop.
|
|
|
|
BasicBlock *ExitingBlock = 0;
|
|
|
|
for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
|
|
|
|
PI != PE; ++PI)
|
|
|
|
if (L->contains(*PI)) {
|
|
|
|
if (ExitingBlock == 0)
|
|
|
|
ExitingBlock = *PI;
|
|
|
|
else
|
2006-09-21 13:12:20 +08:00
|
|
|
return 0; // Multiple exits from loop to this block.
|
2004-04-03 04:24:31 +08:00
|
|
|
}
|
|
|
|
assert(ExitingBlock && "Loop info is broken");
|
|
|
|
|
|
|
|
if (!isa<BranchInst>(ExitingBlock->getTerminator()))
|
2006-09-21 13:12:20 +08:00
|
|
|
return 0; // Can't rewrite non-branch yet
|
2004-04-03 04:24:31 +08:00
|
|
|
BranchInst *BI = cast<BranchInst>(ExitingBlock->getTerminator());
|
|
|
|
assert(BI->isConditional() && "Must be conditional to be part of loop!");
|
|
|
|
|
2006-09-21 13:12:20 +08:00
|
|
|
Instruction *PotentiallyDeadInst = dyn_cast<Instruction>(BI->getCondition());
|
|
|
|
|
2004-04-16 04:26:22 +08: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.
|
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
pred_iterator HPI = pred_begin(Header);
|
|
|
|
assert(HPI != pred_end(Header) && "Loop with zero preds???");
|
|
|
|
if (!L->contains(*HPI)) ++HPI;
|
|
|
|
assert(HPI != pred_end(Header) && L->contains(*HPI) &&
|
|
|
|
"No backedge in loop?");
|
|
|
|
|
|
|
|
SCEVHandle TripCount = IterationCount;
|
|
|
|
Value *IndVar;
|
|
|
|
if (*HPI == ExitingBlock) {
|
|
|
|
// 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.
|
|
|
|
Constant *OneC = ConstantInt::get(IterationCount->getType(), 1);
|
|
|
|
TripCount = SCEVAddExpr::get(IterationCount, SCEVUnknown::get(OneC));
|
|
|
|
IndVar = L->getCanonicalInductionVariableIncrement();
|
|
|
|
} else {
|
|
|
|
// We have to use the preincremented value...
|
|
|
|
IndVar = L->getCanonicalInductionVariable();
|
|
|
|
}
|
2007-01-07 09:14:12 +08:00
|
|
|
|
|
|
|
DOUT << "INDVARS: LFTR: TripCount = " << *TripCount
|
|
|
|
<< " IndVar = " << *IndVar << "\n";
|
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.
llvm-svn: 12961
2004-04-15 23:21:43 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// Expand the code for the iteration count into the preheader of the loop.
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
2004-04-24 05:29:48 +08:00
|
|
|
Value *ExitCnt = RW.expandCodeFor(TripCount, Preheader->getTerminator(),
|
2004-04-03 04:24:31 +08:00
|
|
|
IndVar->getType());
|
|
|
|
|
2006-12-23 14:05:41 +08:00
|
|
|
// Insert a new icmp_ne or icmp_eq instruction before the branch.
|
|
|
|
ICmpInst::Predicate Opcode;
|
2004-04-03 04:24:31 +08:00
|
|
|
if (L->contains(BI->getSuccessor(0)))
|
2006-12-23 14:05:41 +08:00
|
|
|
Opcode = ICmpInst::ICMP_NE;
|
2004-04-03 04:24:31 +08:00
|
|
|
else
|
2006-12-23 14:05:41 +08:00
|
|
|
Opcode = ICmpInst::ICMP_EQ;
|
2004-04-03 04:24:31 +08:00
|
|
|
|
2006-12-23 14:05:41 +08:00
|
|
|
Value *Cond = new ICmpInst(Opcode, IndVar, ExitCnt, "exitcond", BI);
|
2004-04-03 04:24:31 +08:00
|
|
|
BI->setCondition(Cond);
|
|
|
|
++NumLFTR;
|
|
|
|
Changed = true;
|
2006-09-21 13:12:20 +08:00
|
|
|
return PotentiallyDeadInst;
|
2004-04-03 04:24:31 +08:00
|
|
|
}
|
2003-12-22 11:58:44 +08:00
|
|
|
|
|
|
|
|
2004-04-03 04:24:31 +08: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.
|
|
|
|
void IndVarSimplify::RewriteLoopExitValues(Loop *L) {
|
|
|
|
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-24 05:29:48 +08:00
|
|
|
SCEVExpander Rewriter(*SE, *LI);
|
2004-04-03 04:24:31 +08: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;
|
2004-04-19 06:14:10 +08:00
|
|
|
std::vector<BasicBlock*> ExitBlocks;
|
2007-03-04 11:43:23 +08:00
|
|
|
L->getUniqueExitBlocks(ExitBlocks);
|
2004-04-19 06:14:10 +08:00
|
|
|
if (ExitBlocks.size() == 1)
|
|
|
|
BlockToInsertInto = ExitBlocks[0];
|
2004-04-03 04:24:31 +08:00
|
|
|
else
|
|
|
|
BlockToInsertInto = Preheader;
|
|
|
|
BasicBlock::iterator InsertPt = BlockToInsertInto->begin();
|
|
|
|
while (isa<PHINode>(InsertPt)) ++InsertPt;
|
|
|
|
|
2004-04-18 02:44:09 +08:00
|
|
|
bool HasConstantItCount = isa<SCEVConstant>(SE->getIterationCount(L));
|
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
std::set<Instruction*> InstructionsToDelete;
|
2007-03-04 11:43:23 +08: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];
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
|
|
|
unsigned NumPreds = PN->getNumIncomingValues();
|
|
|
|
|
|
|
|
// Iterate over all of the PHI nodes.
|
|
|
|
BasicBlock::iterator BBI = ExitBB->begin();
|
|
|
|
while ((PN = dyn_cast<PHINode>(BBI++))) {
|
2007-03-04 06:48:48 +08:00
|
|
|
|
2007-03-04 11:43:23 +08: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.
|
|
|
|
if (LI->getLoopFor(PN->getIncomingBlock(i)) != L)
|
|
|
|
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;
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
// 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;
|
2007-03-04 09:00:28 +08:00
|
|
|
|
2007-03-04 11:43:23 +08:00
|
|
|
// See if we already computed the exit value for the instruction, if so,
|
|
|
|
// just reuse it.
|
|
|
|
Value *&ExitVal = ExitValues[Inst];
|
|
|
|
if (!ExitVal)
|
|
|
|
ExitVal = Rewriter.expandCodeFor(ExitValue, InsertPt,Inst->getType());
|
|
|
|
|
|
|
|
DOUT << "INDVARS: RLEV: AfterLoopVal = " << *ExitVal
|
|
|
|
<< " LoopVal = " << *Inst << "\n";
|
2007-03-04 09:00:28 +08:00
|
|
|
|
2007-03-04 11:43:23 +08:00
|
|
|
PN->setIncomingValue(i, ExitVal);
|
|
|
|
|
|
|
|
// If this instruction is dead now, schedule it to be removed.
|
|
|
|
if (Inst->use_empty())
|
|
|
|
InstructionsToDelete.insert(Inst);
|
|
|
|
|
|
|
|
// See if this is a single-entry LCSSA PHI node. If so, we can (and
|
|
|
|
// have to) remove
|
2007-03-04 09:00:28 +08: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 11:43:23 +08:00
|
|
|
if (NumPreds == 1) {
|
|
|
|
PN->replaceAllUsesWith(ExitVal);
|
|
|
|
PN->eraseFromParent();
|
|
|
|
break;
|
2007-03-04 06:48:48 +08:00
|
|
|
}
|
2005-06-16 05:29:31 +08:00
|
|
|
}
|
2007-03-04 06:48:48 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
DeleteTriviallyDeadInstructions(InstructionsToDelete);
|
|
|
|
}
|
2003-12-23 15:47:09 +08:00
|
|
|
|
2007-03-07 14:39:01 +08:00
|
|
|
bool IndVarSimplify::doInitialization(Loop *L, LPPassManager &LPM) {
|
2003-12-23 15:47:09 +08:00
|
|
|
|
2007-03-07 14:39:01 +08:00
|
|
|
Changed = false;
|
2004-04-03 04:24:31 +08: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 15:47:09 +08:00
|
|
|
//
|
2004-04-03 04:24:31 +08:00
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
2007-03-07 14:39:01 +08:00
|
|
|
SE = &LPM.getAnalysis<ScalarEvolution>();
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
std::set<Instruction*> DeadInsts;
|
2004-09-16 01:06:42 +08:00
|
|
|
for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2004-04-03 04:24:31 +08:00
|
|
|
if (isa<PointerType>(PN->getType()))
|
|
|
|
EliminatePointerRecurrence(PN, Preheader, DeadInsts);
|
2004-09-16 01:06:42 +08:00
|
|
|
}
|
2003-12-23 15:47:09 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
if (!DeadInsts.empty())
|
|
|
|
DeleteTriviallyDeadInstructions(DeadInsts);
|
2001-12-04 12:32:29 +08:00
|
|
|
|
2007-03-07 14:39:01 +08:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IndVarSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
|
|
|
|
|
2001-12-04 12:32:29 +08:00
|
|
|
|
2007-03-07 14:39:01 +08:00
|
|
|
LI = &getAnalysis<LoopInfo>();
|
|
|
|
SE = &getAnalysis<ScalarEvolution>();
|
2001-12-04 12:32:29 +08:00
|
|
|
|
2007-03-07 14:39:01 +08:00
|
|
|
Changed = false;
|
|
|
|
BasicBlock *Header = L->getHeader();
|
|
|
|
std::set<Instruction*> DeadInsts;
|
|
|
|
|
2007-03-04 09:00:28 +08:00
|
|
|
// Verify the input to the pass in already in LCSSA form.
|
|
|
|
assert(L->isLCSSAForm());
|
|
|
|
|
2004-04-03 04:24:31 +08: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 12:32:29 +08:00
|
|
|
//
|
2004-04-03 04:24:31 +08:00
|
|
|
SCEVHandle IterationCount = SE->getIterationCount(L);
|
|
|
|
if (!isa<SCEVCouldNotCompute>(IterationCount))
|
|
|
|
RewriteLoopExitValues(L);
|
|
|
|
|
|
|
|
// Next, analyze all of the induction variables in the loop, canonicalizing
|
|
|
|
// auxillary induction variables.
|
|
|
|
std::vector<std::pair<PHINode*, SCEVHandle> > IndVars;
|
|
|
|
|
2004-09-16 01:06:42 +08:00
|
|
|
for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
2007-01-15 10:27:26 +08:00
|
|
|
if (PN->getType()->isInteger()) { // FIXME: when we have fast-math, enable!
|
2004-04-03 04:24:31 +08:00
|
|
|
SCEVHandle SCEV = SE->getSCEV(PN);
|
|
|
|
if (SCEV->hasComputableLoopEvolution(L))
|
2005-08-10 09:12:06 +08: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.
|
2004-07-26 10:47:12 +08:00
|
|
|
if (SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(SCEV))
|
2005-08-10 09:12:06 +08:00
|
|
|
if (AR->isAffine())
|
2004-07-26 10:47:12 +08:00
|
|
|
IndVars.push_back(std::make_pair(PN, SCEV));
|
2004-04-03 04:24:31 +08:00
|
|
|
}
|
2004-09-16 01:06:42 +08:00
|
|
|
}
|
2002-05-23 01:17:27 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// If there are no induction variables in the loop, there is nothing more to
|
|
|
|
// do.
|
2004-04-18 02:08:33 +08:00
|
|
|
if (IndVars.empty()) {
|
|
|
|
// Actually, if we know how many times the loop iterates, lets insert a
|
|
|
|
// canonical induction variable to help subsequent passes.
|
|
|
|
if (!isa<SCEVCouldNotCompute>(IterationCount)) {
|
2004-04-24 05:29:48 +08:00
|
|
|
SCEVExpander Rewriter(*SE, *LI);
|
|
|
|
Rewriter.getOrInsertCanonicalInductionVariable(L,
|
2004-04-18 02:08:33 +08:00
|
|
|
IterationCount->getType());
|
2006-09-21 13:12:20 +08:00
|
|
|
if (Instruction *I = LinearFunctionTestReplace(L, IterationCount,
|
|
|
|
Rewriter)) {
|
|
|
|
std::set<Instruction*> InstructionsToDelete;
|
|
|
|
InstructionsToDelete.insert(I);
|
|
|
|
DeleteTriviallyDeadInstructions(InstructionsToDelete);
|
|
|
|
}
|
2004-04-18 02:08:33 +08:00
|
|
|
}
|
2007-03-07 14:39:01 +08:00
|
|
|
return Changed;
|
2004-04-18 02:08:33 +08:00
|
|
|
}
|
2002-05-23 01:17:27 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// Compute the type of the largest recurrence expression.
|
|
|
|
//
|
|
|
|
const Type *LargestType = IndVars[0].first->getType();
|
2004-04-22 22:59:40 +08:00
|
|
|
bool DifferingSizes = false;
|
2004-04-03 04:24:31 +08:00
|
|
|
for (unsigned i = 1, e = IndVars.size(); i != e; ++i) {
|
|
|
|
const Type *Ty = IndVars[i].first->getType();
|
2007-01-09 00:32:00 +08:00
|
|
|
DifferingSizes |=
|
|
|
|
Ty->getPrimitiveSizeInBits() != LargestType->getPrimitiveSizeInBits();
|
|
|
|
if (Ty->getPrimitiveSizeInBits() > LargestType->getPrimitiveSizeInBits())
|
2004-04-03 04:24:31 +08:00
|
|
|
LargestType = Ty;
|
2003-12-22 17:53:29 +08:00
|
|
|
}
|
2001-12-04 12:32:29 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// Create a rewriter object which we'll use to transform the code with.
|
2004-04-24 05:29:48 +08:00
|
|
|
SCEVExpander Rewriter(*SE, *LI);
|
2004-04-03 04:24:31 +08:00
|
|
|
|
|
|
|
// Now that we know the largest of of the induction variables in this loop,
|
|
|
|
// insert a canonical induction variable of the largest size.
|
2004-04-24 05:29:48 +08:00
|
|
|
Value *IndVar = Rewriter.getOrInsertCanonicalInductionVariable(L,LargestType);
|
2004-04-03 04:24:31 +08:00
|
|
|
++NumInserted;
|
|
|
|
Changed = true;
|
2007-01-07 09:14:12 +08:00
|
|
|
DOUT << "INDVARS: New CanIV: " << *IndVar;
|
2004-04-03 04:24:31 +08:00
|
|
|
|
|
|
|
if (!isa<SCEVCouldNotCompute>(IterationCount))
|
2006-09-21 13:12:20 +08:00
|
|
|
if (Instruction *DI = LinearFunctionTestReplace(L, IterationCount,Rewriter))
|
|
|
|
DeadInsts.insert(DI);
|
2004-04-03 04:24:31 +08: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.
|
|
|
|
BasicBlock::iterator InsertPt = Header->begin();
|
|
|
|
while (isa<PHINode>(InsertPt)) ++InsertPt;
|
|
|
|
|
2004-04-22 22:59:40 +08: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.
|
|
|
|
if (DifferingSizes) {
|
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.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
SmallVector<unsigned,4> InsertedSizes;
|
|
|
|
InsertedSizes.push_back(LargestType->getPrimitiveSizeInBits());
|
|
|
|
for (unsigned i = 0, e = IndVars.size(); i != e; ++i) {
|
|
|
|
unsigned ithSize = IndVars[i].first->getType()->getPrimitiveSizeInBits();
|
2007-01-13 06:51:20 +08:00
|
|
|
if (std::find(InsertedSizes.begin(), InsertedSizes.end(), ithSize)
|
|
|
|
== InsertedSizes.end()) {
|
2004-04-22 22:59:40 +08:00
|
|
|
PHINode *PN = IndVars[i].first;
|
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.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
InsertedSizes.push_back(ithSize);
|
2007-01-07 09:14:12 +08:00
|
|
|
Instruction *New = new TruncInst(IndVar, PN->getType(), "indvar",
|
|
|
|
InsertPt);
|
2004-04-22 22:59:40 +08:00
|
|
|
Rewriter.addInsertedValue(New, SE->getSCEV(New));
|
2007-01-07 09:14:12 +08:00
|
|
|
DOUT << "INDVARS: Made trunc IV for " << *PN
|
|
|
|
<< " NewVal = " << *New << "\n";
|
2004-04-22 22:59:40 +08:00
|
|
|
}
|
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.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
}
|
2004-04-22 22:59:40 +08:00
|
|
|
}
|
|
|
|
|
2007-01-07 09:14:12 +08:00
|
|
|
// Rewrite all induction variables in terms of the canonical induction
|
|
|
|
// variable.
|
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.
llvm-svn: 13101
2004-04-22 06:22:01 +08:00
|
|
|
std::map<unsigned, Value*> InsertedSizes;
|
2004-04-03 04:24:31 +08:00
|
|
|
while (!IndVars.empty()) {
|
|
|
|
PHINode *PN = IndVars.back().first;
|
2004-04-24 05:29:48 +08:00
|
|
|
Value *NewVal = Rewriter.expandCodeFor(IndVars.back().second, InsertPt,
|
2004-04-22 22:59:40 +08:00
|
|
|
PN->getType());
|
2007-01-07 09:14:12 +08:00
|
|
|
DOUT << "INDVARS: Rewrote IV '" << *IndVars.back().second << "' " << *PN
|
|
|
|
<< " into = " << *NewVal << "\n";
|
2007-02-11 09:23:03 +08: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.
llvm-svn: 13101
2004-04-22 06:22:01 +08:00
|
|
|
|
2004-04-03 04:24:31 +08:00
|
|
|
// Replace the old PHI Node with the inserted computation.
|
2004-04-22 22:59:40 +08:00
|
|
|
PN->replaceAllUsesWith(NewVal);
|
2004-04-03 04:24:31 +08:00
|
|
|
DeadInsts.insert(PN);
|
|
|
|
IndVars.pop_back();
|
|
|
|
++NumRemoved;
|
|
|
|
Changed = true;
|
2003-12-22 17:53:29 +08:00
|
|
|
}
|
2003-12-11 02:06:47 +08:00
|
|
|
|
2004-04-22 23:12:36 +08:00
|
|
|
#if 0
|
2004-04-22 07:36:08 +08:00
|
|
|
// Now replace all derived expressions in the loop body with simpler
|
|
|
|
// expressions.
|
2004-04-03 04:24:31 +08:00
|
|
|
for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i)
|
|
|
|
if (LI->getLoopFor(L->getBlocks()[i]) == L) { // Not in a subloop...
|
|
|
|
BasicBlock *BB = L->getBlocks()[i];
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
|
2007-01-15 10:27:26 +08:00
|
|
|
if (I->getType()->isInteger() && // Is an integer instruction
|
2004-04-22 07:36:08 +08:00
|
|
|
!I->use_empty() &&
|
2004-04-03 04:24:31 +08:00
|
|
|
!Rewriter.isInsertedInstruction(I)) {
|
|
|
|
SCEVHandle SH = SE->getSCEV(I);
|
2004-04-24 05:29:48 +08:00
|
|
|
Value *V = Rewriter.expandCodeFor(SH, I, I->getType());
|
2004-04-22 07:36:08 +08:00
|
|
|
if (V != I) {
|
2007-02-11 09:23:03 +08:00
|
|
|
if (isa<Instruction>(V))
|
|
|
|
V->takeName(I);
|
2004-04-22 07:36:08 +08:00
|
|
|
I->replaceAllUsesWith(V);
|
|
|
|
DeadInsts.insert(I);
|
|
|
|
++NumRemoved;
|
|
|
|
Changed = true;
|
2005-04-22 07:48:37 +08:00
|
|
|
}
|
2004-04-03 04:24:31 +08:00
|
|
|
}
|
2001-12-04 12:32:29 +08:00
|
|
|
}
|
2004-04-22 23:12:36 +08:00
|
|
|
#endif
|
2004-04-22 07:36:08 +08:00
|
|
|
|
|
|
|
DeleteTriviallyDeadInstructions(DeadInsts);
|
2006-08-26 06:12:36 +08:00
|
|
|
|
2007-03-04 09:00:28 +08:00
|
|
|
assert(L->isLCSSAForm());
|
2007-03-07 14:39:01 +08:00
|
|
|
return Changed;
|
2001-12-04 01:28:42 +08:00
|
|
|
}
|