X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAnalysis%2FLoopPass.cpp;h=10e3f297f9c51dd138171a0f40f7cded30f3e638;hb=6c3541d5597033bdb2f26f5ade811b482c32a39a;hp=e346cc0dd4184891ac1a169411addbb36e16a15d;hpb=6d594a9d76ed93cd03723283c1e7ea1b59075a3d;p=oota-llvm.git diff --git a/lib/Analysis/LoopPass.cpp b/lib/Analysis/LoopPass.cpp index e346cc0dd41..10e3f297f9c 100644 --- a/lib/Analysis/LoopPass.cpp +++ b/lib/Analysis/LoopPass.cpp @@ -14,8 +14,59 @@ //===----------------------------------------------------------------------===// #include "llvm/Analysis/LoopPass.h" +#include "llvm/DebugInfoProbe.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/Timer.h" using namespace llvm; +namespace { + +/// PrintLoopPass - Print a Function corresponding to a Loop. +/// +class PrintLoopPass : public LoopPass { +private: + std::string Banner; + raw_ostream &Out; // raw_ostream to print on. + +public: + static char ID; + PrintLoopPass(const std::string &B, raw_ostream &o) + : LoopPass(ID), Banner(B), Out(o) {} + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } + + bool runOnLoop(Loop *L, LPPassManager &) { + Out << Banner; + for (Loop::block_iterator b = L->block_begin(), be = L->block_end(); + b != be; + ++b) { + (*b)->print(Out); + } + return false; + } +}; + +char PrintLoopPass::ID = 0; +} + +//===----------------------------------------------------------------------===// +// DebugInfoProbe + +static DebugInfoProbeInfo *TheDebugProbe; +static void createDebugInfoProbe() { + if (TheDebugProbe) return; + + // Constructed the first time this is called. This guarantees that the + // object will be constructed, if -enable-debug-info-probe is set, + // before static globals, thus it will be destroyed before them. + static ManagedStatic DIP; + TheDebugProbe = &*DIP; +} + //===----------------------------------------------------------------------===// // LPPassManager // @@ -23,7 +74,7 @@ using namespace llvm; char LPPassManager::ID = 0; LPPassManager::LPPassManager(int Depth) - : FunctionPass(&ID), PMDataManager(Depth) { + : FunctionPass(ID), PMDataManager(Depth) { skipThisLoop = false; redoThisLoop = false; LI = NULL; @@ -147,8 +198,7 @@ void LPPassManager::redoLoop(Loop *L) { void LPPassManager::cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L) { for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - Pass *P = getContainedPass(Index); - LoopPass *LP = dynamic_cast(P); + LoopPass *LP = getContainedPass(Index); LP->cloneBasicBlockAnalysis(From, To, L); } } @@ -163,8 +213,7 @@ void LPPassManager::deleteSimpleAnalysisValue(Value *V, Loop *L) { } } for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - Pass *P = getContainedPass(Index); - LoopPass *LP = dynamic_cast(P); + LoopPass *LP = getContainedPass(Index); LP->deleteAnalysisValue(V, L); } } @@ -190,6 +239,7 @@ void LPPassManager::getAnalysisUsage(AnalysisUsage &Info) const { bool LPPassManager::runOnFunction(Function &F) { LI = &getAnalysis(); bool Changed = false; + createDebugInfoProbe(); // Collect inherited analysis from Module level pass manager. populateInheritedAnalysis(TPM->activeStack); @@ -206,10 +256,8 @@ bool LPPassManager::runOnFunction(Function &F) { I != E; ++I) { Loop *L = *I; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - Pass *P = getContainedPass(Index); - LoopPass *LP = dynamic_cast(P); - if (LP) - Changed |= LP->doInitialization(L, *this); + LoopPass *P = getContainedPass(Index); + Changed |= P->doInitialization(L, *this); } } @@ -222,26 +270,27 @@ bool LPPassManager::runOnFunction(Function &F) { // Run all passes on the current Loop. for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - Pass *P = getContainedPass(Index); - + LoopPass *P = getContainedPass(Index); dumpPassInfo(P, EXECUTION_MSG, ON_LOOP_MSG, - CurrentLoop->getHeader()->getNameStr()); + CurrentLoop->getHeader()->getName()); dumpRequiredSet(P); initializeAnalysisImpl(P); - - LoopPass *LP = dynamic_cast(P); - assert(LP && "Invalid LPPassManager member"); + if (TheDebugProbe) + TheDebugProbe->initialize(P, F); { - PassManagerPrettyStackEntry X(LP, *CurrentLoop->getHeader()); - Timer *T = StartPassTimer(P); - Changed |= LP->runOnLoop(CurrentLoop, *this); - StopPassTimer(P, T); + PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader()); + TimeRegion PassTimer(getPassTimer(P)); + + Changed |= P->runOnLoop(CurrentLoop, *this); } + if (TheDebugProbe) + TheDebugProbe->finalize(P, F); if (Changed) dumpPassInfo(P, MODIFICATION_MSG, ON_LOOP_MSG, - CurrentLoop->getHeader()->getNameStr()); + skipThisLoop ? "" : + CurrentLoop->getHeader()->getName()); dumpPreservedSet(P); if (!skipThisLoop) { @@ -250,19 +299,20 @@ bool LPPassManager::runOnFunction(Function &F) { // is a function pass and it's really expensive to verify every // loop in the function every time. That level of checking can be // enabled with the -verify-loop-info option. - Timer *T = StartPassTimer(LI); - CurrentLoop->verifyLoop(); - StopPassTimer(LI, T); + { + TimeRegion PassTimer(getPassTimer(LI)); + CurrentLoop->verifyLoop(); + } // Then call the regular verifyAnalysis functions. - verifyPreservedAnalysis(LP); + verifyPreservedAnalysis(P); } removeNotPreservedAnalysis(P); recordAvailableAnalysis(P); removeDeadPasses(P, skipThisLoop ? "" : - CurrentLoop->getHeader()->getNameStr(), + CurrentLoop->getHeader()->getName(), ON_LOOP_MSG); if (skipThisLoop) @@ -288,10 +338,8 @@ bool LPPassManager::runOnFunction(Function &F) { // Finalization for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - Pass *P = getContainedPass(Index); - LoopPass *LP = dynamic_cast (P); - if (LP) - Changed |= LP->doFinalization(); + LoopPass *P = getContainedPass(Index); + Changed |= P->doFinalization(); } return Changed; @@ -311,6 +359,11 @@ void LPPassManager::dumpPassStructure(unsigned Offset) { //===----------------------------------------------------------------------===// // LoopPass +Pass *LoopPass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + return new PrintLoopPass(Banner, O); +} + // Check if this pass is suitable for the current LPPassManager, if // available. This pass P is not suitable for a LPPassManager if P // is not preserving higher level analysis info used by other @@ -324,12 +377,11 @@ void LoopPass::preparePassManager(PMStack &PMS) { PMS.top()->getPassManagerType() > PMT_LoopPassManager) PMS.pop(); - LPPassManager *LPPM = dynamic_cast(PMS.top()); - // If this pass is destroying high level information that is used // by other passes that are managed by LPM then do not insert // this pass in current LPM. Use new LPPassManager. - if (LPPM && !LPPM->preserveHigherLevelAnalysis(this)) + if (PMS.top()->getPassManagerType() == PMT_LoopPassManager && + !PMS.top()->preserveHigherLevelAnalysis(this)) PMS.pop(); } @@ -341,11 +393,11 @@ void LoopPass::assignPassManager(PMStack &PMS, PMS.top()->getPassManagerType() > PMT_LoopPassManager) PMS.pop(); - LPPassManager *LPPM = dynamic_cast(PMS.top()); - - // Create new Loop Pass Manager if it does not exist. - if (!LPPM) { - + LPPassManager *LPPM; + if (PMS.top()->getPassManagerType() == PMT_LoopPassManager) + LPPM = (LPPassManager*)PMS.top(); + else { + // Create new Loop Pass Manager if it does not exist. assert (!PMS.empty() && "Unable to create Loop Pass Manager"); PMDataManager *PMD = PMS.top(); @@ -359,7 +411,7 @@ void LoopPass::assignPassManager(PMStack &PMS, // [3] Assign manager to manage this new manager. This may create // and push new managers into PMS - Pass *P = dynamic_cast(LPPM); + Pass *P = LPPM->getAsPass(); TPM->schedulePass(P); // [4] Push new manager into PMS