X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FFunction.h;h=91df9a70cfa34f5cb8dad9ffb82e9c5de097bfbb;hb=d80e973cec7e30839530d94f84748d99b03b0d9e;hp=fe878bf45e88a9dbbd39a8a1b448943c0c2217ea;hpb=4387370c1c6dd64ad01be0fc91836616d908e917;p=oota-llvm.git diff --git a/include/llvm/Function.h b/include/llvm/Function.h index fe878bf45e8..91df9a70cfa 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -1,69 +1,68 @@ -//===-- llvm/Method.h - Class to represent a single VM method ----*- C++ -*--=// +//===-- llvm/Function.h - Class to represent a single VM function -*- C++ -*-=// // -// This file contains the declaration of the Method class, which represents a -// single Method/function/procedure in the VM. +// This file contains the declaration of the Function class, which represents a +// single function/procedure in the VM. // -// Note that basic blocks themselves are Def's, because they are referenced -// by instructions like calls and can go in virtual function tables and stuff. +// Note that basic blocks in the method are value's, because they are referenced +// by instructions like calls and can go into virtual function tables and stuff. // //===----------------------------------------------------------------------===// -#ifndef LLVM_METHOD_H -#define LLVM_METHOD_H +#ifndef LLVM_FUNCTION_H +#define LLVM_FUNCTION_H #include "llvm/SymTabValue.h" -#include "llvm/BasicBlock.h" #include "llvm/GlobalValue.h" +#include "llvm/ValueHolder.h" -class Instruction; -class BasicBlock; -class MethodArgument; -class MethodType; -class Module; +class FunctionType; -class Method : public GlobalValue, public SymTabValue { +class Function : public GlobalValue, public SymTabValue { public: - typedef ValueHolder ArgumentListType; - typedef ValueHolder BasicBlocksType; + typedef ValueHolder ArgumentListType; + typedef ValueHolder BasicBlocksType; // BasicBlock iterators... typedef BasicBlocksType::iterator iterator; typedef BasicBlocksType::const_iterator const_iterator; - typedef reverse_iterator const_reverse_iterator; - typedef reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; private: // Important things that make up a method! - BasicBlocksType BasicBlocks; // The basic blocks - ArgumentListType ArgumentList; // The formal arguments - - friend class ValueHolder; + 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(); + Function(const FunctionType *Ty, bool isInternal, const std::string &N = ""); + ~Function(); // Specialize setName to handle symbol table majik... - virtual void setName(const string &name, SymbolTable *ST = 0); + virtual void setName(const std::string &name, SymbolTable *ST = 0); - const Type *getReturnType() const; // Return the return type of method - const MethodType *getMethodType() const; // Return the MethodType for me + const Type *getReturnType() const; // Return the type of the ret val + const FunctionType *getFunctionType() const; // Return the FunctionType for me // Is the body of this method unknown? (the basic block list is empty if so) // this is true for external methods, defined as forward "declare"ations bool isExternal() const { return BasicBlocks.empty(); } - - // Get the underlying elements of the Method... + // Get the underlying elements of the Function... 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 BasicBlock *getEntryNode() const { return front(); } + inline BasicBlock *getEntryNode() { return front(); } + //===--------------------------------------------------------------------===// // BasicBlock iterator forwarding functions // @@ -84,11 +83,12 @@ public: inline const BasicBlock *back() const { return BasicBlocks.back(); } inline BasicBlock *back() { return BasicBlocks.back(); } + virtual void print(std::ostream &OS) const; // 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 Function *) { return true; } static inline bool classof(const Value *V) { - return V->getValueType() == Value::MethodVal; + return V->getValueType() == Value::FunctionVal; } // dropAllReferences() - This function causes all the subinstructions to "let @@ -100,130 +100,6 @@ public: // delete. // void dropAllReferences(); - - //===--------------------------------------------------------------------===// - // Method Instruction iterator code - //===--------------------------------------------------------------------===// - // - template - class InstIterator; - typedef InstIterator inst_iterator; - typedef InstIterator inst_const_iterator; - - // This inner class is used to implement inst_begin() & inst_end() for - // inst_iterator and inst_const_iterator's. - // - template - class InstIterator { - typedef _BB_t BBty; - typedef _BB_i_t BBIty; - typedef _BI_t BIty; - typedef _II_t IIty; - _BB_t &BBs; // BasicBlocksType - _BB_i_t BB; // BasicBlocksType::iterator - _BI_t BI; // BasicBlock::iterator - public: - typedef bidirectional_iterator_tag iterator_category; - - template InstIterator(M &m) - : BBs(m.getBasicBlocks()), BB(BBs.begin()) { // begin ctor - if (BB != BBs.end()) { - BI = (*BB)->begin(); - resyncInstructionIterator(); - } - } - - template InstIterator(M &m, bool) - : BBs(m.getBasicBlocks()), BB(BBs.end()) { // end ctor - } - - // Accessors to get at the underlying iterators... - inline BBIty &getBasicBlockIterator() { return BB; } - inline BIty &getInstructionIterator() { return BI; } - - inline IIty operator*() const { return *BI; } - inline IIty operator->() const { return operator*(); } - - inline bool operator==(const InstIterator &y) const { - return BB == y.BB && (BI == y.BI || BB == BBs.end()); - } - inline bool operator!=(const InstIterator& y) const { - return !operator==(y); - } - - // resyncInstructionIterator - This should be called if the - // InstructionIterator is modified outside of our control. This resynchs - // the internals of the InstIterator to a consistent state. - // - 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)->end()) { - ++BB; - if (BB == BBs.end()) break; - BI = (*BB)->begin(); - } - } - - InstIterator& operator++() { - ++BI; - resyncInstructionIterator(); // Make sure it is still valid. - return *this; - } - inline InstIterator operator++(int) { - InstIterator tmp = *this; ++*this; return tmp; - } - - InstIterator& operator--() { - while (BB == BBs.end() || BI == (*BB)->begin()) { - --BB; - BI = (*BB)->end(); - } - --BI; - return *this; - } - 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); } -}; - -// 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