CbC/CbC_llvm: lib/Analysis/LoopInfo.cpp comparison

comparison lib/Analysis/LoopInfo.cpp @ 77:54457678186b LLVM3.6

LLVM 3.6

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Mon, 08 Sep 2014 22:06:00 +0900
parents	95c75e76d11b
children	60c9769439b8

comparison

equal deleted inserted replaced

-:e874dbf0ad9d
+:54457678186b
 //===----------------------------------------------------------------------===//
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/LoopInfoImpl.h"
 #include "llvm/Analysis/LoopIterator.h"
 #include "llvm/Analysis/ValueTracking.h"
-#include "llvm/Assembly/Writer.h"
+#include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Metadata.h"
-#include "llvm/Support/CFG.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <algorithm>
 using namespace llvm;
 VerifyLoopInfoX("verify-loop-info", cl::location(VerifyLoopInfo),
 cl::desc("Verify loop info (time consuming)"));
 char LoopInfo::ID = 0;
 INITIALIZE_PASS_BEGIN(LoopInfo, "loops", "Natural Loop Information", true, true)
-INITIALIZE_PASS_DEPENDENCY(DominatorTree)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_END(LoopInfo, "loops", "Natural Loop Information", true, true)
 // Loop identifier metadata name.
 static const char *const LoopMDName = "llvm.loop";
 /// variable.
 ///
 PHINode *Loop::getCanonicalInductionVariable() const {
 BasicBlock *H = getHeader();
-BasicBlock *Incoming = 0, *Backedge = 0;
+BasicBlock *Incoming = nullptr, *Backedge = nullptr;
 pred_iterator PI = pred_begin(H);
 assert(PI != pred_end(H) &&
 "Loop must have at least one backedge!");
 Backedge = *PI++;
-if (PI == pred_end(H)) return 0;  // dead loop
+if (PI == pred_end(H)) return nullptr;  // dead loop
 Incoming = *PI++;
-if (PI != pred_end(H)) return 0;  // multiple backedges?
+if (PI != pred_end(H)) return nullptr;  // multiple backedges?
 if (contains(Incoming)) {
 if (contains(Backedge))
-return 0;
+return nullptr;
 std::swap(Incoming, Backedge);
 } else if (!contains(Backedge))
-return 0;
+return nullptr;
 // Loop over all of the PHI nodes, looking for a canonical indvar.
 for (BasicBlock::iterator I = H->begin(); isa<PHINode>(I); ++I) {
 PHINode *PN = cast<PHINode>(I);
 if (ConstantInt *CI =
 Inc->getOperand(0) == PN)
 if (ConstantInt *CI = dyn_cast<ConstantInt>(Inc->getOperand(1)))
 if (CI->equalsInt(1))
 return PN;
 }
-return 0;
+return nullptr;
 }
 /// isLCSSAForm - Return true if the Loop is in LCSSA form
 bool Loop::isLCSSAForm(DominatorTree &DT) const {
 for (block_iterator BI = block_begin(), E = block_end(); BI != E; ++BI) {
 BasicBlock *BB = *BI;
 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;++I)
-for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E;
+for (Use &U : I->uses()) {
-++UI) {
+Instruction *UI = cast<Instruction>(U.getUser());
-User *U = *UI;
+BasicBlock *UserBB = UI->getParent();
-BasicBlock *UserBB = cast<Instruction>(U)->getParent();
+if (PHINode *P = dyn_cast<PHINode>(UI))
-if (PHINode *P = dyn_cast<PHINode>(U))
+UserBB = P->getIncomingBlock(U);
-UserBB = P->getIncomingBlock(UI);
 // Check the current block, as a fast-path, before checking whether
 // the use is anywhere in the loop.  Most values are used in the same
 // block they are defined in.  Also, blocks not reachable from the
 // entry are special; uses in them don't need to go through PHIs.
 for (Loop::block_iterator I = block_begin(), E = block_end(); I != E; ++I) {
 if (isa<IndirectBrInst>((*I)->getTerminator()))
 return false;
 if (const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator()))
-if (II->hasFnAttr(Attribute::NoDuplicate))
+if (II->cannotDuplicate())
 return false;
 for (BasicBlock::iterator BI = (*I)->begin(), BE = (*I)->end(); BI != BE; ++BI) {
 if (const CallInst *CI = dyn_cast<CallInst>(BI)) {
-if (CI->hasFnAttr(Attribute::NoDuplicate))
+if (CI->cannotDuplicate())
 return false;
 }
 }
 }
 return true;
 }
 MDNode *Loop::getLoopID() const {
-MDNode *LoopID = 0;
+MDNode *LoopID = nullptr;
 if (isLoopSimplifyForm()) {
 LoopID = getLoopLatch()->getTerminator()->getMetadata(LoopMDName);
 } else {
 // Go through each predecessor of the loop header and check the
 // terminator for the metadata.
 BasicBlock *H = getHeader();
 for (block_iterator I = block_begin(), IE = block_end(); I != IE; ++I) {
 TerminatorInst *TI = (*I)->getTerminator();
-MDNode *MD = 0;
+MDNode *MD = nullptr;
 // Check if this terminator branches to the loop header.
 for (unsigned i = 0, ie = TI->getNumSuccessors(); i != ie; ++i) {
 if (TI->getSuccessor(i) == H) {
 MD = TI->getMetadata(LoopMDName);
 break;
 }
 }
 if (!MD)
-return 0;
+return nullptr;
 if (!LoopID)
 LoopID = MD;
 else if (MD != LoopID)
-return 0;
+return nullptr;
 }
 }
 if (!LoopID || LoopID->getNumOperands() == 0 ||
 LoopID->getOperand(0) != LoopID)
-return 0;
+return nullptr;
 return LoopID;
 }
 void Loop::setLoopID(MDNode *LoopID) const {
 assert(LoopID && "Loop ID should not be null");
 BasicBlock *Loop::getUniqueExitBlock() const {
 SmallVector<BasicBlock *, 8> UniqueExitBlocks;
 getUniqueExitBlocks(UniqueExitBlocks);
 if (UniqueExitBlocks.size() == 1)
 return UniqueExitBlocks[0];
-return 0;
+return nullptr;
 }
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 void Loop::dump() const {
 print(dbgs());
 /// updateSubloopParents - Update the parent loop for all subloops directly
 /// nested within unloop.
 void UnloopUpdater::updateSubloopParents() {
 while (!Unloop->empty()) {
-Loop *Subloop = *llvm::prior(Unloop->end());
+Loop *Subloop = *std::prev(Unloop->end());
-Unloop->removeChildLoop(llvm::prior(Unloop->end()));
+Unloop->removeChildLoop(std::prev(Unloop->end()));
 assert(SubloopParents.count(Subloop) && "DFS failed to visit subloop");
 if (Loop *Parent = SubloopParents[Subloop])
 Parent->addChildLoop(Subloop);
 else
 // Initially for blocks directly contained by Unloop, NearLoop == Unloop and
 // is considered uninitialized.
 Loop *NearLoop = BBLoop;
-Loop *Subloop = 0;
+Loop *Subloop = nullptr;
 if (NearLoop != Unloop && Unloop->contains(NearLoop)) {
 Subloop = NearLoop;
 // Find the subloop ancestor that is directly contained within Unloop.
 while (Subloop->getParentLoop() != Unloop) {
 Subloop = Subloop->getParentLoop();
 }
 succ_iterator I = succ_begin(BB), E = succ_end(BB);
 if (I == E) {
 assert(!Subloop && "subloop blocks must have a successor");
-NearLoop = 0; // unloop blocks may now exit the function.
+NearLoop = nullptr; // unloop blocks may now exit the function.
 }
 for (; I != E; ++I) {
 if (*I == BB)
 continue; // self loops are uninteresting
 //===----------------------------------------------------------------------===//
 // LoopInfo implementation
 //
 bool LoopInfo::runOnFunction(Function &) {
 releaseMemory();
-LI.Analyze(getAnalysis<DominatorTree>().getBase());
+LI.Analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
 return false;
 }
 /// updateUnloop - The last backedge has been removed from a loop--now the
 /// "unloop". Find a new parent for the blocks contained within unloop and
 if (getLoopFor(*I) != Unloop)
 continue;
 // Blocks no longer have a parent but are still referenced by Unloop until
 // the Unloop object is deleted.
-LI.changeLoopFor(*I, 0);
+LI.changeLoopFor(*I, nullptr);
 }
 // Remove the loop from the top-level LoopInfo object.
 for (LoopInfo::iterator I = LI.begin();; ++I) {
 assert(I != LI.end() && "Couldn't find loop");
 }
 }
 // Move all of the subloops to the top-level.
 while (!Unloop->empty())
-LI.addTopLevelLoop(Unloop->removeChildLoop(llvm::prior(Unloop->end())));
+LI.addTopLevelLoop(Unloop->removeChildLoop(std::prev(Unloop->end())));
 return;
 }
 // Update the parent loop for all blocks within the loop. Blocks within
 }
 }
 void LoopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
 AU.setPreservesAll();
-AU.addRequired<DominatorTree>();
+AU.addRequired<DominatorTreeWrapperPass>();
 }
 void LoopInfo::print(raw_ostream &OS, const Module*) const {
 LI.print(OS);
 }

Mercurial > hg > CbC > CbC_llvm

comparison lib/Analysis/LoopInfo.cpp @ 77:54457678186b LLVM3.6