X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineLoopInfo.h;h=d53f041128ac84cdab122b016964913a04a53b59;hb=53e98a2c4aa7065f4136c5263b14192036c1e056;hp=4102b90681cb22f8337025d1f71ddca6e55aacb3;hpb=050fe638a5e543674133af6abceb1f0967b84134;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineLoopInfo.h b/include/llvm/CodeGen/MachineLoopInfo.h index 4102b90681c..d53f041128a 100644 --- a/include/llvm/CodeGen/MachineLoopInfo.h +++ b/include/llvm/CodeGen/MachineLoopInfo.h @@ -2,12 +2,12 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Owen Anderson 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. // //===----------------------------------------------------------------------===// // -// This file defines the MachineLoopInfo class that is used to identify natural +// This file defines the MachineLoopInfo class that is used to identify natural // loops and determine the loop depth of various nodes of the CFG. Note that // natural loops may actually be several loops that share the same header node. // @@ -31,132 +31,129 @@ #define LLVM_CODEGEN_MACHINE_LOOP_INFO_H #include "llvm/CodeGen/MachineFunctionPass.h" -#include "llvm/CodeGen/MachineBasicBlock.h" -#include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineInstr.h" #include "llvm/Analysis/LoopInfo.h" namespace llvm { -// Provide overrides for Loop methods that don't make sense for machine loops. -template<> inline -PHINode *LoopBase::getCanonicalInductionVariable() const { - assert(0 && "getCanonicalInductionVariable not supported for machine loops!"); - return 0; -} - -template<> inline Instruction* -LoopBase::getCanonicalInductionVariableIncrement() const { - assert(0 && - "getCanonicalInductionVariableIncrement not supported for machine loops!"); - return 0; -} - -template<> -inline bool LoopBase::isLoopInvariant(Value *V) const { - assert(0 && "isLoopInvariant not supported for machine loops!"); - return false; -} - -template<> -inline Value *LoopBase::getTripCount() const { - assert(0 && "getTripCount not supported for machine loops!"); - return 0; -} - -template<> -inline bool LoopBase::isLCSSAForm() const { - assert(0 && "isLCSSAForm not supported for machine loops"); - return false; -} - -EXTERN_TEMPLATE_INSTANTIATION(class LoopBase); -EXTERN_TEMPLATE_INSTANTIATION(class LoopInfoBase); - -typedef LoopBase MachineLoop; +// Implementation in LoopInfoImpl.h +#ifdef __GNUC__ +class MachineLoop; +__extension__ extern template class LoopBase; +#endif + +class MachineLoop : public LoopBase { +public: + MachineLoop(); + + /// getTopBlock - Return the "top" block in the loop, which is the first + /// block in the linear layout, ignoring any parts of the loop not + /// contiguous with the part the contains the header. + MachineBasicBlock *getTopBlock(); + + /// getBottomBlock - Return the "bottom" block in the loop, which is the last + /// block in the linear layout, ignoring any parts of the loop not + /// contiguous with the part the contains the header. + MachineBasicBlock *getBottomBlock(); + + void dump() const; + +private: + friend class LoopInfoBase; + explicit MachineLoop(MachineBasicBlock *MBB) + : LoopBase(MBB) {} +}; + +// Implementation in LoopInfoImpl.h +#ifdef __GNUC__ +__extension__ extern template +class LoopInfoBase; +#endif class MachineLoopInfo : public MachineFunctionPass { - LoopInfoBase* LI; - friend class LoopBase; - - LoopInfoBase& getBase() { return *LI; } + LoopInfoBase LI; + friend class LoopBase; + + void operator=(const MachineLoopInfo &) LLVM_DELETED_FUNCTION; + MachineLoopInfo(const MachineLoopInfo &) LLVM_DELETED_FUNCTION; + public: static char ID; // Pass identification, replacement for typeid - MachineLoopInfo() : MachineFunctionPass(intptr_t(&ID)) { - LI = new LoopInfoBase(); + MachineLoopInfo() : MachineFunctionPass(ID) { + initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry()); } - - ~MachineLoopInfo() { delete LI; } + + LoopInfoBase& getBase() { return LI; } /// iterator/begin/end - The interface to the top-level loops in the current /// function. /// - typedef std::vector::const_iterator iterator; - inline iterator begin() const { return LI->begin(); } - inline iterator end() const { return LI->end(); } + typedef LoopInfoBase::iterator iterator; + inline iterator begin() const { return LI.begin(); } + inline iterator end() const { return LI.end(); } + bool empty() const { return LI.empty(); } /// getLoopFor - Return the inner most loop that BB lives in. If a basic /// block is in no loop (for example the entry node), null is returned. /// inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const { - return LI->getLoopFor(BB); + return LI.getLoopFor(BB); } /// operator[] - same as getLoopFor... /// inline const MachineLoop *operator[](const MachineBasicBlock *BB) const { - return LI->getLoopFor(BB); + return LI.getLoopFor(BB); } /// getLoopDepth - Return the loop nesting level of the specified block... /// inline unsigned getLoopDepth(const MachineBasicBlock *BB) const { - return LI->getLoopDepth(BB); + return LI.getLoopDepth(BB); } // isLoopHeader - True if the block is a loop header node inline bool isLoopHeader(MachineBasicBlock *BB) const { - return LI->isLoopHeader(BB); + return LI.isLoopHeader(BB); } /// runOnFunction - Calculate the natural loop information. /// virtual bool runOnMachineFunction(MachineFunction &F); - virtual void releaseMemory() { LI->releaseMemory(); } + virtual void releaseMemory() { LI.releaseMemory(); } virtual void getAnalysisUsage(AnalysisUsage &AU) const; /// removeLoop - This removes the specified top-level loop from this loop info /// object. The loop is not deleted, as it will presumably be inserted into /// another loop. - inline MachineLoop *removeLoop(iterator I) { return LI->removeLoop(I); } + inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); } /// changeLoopFor - Change the top-level loop that contains BB to the /// specified loop. This should be used by transformations that restructure /// the loop hierarchy tree. inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) { - LI->changeLoopFor(BB, L); + LI.changeLoopFor(BB, L); } /// changeTopLevelLoop - Replace the specified loop in the top-level loops /// list with the indicated loop. inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) { - LI->changeTopLevelLoop(OldLoop, NewLoop); + LI.changeTopLevelLoop(OldLoop, NewLoop); } /// addTopLevelLoop - This adds the specified loop to the collection of /// top-level loops. inline void addTopLevelLoop(MachineLoop *New) { - LI->addTopLevelLoop(New); + LI.addTopLevelLoop(New); } /// removeBlock - This method completely removes BB from all data structures, /// including all of the Loop objects it is nested in and our mapping from /// MachineBasicBlocks to loops. void removeBlock(MachineBasicBlock *BB) { - LI->removeBlock(BB); + LI.removeBlock(BB); } }; @@ -164,7 +161,7 @@ public: // Allow clients to walk the list of nested loops... template <> struct GraphTraits { typedef const MachineLoop NodeType; - typedef std::vector::const_iterator ChildIteratorType; + typedef MachineLoopInfo::iterator ChildIteratorType; static NodeType *getEntryNode(const MachineLoop *L) { return L; } static inline ChildIteratorType child_begin(NodeType *N) { @@ -177,7 +174,7 @@ template <> struct GraphTraits { template <> struct GraphTraits { typedef MachineLoop NodeType; - typedef std::vector::const_iterator ChildIteratorType; + typedef MachineLoopInfo::iterator ChildIteratorType; static NodeType *getEntryNode(MachineLoop *L) { return L; } static inline ChildIteratorType child_begin(NodeType *N) { @@ -190,7 +187,4 @@ template <> struct GraphTraits { } // End llvm namespace -// Make sure that any clients of this file link in LoopInfo.cpp -FORCE_DEFINING_FILE_TO_BE_LINKED(MachineLoopInfo) - #endif