//
// 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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
bool Changed;
public:
- static const int ID; // Pass identifcation, replacement for typeid
+ static char ID; // Pass identification, replacement for typeid
IndVarSimplify() : LoopPass((intptr_t)&ID) {}
bool runOnLoop(Loop *L, LPPassManager &LPM);
bool doInitialization(Loop *L, LPPassManager &LPM);
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequired<ScalarEvolution>();
AU.addRequiredID(LCSSAID);
AU.addRequiredID(LoopSimplifyID);
- AU.addRequired<ScalarEvolution>();
AU.addRequired<LoopInfo>();
AU.addPreservedID(LoopSimplifyID);
AU.addPreservedID(LCSSAID);
void DeleteTriviallyDeadInstructions(std::set<Instruction*> &Insts);
};
-
- const int IndVarSimplify::ID = 0;
- RegisterPass<IndVarSimplify> X("indvars", "Canonicalize Induction Variables");
}
+char IndVarSimplify::ID = 0;
+static RegisterPass<IndVarSimplify>
+X("indvars", "Canonicalize Induction Variables");
+
LoopPass *llvm::createIndVarSimplifyPass() {
return new IndVarSimplify();
}
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);
+ SE->deleteValueFromRecords(I);
DOUT << "INDVARS: Deleting: " << *I;
I->eraseFromParent();
Changed = true;
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);
+ PHINode *NewPhi = PHINode::Create(AddedVal->getType(),
+ PN->getName()+".rec", PN);
NewPhi->addIncoming(Constant::getNullValue(NewPhi->getType()), Preheader);
// Create the new add instruction.
Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0),
&CEIdxs[0],
CEIdxs.size());
- GetElementPtrInst *NGEPI = new GetElementPtrInst(
- NCE, Constant::getNullValue(Type::Int32Ty), NewAdd,
+ Value *Idx[2];
+ Idx[0] = Constant::getNullValue(Type::Int32Ty);
+ Idx[1] = NewAdd;
+ GetElementPtrInst *NGEPI = GetElementPtrInst::Create(
+ NCE, Idx, Idx + 2,
GEPI->getName(), GEPI);
+ SE->deleteValueFromRecords(GEPI);
GEPI->replaceAllUsesWith(NGEPI);
GEPI->eraseFromParent();
GEPI = NGEPI;
BasicBlock::iterator InsertPos = PN; ++InsertPos;
while (isa<PHINode>(InsertPos)) ++InsertPos;
Value *PreInc =
- new GetElementPtrInst(PN->getIncomingValue(PreheaderIdx),
- NewPhi, "", InsertPos);
+ GetElementPtrInst::Create(PN->getIncomingValue(PreheaderIdx),
+ NewPhi, "", InsertPos);
PreInc->takeName(PN);
PN->replaceAllUsesWith(PreInc);
}
SCEVExpander &RW) {
// Find the exit block for the loop. We can currently only handle loops with
// a single exit.
- std::vector<BasicBlock*> ExitBlocks;
+ SmallVector<BasicBlock*, 8> ExitBlocks;
L->getExitBlocks(ExitBlocks);
if (ExitBlocks.size() != 1) return 0;
BasicBlock *ExitBlock = ExitBlocks[0];
// 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));
+ ConstantInt *OneC = ConstantInt::get(IterationCount->getType(), 1);
+ TripCount = SE->getAddExpr(IterationCount, SE->getConstant(OneC));
IndVar = L->getCanonicalInductionVariableIncrement();
} else {
// We have to use the preincremented value...
// Expand the code for the iteration count into the preheader of the loop.
BasicBlock *Preheader = L->getLoopPreheader();
- Value *ExitCnt = RW.expandCodeFor(TripCount, Preheader->getTerminator(),
- IndVar->getType());
+ Value *ExitCnt = RW.expandCodeFor(TripCount, Preheader->getTerminator());
// Insert a new icmp_ne or icmp_eq instruction before the branch.
ICmpInst::Predicate Opcode;
// 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;
- std::vector<BasicBlock*> ExitBlocks;
+ SmallVector<BasicBlock*, 8> ExitBlocks;
L->getUniqueExitBlocks(ExitBlocks);
if (ExitBlocks.size() == 1)
BlockToInsertInto = ExitBlocks[0];
// just reuse it.
Value *&ExitVal = ExitValues[Inst];
if (!ExitVal)
- ExitVal = Rewriter.expandCodeFor(ExitValue, InsertPt,Inst->getType());
+ ExitVal = Rewriter.expandCodeFor(ExitValue, InsertPt);
DOUT << "INDVARS: RLEV: AfterLoopVal = " << *ExitVal
<< " LoopVal = " << *Inst << "\n";
// 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.
if (NumPreds == 1) {
+ SE->deleteValueFromRecords(PN);
PN->replaceAllUsesWith(ExitVal);
PN->eraseFromParent();
break;
Changed = true;
DOUT << "INDVARS: New CanIV: " << *IndVar;
- if (!isa<SCEVCouldNotCompute>(IterationCount))
+ if (!isa<SCEVCouldNotCompute>(IterationCount)) {
+ if (IterationCount->getType()->getPrimitiveSizeInBits() <
+ LargestType->getPrimitiveSizeInBits())
+ IterationCount = SE->getZeroExtendExpr(IterationCount, LargestType);
+ else if (IterationCount->getType() != LargestType)
+ IterationCount = SE->getTruncateExpr(IterationCount, LargestType);
if (Instruction *DI = LinearFunctionTestReplace(L, IterationCount,Rewriter))
DeadInsts.insert(DI);
+ }
// Now that we have a canonical induction variable, we can rewrite any
// recurrences in terms of the induction variable. Start with the auxillary
std::map<unsigned, Value*> InsertedSizes;
while (!IndVars.empty()) {
PHINode *PN = IndVars.back().first;
- Value *NewVal = Rewriter.expandCodeFor(IndVars.back().second, InsertPt,
- PN->getType());
+ Value *NewVal = Rewriter.expandCodeFor(IndVars.back().second, InsertPt);
DOUT << "INDVARS: Rewrote IV '" << *IndVars.back().second << "' " << *PN
<< " into = " << *NewVal << "\n";
NewVal->takeName(PN);