X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FTransforms%2FScalar%2FIndVarSimplify.cpp;h=ed377658932cde2d9b957d59a19d500131456035;hp=c7262a0fb5a1ebd92552c424362f2e3735503dde;hb=7cbd8a3e92221437048b484d5ef9c0a22d0f8c58;hpb=3e15bf33e024b9df9e89351a165acfdb1dde51ed diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index c7262a0fb5a..ed377658932 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -2,8 +2,8 @@ // // 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. // //===----------------------------------------------------------------------===// // @@ -69,15 +69,15 @@ namespace { bool Changed; public: - static const char 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(); AU.addRequiredID(LCSSAID); AU.addRequiredID(LoopSimplifyID); - AU.addRequired(); AU.addRequired(); AU.addPreservedID(LoopSimplifyID); AU.addPreservedID(LCSSAID); @@ -94,11 +94,12 @@ namespace { void DeleteTriviallyDeadInstructions(std::set &Insts); }; - - const char IndVarSimplify::ID = 0; - RegisterPass X("indvars", "Canonicalize Induction Variables"); } +char IndVarSimplify::ID = 0; +static RegisterPass +X("indvars", "Canonicalize Induction Variables"); + LoopPass *llvm::createIndVarSimplifyPass() { return new IndVarSimplify(); } @@ -115,7 +116,7 @@ DeleteTriviallyDeadInstructions(std::set &Insts) { for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) if (Instruction *U = dyn_cast(I->getOperand(i))) Insts.insert(U); - SE->deleteInstructionFromRecords(I); + SE->deleteValueFromRecords(I); DOUT << "INDVARS: Deleting: " << *I; I->eraseFromParent(); Changed = true; @@ -145,12 +146,12 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, 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. - Value *NewAdd = BinaryOperator::createAdd(NewPhi, AddedVal, + Value *NewAdd = BinaryOperator::CreateAdd(NewPhi, AddedVal, GEPI->getName()+".rec", GEPI); NewPhi->addIncoming(NewAdd, PN->getIncomingBlock(BackedgeIdx)); @@ -178,9 +179,13 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, 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; @@ -196,8 +201,8 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, BasicBlock::iterator InsertPos = PN; ++InsertPos; while (isa(InsertPos)) ++InsertPos; Value *PreInc = - new GetElementPtrInst(PN->getIncomingValue(PreheaderIdx), - NewPhi, "", InsertPos); + GetElementPtrInst::Create(PN->getIncomingValue(PreheaderIdx), + NewPhi, "", InsertPos); PreInc->takeName(PN); PN->replaceAllUsesWith(PreInc); } @@ -223,7 +228,7 @@ Instruction *IndVarSimplify::LinearFunctionTestReplace(Loop *L, SCEVExpander &RW) { // Find the exit block for the loop. We can currently only handle loops with // a single exit. - std::vector ExitBlocks; + SmallVector ExitBlocks; L->getExitBlocks(ExitBlocks); if (ExitBlocks.size() != 1) return 0; BasicBlock *ExitBlock = ExitBlocks[0]; @@ -263,8 +268,8 @@ Instruction *IndVarSimplify::LinearFunctionTestReplace(Loop *L, // 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... @@ -276,8 +281,7 @@ Instruction *IndVarSimplify::LinearFunctionTestReplace(Loop *L, // 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; @@ -309,7 +313,7 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L) { // 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 ExitBlocks; + SmallVector ExitBlocks; L->getUniqueExitBlocks(ExitBlocks); if (ExitBlocks.size() == 1) BlockToInsertInto = ExitBlocks[0]; @@ -382,7 +386,7 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L) { // 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"; @@ -398,6 +402,7 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L) { // 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; @@ -517,9 +522,15 @@ bool IndVarSimplify::runOnLoop(Loop *L, LPPassManager &LPM) { Changed = true; DOUT << "INDVARS: New CanIV: " << *IndVar; - if (!isa(IterationCount)) + if (!isa(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 @@ -553,8 +564,7 @@ bool IndVarSimplify::runOnLoop(Loop *L, LPPassManager &LPM) { std::map 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);