From: Chris Lattner Date: Sun, 29 Aug 2010 04:23:04 +0000 (+0000) Subject: modernize this pass a bit: use efficient set/map and reduce indentation. X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=dc1ceb370a99f7035f644c081bad14c2003b9381;p=oota-llvm.git modernize this pass a bit: use efficient set/map and reduce indentation. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@112404 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp index 964a3b2a9a5..bb253550b6a 100644 --- a/lib/Transforms/Scalar/LICM.cpp +++ b/lib/Transforms/Scalar/LICM.cpp @@ -217,7 +217,7 @@ namespace { /// void FindPromotableValuesInLoop( std::vector > &PromotedValues, - std::map &Val2AlMap); + DenseMap &Val2AlMap); }; } @@ -520,21 +520,22 @@ void LICM::sink(Instruction &I) { if (PHINode *UPN = dyn_cast(U)) { // Only insert into each predecessor once, so that we don't have // different incoming values from the same block! - std::map InsertedBlocks; - for (unsigned i = 0, e = UPN->getNumIncomingValues(); i != e; ++i) - if (UPN->getIncomingValue(i) == &I) { - BasicBlock *Pred = UPN->getIncomingBlock(i); - Value *&PredVal = InsertedBlocks[Pred]; - if (!PredVal) { - // Insert a new load instruction right before the terminator in - // the predecessor block. - PredVal = new LoadInst(AI, "", Pred->getTerminator()); - CurAST->add(cast(PredVal)); - } - - UPN->setIncomingValue(i, PredVal); + DenseMap InsertedBlocks; + for (unsigned i = 0, e = UPN->getNumIncomingValues(); i != e; ++i) { + if (UPN->getIncomingValue(i) != &I) continue; + + BasicBlock *Pred = UPN->getIncomingBlock(i); + Value *&PredVal = InsertedBlocks[Pred]; + if (!PredVal) { + // Insert a new load instruction right before the terminator in + // the predecessor block. + PredVal = new LoadInst(AI, "", Pred->getTerminator()); + CurAST->add(cast(PredVal)); } + UPN->setIncomingValue(i, PredVal); + } + } else { LoadInst *L = new LoadInst(AI, "", U); U->replaceUsesOfWith(&I, L); @@ -546,38 +547,40 @@ void LICM::sink(Instruction &I) { // that is dominated by the instruction, storing the result into the memory // location. Be careful not to insert the instruction into any particular // basic block more than once. - std::set InsertedBlocks; + SmallPtrSet InsertedBlocks; BasicBlock *InstOrigBB = I.getParent(); for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) { BasicBlock *ExitBlock = ExitBlocks[i]; - if (isExitBlockDominatedByBlockInLoop(ExitBlock, InstOrigBB)) { - // If we haven't already processed this exit block, do so now. - if (InsertedBlocks.insert(ExitBlock).second) { - // Insert the code after the last PHI node... - BasicBlock::iterator InsertPt = ExitBlock->getFirstNonPHI(); - - // If this is the first exit block processed, just move the original - // instruction, otherwise clone the original instruction and insert - // the copy. - Instruction *New; - if (InsertedBlocks.size() == 1) { - I.removeFromParent(); - ExitBlock->getInstList().insert(InsertPt, &I); - New = &I; - } else { - New = I.clone(); - CurAST->copyValue(&I, New); - if (!I.getName().empty()) - New->setName(I.getName()+".le"); - ExitBlock->getInstList().insert(InsertPt, New); - } - - // Now that we have inserted the instruction, store it into the alloca - if (AI) new StoreInst(New, AI, InsertPt); - } + if (!isExitBlockDominatedByBlockInLoop(ExitBlock, InstOrigBB)) + continue; + + // If we haven't already processed this exit block, do so now. + if (!InsertedBlocks.insert(ExitBlock)) + continue; + + // Insert the code after the last PHI node... + BasicBlock::iterator InsertPt = ExitBlock->getFirstNonPHI(); + + // If this is the first exit block processed, just move the original + // instruction, otherwise clone the original instruction and insert + // the copy. + Instruction *New; + if (InsertedBlocks.size() == 1) { + I.removeFromParent(); + ExitBlock->getInstList().insert(InsertPt, &I); + New = &I; + } else { + New = I.clone(); + CurAST->copyValue(&I, New); + if (!I.getName().empty()) + New->setName(I.getName()+".le"); + ExitBlock->getInstList().insert(InsertPt, New); } + + // Now that we have inserted the instruction, store it into the alloca + if (AI) new StoreInst(New, AI, InsertPt); } // If the instruction doesn't dominate any exit blocks, it must be dead. @@ -660,7 +663,7 @@ void LICM::PromoteValuesInLoop() { // value has an alloca instruction for it, and a canonical version of the // pointer. std::vector > PromotedValues; - std::map ValueToAllocaMap; // Map of ptr to alloca + DenseMap ValueToAllocaMap; // Map of ptr to alloca FindPromotableValuesInLoop(PromotedValues, ValueToAllocaMap); if (ValueToAllocaMap.empty()) return; // If there are values to promote. @@ -717,12 +720,12 @@ void LICM::PromoteValuesInLoop() { // Rewrite all loads and stores in the block of the pointer... for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E; ++II) { if (LoadInst *L = dyn_cast(II)) { - std::map::iterator + DenseMap::iterator I = ValueToAllocaMap.find(L->getOperand(0)); if (I != ValueToAllocaMap.end()) L->setOperand(0, I->second); // Rewrite load instruction... } else if (StoreInst *S = dyn_cast(II)) { - std::map::iterator + DenseMap::iterator I = ValueToAllocaMap.find(S->getOperand(1)); if (I != ValueToAllocaMap.end()) S->setOperand(1, I->second); // Rewrite store instruction... @@ -778,7 +781,7 @@ void LICM::PromoteValuesInLoop() { /// alloca. void LICM::FindPromotableValuesInLoop( std::vector > &PromotedValues, - std::map &ValueToAllocaMap) { + DenseMap &ValueToAllocaMap) { Instruction *FnStart = CurLoop->getHeader()->getParent()->begin()->begin(); // Loop over all of the alias sets in the tracker object. @@ -855,7 +858,7 @@ void LICM::FindPromotableValuesInLoop( CurAST->copyValue(V, AI); for (AliasSet::iterator I = AS.begin(), E = AS.end(); I != E; ++I) - ValueToAllocaMap.insert(std::make_pair(I->getValue(), AI)); + ValueToAllocaMap[I->getValue()] = AI; DEBUG(dbgs() << "LICM: Promoting value: " << *V << "\n"); }