X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FLoopPass.h;h=f78472aeb3e728c557289b9d93c1f098cb8a8b01;hb=0b8c9a80f20772c3793201ab5b251d3520b9cea3;hp=a231598417c31b82925087f5fabd315228432b02;hpb=84da80d10b472332d079c58d21aa48b82e636274;p=oota-llvm.git diff --git a/include/llvm/Analysis/LoopPass.h b/include/llvm/Analysis/LoopPass.h index a231598417c..f78472aeb3e 100644 --- a/include/llvm/Analysis/LoopPass.h +++ b/include/llvm/Analysis/LoopPass.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Devang Patel 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. // //===----------------------------------------------------------------------===// // @@ -16,88 +16,144 @@ #define LLVM_LOOP_PASS_H #include "llvm/Analysis/LoopInfo.h" +#include "llvm/IR/Function.h" #include "llvm/Pass.h" #include "llvm/PassManagers.h" -#include "llvm/Function.h" +#include namespace llvm { class LPPassManager; -class Loop; class Function; -class LoopQueue; +class PMStack; class LoopPass : public Pass { +public: + explicit LoopPass(char &pid) : Pass(PT_Loop, pid) {} + + /// getPrinterPass - Get a pass to print the function corresponding + /// to a Loop. + Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const; + + // runOnLoop - This method should be implemented by the subclass to perform + // whatever action is necessary for the specified Loop. + virtual bool runOnLoop(Loop *L, LPPassManager &LPM) = 0; - public: - // runOnLoop - THis method should be implemented by the subclass to perform - // whatever action is necessary for the specfied Loop. - virtual bool runOnLoop (Loop *L, LPPassManager &LPM) = 0; - virtual bool runOnFunctionBody (Function &F, LPPassManager &LPM) { - return false; + using llvm::Pass::doInitialization; + using llvm::Pass::doFinalization; + + // Initialization and finalization hooks. + virtual bool doInitialization(Loop *L, LPPassManager &LPM) { + return false; } - /// Assign pass manager to manager this pass + // Finalization hook does not supply Loop because at this time + // loop nest is completely different. + virtual bool doFinalization() { return false; } + + // 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 + // LPPassManager passes. In such case, pop LPPassManager from the + // stack. This will force assignPassManager() to create new + // LPPassManger as expected. + void preparePassManager(PMStack &PMS); + + /// Assign pass manager to manage this pass virtual void assignPassManager(PMStack &PMS, - PassManagerType PMT = PMT_LoopPassManager); + PassManagerType PMT); + /// Return what kind of Pass Manager can manage this pass. + virtual PassManagerType getPotentialPassManagerType() const { + return PMT_LoopPassManager; + } + + //===--------------------------------------------------------------------===// + /// SimpleAnalysis - Provides simple interface to update analysis info + /// maintained by various passes. Note, if required this interface can + /// be extracted into a separate abstract class but it would require + /// additional use of multiple inheritance in Pass class hierarchy, something + /// we are trying to avoid. + + /// Each loop pass can override these simple analysis hooks to update + /// desired analysis information. + /// cloneBasicBlockAnalysis - Clone analysis info associated with basic block. + virtual void cloneBasicBlockAnalysis(BasicBlock *F, BasicBlock *T, Loop *L) {} + + /// deleteAnalysisValue - Delete analysis info associated with value V. + virtual void deleteAnalysisValue(Value *V, Loop *L) {} }; class LPPassManager : public FunctionPass, public PMDataManager { - public: - LPPassManager(int Depth); - ~LPPassManager(); + static char ID; + explicit LPPassManager(); /// run - Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the module, and if so, return true. bool runOnFunction(Function &F); /// Pass Manager itself does not invalidate any analysis info. - void getAnalysisUsage(AnalysisUsage &Info) const { - // LPPassManager needs LoopInfo. In the long term LoopInfo class will - // be consumed by LPPassManager. - Info.addRequired(); - Info.setPreservesAll(); - } - + // LPPassManager needs LoopInfo. + void getAnalysisUsage(AnalysisUsage &Info) const; + virtual const char *getPassName() const { return "Loop Pass Manager"; } - - // Print passes managed by this manager - void dumpPassStructure(unsigned Offset) { - llvm::cerr << std::string(Offset*2, ' ') << "Loop Pass Manager\n"; - for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - Pass *P = getContainedPass(Index); - P->dumpPassStructure(Offset + 1); - dumpLastUses(P, Offset+1); - } - } - - Pass *getContainedPass(unsigned N) { - assert ( N < PassVector.size() && "Pass number out of range!"); - Pass *FP = static_cast(PassVector[N]); - return FP; + + virtual PMDataManager *getAsPMDataManager() { return this; } + virtual Pass *getAsPass() { return this; } + + /// Print passes managed by this manager + void dumpPassStructure(unsigned Offset); + + LoopPass *getContainedPass(unsigned N) { + assert(N < PassVector.size() && "Pass number out of range!"); + LoopPass *LP = static_cast(PassVector[N]); + return LP; } - virtual PassManagerType getPassManagerType() const { - return PMT_LoopPassManager; + virtual PassManagerType getPassManagerType() const { + return PMT_LoopPassManager; } public: - // Delete loop from the loop queue. This is used by Loop pass to inform - // Loop Pass Manager that it should skip rest of the passes for this loop. + // Delete loop from the loop queue and loop nest (LoopInfo). void deleteLoopFromQueue(Loop *L); + // Insert loop into the loop queue and add it as a child of the + // given parent. + void insertLoop(Loop *L, Loop *ParentLoop); + + // Insert a loop into the loop queue. + void insertLoopIntoQueue(Loop *L); + // Reoptimize this loop. LPPassManager will re-insert this loop into the // queue. This allows LoopPass to change loop nest for the loop. This // utility may send LPPassManager into infinite loops so use caution. void redoLoop(Loop *L); + + //===--------------------------------------------------------------------===// + /// SimpleAnalysis - Provides simple interface to update analysis info + /// maintained by various passes. Note, if required this interface can + /// be extracted into a separate abstract class but it would require + /// additional use of multiple inheritance in Pass class hierarchy, something + /// we are trying to avoid. + + /// cloneBasicBlockSimpleAnalysis - Invoke cloneBasicBlockAnalysis hook for + /// all passes that implement simple analysis interface. + void cloneBasicBlockSimpleAnalysis(BasicBlock *From, BasicBlock *To, Loop *L); + + /// deleteSimpleAnalysisValue - Invoke deleteAnalysisValue hook for all passes + /// that implement simple analysis interface. + void deleteSimpleAnalysisValue(Value *V, Loop *L); + private: - LoopQueue *LQ; + std::deque LQ; bool skipThisLoop; bool redoThisLoop; + LoopInfo *LI; + Loop *CurrentLoop; }; } // End llvm namespace