X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FLoopPass.h;h=2cf734e53bb43ecf7dd81c64987fede322a3f53f;hb=44fb5881d8edf448d6231a5b8df583aecd6bcd42;hp=2fd14f2dad4a1ecf26bb34256c4e7e73c6257af3;hpb=bfd59055842311a0358f667177c736252d59a7c9;p=oota-llvm.git diff --git a/include/llvm/Analysis/LoopPass.h b/include/llvm/Analysis/LoopPass.h index 2fd14f2dad4..2cf734e53bb 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. // //===----------------------------------------------------------------------===// // @@ -12,92 +12,148 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_LOOP_PASS_H -#define LLVM_LOOP_PASS_H +#ifndef LLVM_ANALYSIS_LOOPPASS_H +#define LLVM_ANALYSIS_LOOPPASS_H #include "llvm/Analysis/LoopInfo.h" +#include "llvm/IR/LegacyPassManagers.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 override; + + // 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 - virtual void assignPassManager(PMStack &PMS, - PassManagerType PMT = PMT_LoopPassManager); + // 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) override; + /// Assign pass manager to manage this pass + void assignPassManager(PMStack &PMS, PassManagerType PMT) override; + + /// Return what kind of Pass Manager can manage this pass. + PassManagerType getPotentialPassManagerType() const override { + 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) {} + + /// Delete analysis info associated with Loop L. + /// Called to notify a Pass that a loop has been deleted and any + /// associated analysis values can be deleted. + virtual void deleteAnalysisLoop(Loop *L) {} + +protected: + /// skipOptnoneFunction - Containing function has Attribute::OptimizeNone + /// and most transformation passes should skip it. + bool skipOptnoneFunction(const Loop *L) const; }; 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); + bool runOnFunction(Function &F) override; /// 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(); - } - - virtual const char *getPassName() const { + // LPPassManager needs LoopInfo. + void getAnalysisUsage(AnalysisUsage &Info) const override; + + const char *getPassName() const override { 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; + + PMDataManager *getAsPMDataManager() override { return this; } + Pass *getAsPass() override { return this; } + + /// Print passes managed by this manager + void dumpPassStructure(unsigned Offset) override; + + LoopPass *getContainedPass(unsigned N) { + assert(N < PassVector.size() && "Pass number out of range!"); + LoopPass *LP = static_cast(PassVector[N]); + return LP; } - virtual PassManagerType getPassManagerType() { - return PMT_LoopPassManager; + PassManagerType getPassManagerType() const override { + 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. - void deleteLoopFromQueue(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); + // Add a new loop into the loop queue as a child of the given parent, or at + // the top level if \c ParentLoop is null. + Loop &addLoop(Loop *ParentLoop); + + //===--------------------------------------------------------------------===// + /// 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); + + /// Invoke deleteAnalysisLoop hook for all passes that implement simple + /// analysis interface. + void deleteSimpleAnalysisLoop(Loop *L); + private: - LoopQueue *LQ; - bool skipThisLoop; - bool redoThisLoop; + std::deque LQ; + LoopInfo *LI; + Loop *CurrentLoop; }; } // End llvm namespace