X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FFunction.h;h=93b9dc6d7abfe5f6e09e0b8c0e5409a3abb598d1;hb=2182c785c22a3e805d7d38708e75e5d30c547fdf;hp=7448dce9fe3a3ec912cf140984825943ab10fabc;hpb=009505452b713ed2e3a8e99c5545a6e721c65495;p=oota-llvm.git diff --git a/include/llvm/Function.h b/include/llvm/Function.h index 7448dce9fe3..93b9dc6d7ab 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -13,57 +13,86 @@ #include "llvm/SymTabValue.h" #include "llvm/BasicBlock.h" -#include +#include "llvm/GlobalValue.h" class Instruction; class BasicBlock; class MethodArgument; class MethodType; -class Method; class Module; -typedef UseTy MethodUse; - -class Method : public SymTabValue { +class Method : public GlobalValue, public SymTabValue { public: - typedef ValueHolder ArgumentListType; - typedef ValueHolder BasicBlocksType; -private: + typedef ValueHolder ArgumentListType; + typedef ValueHolder BasicBlocksType; - // Important things that make up a method! - BasicBlocksType BasicBlocks; // The basic blocks - ArgumentListType ArgumentList; // The formal arguments + // BasicBlock iterators... + typedef BasicBlocksType::iterator iterator; + typedef BasicBlocksType::const_iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; - Module *Parent; // The module that contains this method +private: - friend class ValueHolder; + // Important things that make up a method! + BasicBlocksType BasicBlocks; // The basic blocks + ArgumentListType ArgumentList; // The formal arguments + + friend class ValueHolder; void setParent(Module *parent); public: - Method(const MethodType *Ty, const string &Name = ""); + Method(const MethodType *Ty, bool isInternal, const std::string &Name = ""); ~Method(); // Specialize setName to handle symbol table majik... - virtual void setName(const string &name); + virtual void setName(const std::string &name, SymbolTable *ST = 0); - const Type *getReturnType() const; - const MethodType *getMethodType() const; + const Type *getReturnType() const; // Return the return type of method + const MethodType *getMethodType() const; // Return the MethodType for me // Is the body of this method unknown? (the basic block list is empty if so) - // this is true for "extern"al methods. - bool isMethodExternal() const { return BasicBlocks.empty(); } - + // this is true for external methods, defined as forward "declare"ations + bool isExternal() const { return BasicBlocks.empty(); } - // Get the class structure that this method is contained inside of... - inline Module *getParent() { return Parent; } - inline const Module *getParent() const { return Parent; } + // Get the underlying elements of the Method... both the argument list and + // basic block list are empty for external methods. + // + inline const ArgumentListType &getArgumentList() const{ return ArgumentList; } + inline ArgumentListType &getArgumentList() { return ArgumentList; } inline const BasicBlocksType &getBasicBlocks() const { return BasicBlocks; } inline BasicBlocksType &getBasicBlocks() { return BasicBlocks; } - inline const ArgumentListType &getArgumentList() const{ return ArgumentList; } - inline ArgumentListType &getArgumentList() { return ArgumentList; } - + inline const BasicBlock *getEntryNode() const { return front(); } + inline BasicBlock *getEntryNode() { return front(); } + + //===--------------------------------------------------------------------===// + // BasicBlock iterator forwarding functions + // + inline iterator begin() { return BasicBlocks.begin(); } + inline const_iterator begin() const { return BasicBlocks.begin(); } + inline iterator end () { return BasicBlocks.end(); } + inline const_iterator end () const { return BasicBlocks.end(); } + + inline reverse_iterator rbegin() { return BasicBlocks.rbegin(); } + inline const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); } + inline reverse_iterator rend () { return BasicBlocks.rend(); } + inline const_reverse_iterator rend () const { return BasicBlocks.rend(); } + + inline unsigned size() const { return BasicBlocks.size(); } + inline bool empty() const { return BasicBlocks.empty(); } + inline const BasicBlock *front() const { return BasicBlocks.front(); } + inline BasicBlock *front() { return BasicBlocks.front(); } + inline const BasicBlock *back() const { return BasicBlocks.back(); } + inline BasicBlock *back() { return BasicBlocks.back(); } + + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const Method *T) { return true; } + static inline bool classof(const Value *V) { + return V->getValueType() == Value::MethodVal; + } // dropAllReferences() - This function causes all the subinstructions to "let // go" of all references that they are maintaining. This allows one to @@ -81,15 +110,14 @@ public: // template class InstIterator; - typedef InstIterator inst_iterator; - typedef InstIterator inst_const_iterator; + typedef InstIterator inst_iterator; + typedef InstIterator const_inst_iterator; // This inner class is used to implement inst_begin() & inst_end() for - // inst_iterator and inst_const_iterator's. + // inst_iterator and const_inst_iterator's. // template class InstIterator { @@ -99,14 +127,18 @@ public: typedef _II_t IIty; _BB_t &BBs; // BasicBlocksType _BB_i_t BB; // BasicBlocksType::iterator - _BI_t BI; // BasicBlock::InstListType::iterator + _BI_t BI; // BasicBlock::iterator public: - typedef bidirectional_iterator_tag iterator_category; - + typedef std::bidirectional_iterator_tag iterator_category; + typedef IIty value_type; + typedef unsigned difference_type; + typedef BIty pointer; + typedef IIty reference; + template InstIterator(M &m) : BBs(m.getBasicBlocks()), BB(BBs.begin()) { // begin ctor if (BB != BBs.end()) { - BI = (*BB)->getInstList().begin(); + BI = (*BB)->begin(); resyncInstructionIterator(); } } @@ -120,10 +152,10 @@ public: inline BIty &getInstructionIterator() { return BI; } inline IIty operator*() const { return *BI; } - inline IIty *operator->() const { return &(operator*()); } + inline IIty operator->() const { return operator*(); } inline bool operator==(const InstIterator &y) const { - return BB == y.BB && (BI == y.BI || BB == BBs.end()); + return BB == y.BB && (BB == BBs.end() || BI == y.BI); } inline bool operator!=(const InstIterator& y) const { return !operator==(y); @@ -136,10 +168,10 @@ public: inline void resyncInstructionIterator() { // The only way that the II could be broken is if it is now pointing to // the end() of the current BasicBlock and there are successor BBs. - while (BI == (*BB)->getInstList().end()) { - ++BB; + while (BI == (*BB)->end()) { + ++BB; if (BB == BBs.end()) break; - BI = (*BB)->getInstList().begin(); + BI = (*BB)->begin(); } } @@ -153,9 +185,9 @@ public: } InstIterator& operator--() { - while (BB == BBs.end() || BI == (*BB)->getInstList().begin()) { + while (BB == BBs.end() || BI == (*BB)->begin()) { --BB; - BI = (*BB)->getInstList().end(); + BI = (*BB)->end(); } --BI; return *this; @@ -163,12 +195,42 @@ public: inline InstIterator operator--(int) { InstIterator tmp = *this; --*this; return tmp; } + + inline bool atEnd() const { return BB == BBs.end(); } }; inline inst_iterator inst_begin() { return inst_iterator(*this); } inline inst_iterator inst_end() { return inst_iterator(*this, true); } - inline inst_const_iterator inst_begin() const { return inst_const_iterator(*this); } - inline inst_const_iterator inst_end() const { return inst_const_iterator(*this, true); } + inline const_inst_iterator inst_begin() const { return const_inst_iterator(*this); } + inline const_inst_iterator inst_end() const { return const_inst_iterator(*this, true); } +}; + +// Provide specializations of GraphTraits to be able to treat a method as a +// graph of basic blocks... these are the same as the basic block iterators, +// except that the root node is implicitly the first node of the method. +// +template <> struct GraphTraits : public GraphTraits { + static NodeType *getEntryNode(Method *M) { return M->front(); } +}; +template <> struct GraphTraits : + public GraphTraits { + static NodeType *getEntryNode(const Method *M) { return M->front(); } +}; + +// Provide specializations of GraphTraits to be able to treat a method as a +// graph of basic blocks... and to walk it in inverse order. Inverse order for +// a method is considered to be when traversing the predecessor edges of a BB +// instead of the successor edges. +// +template <> struct GraphTraits > : + public GraphTraits > { + static NodeType *getEntryNode(Inverse G) { return G.Graph->front();} +}; +template <> struct GraphTraits > : + public GraphTraits > { + static NodeType *getEntryNode(Inverse G) { + return G.Graph->front(); + } }; #endif