Members/tobaru/cbc/CbC_llvm: lib/Transforms/Scalar/LICM.cpp comparison

comparison lib/Transforms/Scalar/LICM.cpp @ 83:60c9769439b8

LLVM 3.7

author	Tatsuki IHA <e125716@ie.u-ryukyu.ac.jp>
date	Wed, 18 Feb 2015 14:55:36 +0900
parents	54457678186b
children	afa8332a0e37

comparison

equal deleted inserted replaced

-:af83660cff7b
+:60c9769439b8
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/PredIteratorCache.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Target/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/SSAUpdater.h"
 #include <algorithm>
 using namespace llvm;
 /// loop preheaders be inserted into the CFG...
 ///
 void getAnalysisUsage(AnalysisUsage &AU) const override {
 AU.setPreservesCFG();
 AU.addRequired<DominatorTreeWrapperPass>();
-AU.addRequired<LoopInfo>();
+AU.addRequired<LoopInfoWrapperPass>();
 AU.addRequiredID(LoopSimplifyID);
 AU.addPreservedID(LoopSimplifyID);
 AU.addRequiredID(LCSSAID);
 AU.addPreservedID(LCSSAID);
 AU.addRequired<AliasAnalysis>();
 AU.addPreserved<AliasAnalysis>();
 AU.addPreserved<ScalarEvolution>();
-AU.addRequired<TargetLibraryInfo>();
+AU.addRequired<TargetLibraryInfoWrapperPass>();
 }
 using llvm::Pass::doFinalization;
 bool doFinalization() override {
 Loop *CurLoop;           // The current loop we are working on...
 AliasSetTracker *CurAST; // AliasSet information for the current loop...
 bool MayThrow;           // The current loop contains an instruction which
 // may throw, thus preventing code motion of
 // instructions with side effects.
+bool HeaderMayThrow;     // Same as previous, but specific to loop header
 DenseMap<Loop*, AliasSetTracker*> LoopToAliasSetMap;
 /// cloneBasicBlockAnalysis - Simple Analysis hook. Clone alias set info.
 void cloneBasicBlockAnalysis(BasicBlock *From, BasicBlock *To,
 Loop *L) override;
 /// deleteAnalysisValue - Simple Analysis hook. Delete value V from alias
 /// set.
 void deleteAnalysisValue(Value *V, Loop *L) override;
+/// Simple Analysis hook. Delete loop L from alias set map.
+void deleteAnalysisLoop(Loop *L) override;
 /// SinkRegion - Walk the specified region of the CFG (defined by all blocks
 /// dominated by the specified block, and that are in the current loop) in
 /// reverse depth first order w.r.t the DominatorTree.  This allows us to
 /// visit uses before definitions, allowing us to sink a loop body in one
 }
 char LICM::ID = 0;
 INITIALIZE_PASS_BEGIN(LICM, "licm", "Loop Invariant Code Motion", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(LoopInfo)
+INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
 INITIALIZE_PASS_DEPENDENCY(LCSSA)
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
-INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
+INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
 INITIALIZE_PASS_END(LICM, "licm", "Loop Invariant Code Motion", false, false)
 Pass *llvm::createLICMPass() { return new LICM(); }
 return false;
 Changed = false;
 // Get our Loop and Alias Analysis information...
-LI = &getAnalysis<LoopInfo>();
+LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 AA = &getAnalysis<AliasAnalysis>();
 DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
 DL = DLP ? &DLP->getDataLayout() : nullptr;
-TLI = &getAnalysis<TargetLibraryInfo>();
+TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 assert(L->isLCSSAForm(*DT) && "Loop is not in LCSSA form.");
 CurAST = new AliasSetTracker(*AA);
 // Collect Alias info from subloops.
 BasicBlock *BB = *I;
 if (LI->getLoopFor(BB) == L)        // Ignore blocks in subloops.
 CurAST->add(*BB);                 // Incorporate the specified basic block
 }
-MayThrow = false;
+HeaderMayThrow = false;
+BasicBlock *Header = L->getHeader();
+for (BasicBlock::iterator I = Header->begin(), E = Header->end();
+(I != E) && !HeaderMayThrow; ++I)
+HeaderMayThrow |= I->mayThrow();
+MayThrow = HeaderMayThrow;
 // TODO: We've already searched for instructions which may throw in subloops.
 // We may want to reuse this information.
 for (Loop::block_iterator BB = L->block_begin(), BBE = L->block_end();
 (BB != BBE) && !MayThrow ; ++BB)
 for (BasicBlock::iterator I = (*BB)->begin(), E = (*BB)->end();
 // loop used in the outer loop.
 // FIXME: This is really heavy handed. It would be a bit better to use an
 // SSAUpdater strategy during promotion that was LCSSA aware and reformed
 // it as it went.
 if (Changed)
-formLCSSARecursively(*L, *DT, getAnalysisIfAvailable<ScalarEvolution>());
+formLCSSARecursively(*L, *DT, LI,
+getAnalysisIfAvailable<ScalarEvolution>());
 }
 // Check that neither this loop nor its parent have had LCSSA broken. LICM is
 // specifically moving instructions across the loop boundary and so it is
 // especially in need of sanity checking here.
 // Loads from constant memory are always safe to move, even if they end up
 // in the same alias set as something that ends up being modified.
 if (AA->pointsToConstantMemory(LI->getOperand(0)))
 return true;
-if (LI->getMetadata("invariant.load"))
+if (LI->getMetadata(LLVMContext::MD_invariant_load))
 return true;
 // Don't hoist loads which have may-aliased stores in loop.
 uint64_t Size = 0;
 if (LI->getType()->isSized())
 return isGuaranteedToExecute(Inst);
 }
 bool LICM::isGuaranteedToExecute(Instruction &Inst) {
+// We have to check to make sure that the instruction dominates all
+// of the exit blocks.  If it doesn't, then there is a path out of the loop
+// which does not execute this instruction, so we can't hoist it.
+// If the instruction is in the header block for the loop (which is very
+// common), it is always guaranteed to dominate the exit blocks.  Since this
+// is a common case, and can save some work, check it now.
+if (Inst.getParent() == CurLoop->getHeader())
+// If there's a throw in the header block, we can't guarantee we'll reach
+// Inst.
+return !HeaderMayThrow;
 // Somewhere in this loop there is an instruction which may throw and make us
 // exit the loop.
 if (MayThrow)
 return false;
-// Otherwise we have to check to make sure that the instruction dominates all
-// of the exit blocks.  If it doesn't, then there is a path out of the loop
-// which does not execute this instruction, so we can't hoist it.
-// If the instruction is in the header block for the loop (which is very
-// common), it is always guaranteed to dominate the exit blocks.  Since this
-// is a common case, and can save some work, check it now.
-if (Inst.getParent() == CurLoop->getHeader())
-return true;
 // Get the exit blocks for the current loop.
 SmallVector<BasicBlock*, 8> ExitBlocks;
 CurLoop->getExitBlocks(ExitBlocks);
 // We start with an alignment of one and try to find instructions that allow
 // us to prove better alignment.
 unsigned Alignment = 1;
 AAMDNodes AATags;
+bool HasDedicatedExits = CurLoop->hasDedicatedExits();
 // Check that all of the pointers in the alias set have the same type.  We
 // cannot (yet) promote a memory location that is loaded and stored in
 // different sizes.  While we are at it, collect alignment and AA info.
 for (AliasSet::iterator ASI = AS.begin(), E = AS.end(); ASI != E; ++ASI) {
 if (UI->getOperand(1) != ASIV)
 continue;
 assert(!store->isVolatile() && "AST broken");
 if (!store->isSimple())
 return;
+// Don't sink stores from loops without dedicated block exits. Exits
+// containing indirect branches are not transformed by loop simplify,
+// make sure we catch that. An additional load may be generated in the
+// preheader for SSA updater, so also avoid sinking when no preheader
+// is available.
+if (!HasDedicatedExits || !Preheader)
+return;
 // Note that we only check GuaranteedToExecute inside the store case
 // so that we do not introduce stores where they did not exist before
 // (which would break the LLVM concurrency model).
 if (!AST)
 return;
 AST->deleteValue(V);
 }
+/// Simple Analysis hook. Delete value L from alias set map.
+void LICM::deleteAnalysisLoop(Loop *L) {
+AliasSetTracker *AST = LoopToAliasSetMap.lookup(L);
+if (!AST)
+return;
+delete AST;
+LoopToAliasSetMap.erase(L);
+}

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison lib/Transforms/Scalar/LICM.cpp @ 83:60c9769439b8