Function.h revision 18feb92e917a029b72a338e91b5b93f74d26f406
1//===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains the declaration of the Function class, which represents a 11// single function/procedure in LLVM. 12// 13// A function basically consists of a list of basic blocks, a list of arguments, 14// and a symbol table. 15// 16//===----------------------------------------------------------------------===// 17 18#ifndef LLVM_FUNCTION_H 19#define LLVM_FUNCTION_H 20 21#include "llvm/GlobalValue.h" 22#include "llvm/BasicBlock.h" 23#include "llvm/Argument.h" 24#include "llvm/Support/Annotation.h" 25 26namespace llvm { 27 28class FunctionType; 29class ParamAttrsList; 30 31// Traits for intrusive list of instructions... 32template<> struct ilist_traits<BasicBlock> 33 : public SymbolTableListTraits<BasicBlock, Function> { 34 35 // createSentinel is used to create a node that marks the end of the list... 36 static BasicBlock *createSentinel(); 37 static void destroySentinel(BasicBlock *BB) { delete BB; } 38 static iplist<BasicBlock> &getList(Function *F); 39 static ValueSymbolTable *getSymTab(Function *ItemParent); 40 static int getListOffset(); 41}; 42 43template<> struct ilist_traits<Argument> 44 : public SymbolTableListTraits<Argument, Function> { 45 46 // createSentinel is used to create a node that marks the end of the list... 47 static Argument *createSentinel(); 48 static void destroySentinel(Argument *A) { delete A; } 49 static iplist<Argument> &getList(Function *F); 50 static ValueSymbolTable *getSymTab(Function *ItemParent); 51 static int getListOffset(); 52}; 53 54class Function : public GlobalValue, public Annotable { 55public: 56 typedef iplist<Argument> ArgumentListType; 57 typedef iplist<BasicBlock> BasicBlockListType; 58 59 // BasicBlock iterators... 60 typedef BasicBlockListType::iterator iterator; 61 typedef BasicBlockListType::const_iterator const_iterator; 62 63 typedef ArgumentListType::iterator arg_iterator; 64 typedef ArgumentListType::const_iterator const_arg_iterator; 65 66private: 67 // Important things that make up a function! 68 BasicBlockListType BasicBlocks; ///< The basic blocks 69 ArgumentListType ArgumentList; ///< The formal arguments 70 ValueSymbolTable *SymTab; ///< Symbol table of args/instructions 71 ParamAttrsList *ParamAttrs; ///< Parameter attributes 72 73 74 // The Calling Convention is stored in Value::SubclassData. 75 /*unsigned CallingConvention;*/ 76 77 friend class SymbolTableListTraits<Function, Module>; 78 79 void setParent(Module *parent); 80 Function *Prev, *Next; 81 void setNext(Function *N) { Next = N; } 82 void setPrev(Function *N) { Prev = N; } 83 84public: 85 /// Function ctor - If the (optional) Module argument is specified, the 86 /// function is automatically inserted into the end of the function list for 87 /// the module. 88 /// 89 Function(const FunctionType *Ty, LinkageTypes Linkage, 90 const std::string &N = "", Module *M = 0); 91 ~Function(); 92 93 const Type *getReturnType() const; // Return the type of the ret val 94 const FunctionType *getFunctionType() const; // Return the FunctionType for me 95 96 /// isVarArg - Return true if this function takes a variable number of 97 /// arguments. 98 bool isVarArg() const; 99 100 /// isDeclaration - Is the body of this function unknown? (The basic block 101 /// list is empty if so.) This is true for function declarations, but not 102 /// true for function definitions. 103 /// 104 virtual bool isDeclaration() const { return BasicBlocks.empty(); } 105 106 /// getIntrinsicID - This method returns the ID number of the specified 107 /// function, or Intrinsic::not_intrinsic if the function is not an 108 /// instrinsic, or if the pointer is null. This value is always defined to be 109 /// zero to allow easy checking for whether a function is intrinsic or not. 110 /// The particular intrinsic functions which correspond to this value are 111 /// defined in llvm/Intrinsics.h. 112 /// 113 unsigned getIntrinsicID(bool noAssert = false) const; 114 bool isIntrinsic() const { return getIntrinsicID() != 0; } 115 116 /// getCallingConv()/setCallingConv(uint) - These method get and set the 117 /// calling convention of this function. The enum values for the known 118 /// calling conventions are defined in CallingConv.h. 119 unsigned getCallingConv() const { return SubclassData; } 120 void setCallingConv(unsigned CC) { SubclassData = CC; } 121 122 /// Obtains a constant pointer to the ParamAttrsList object which holds the 123 /// parameter attributes information, if any. 124 /// @returns 0 if no parameter attributes have been set. 125 /// @brief Get the parameter attributes. 126 const ParamAttrsList *getParamAttrs() const { return ParamAttrs; } 127 128 /// Sets the parameter attributes for this Function. To construct a 129 /// ParamAttrsList, see ParameterAttributes.h 130 /// @brief Set the parameter attributes. 131 void setParamAttrs(ParamAttrsList *attrs) { ParamAttrs = attrs; } 132 133 /// deleteBody - This method deletes the body of the function, and converts 134 /// the linkage to external. 135 /// 136 void deleteBody() { 137 dropAllReferences(); 138 setLinkage(ExternalLinkage); 139 } 140 141 /// removeFromParent - This method unlinks 'this' from the containing module, 142 /// but does not delete it. 143 /// 144 void removeFromParent(); 145 146 /// eraseFromParent - This method unlinks 'this' from the containing module 147 /// and deletes it. 148 /// 149 void eraseFromParent(); 150 151 152 // getNext/Prev - Return the next or previous function in the list. These 153 // methods should never be used directly, and are only used to implement the 154 // function list as part of the module. 155 // 156 Function *getNext() { return Next; } 157 const Function *getNext() const { return Next; } 158 Function *getPrev() { return Prev; } 159 const Function *getPrev() const { return Prev; } 160 161 /// Get the underlying elements of the Function... the basic block list is 162 /// empty for external functions. 163 /// 164 const ArgumentListType &getArgumentList() const { return ArgumentList; } 165 ArgumentListType &getArgumentList() { return ArgumentList; } 166 167 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } 168 BasicBlockListType &getBasicBlockList() { return BasicBlocks; } 169 170 const BasicBlock &getEntryBlock() const { return front(); } 171 BasicBlock &getEntryBlock() { return front(); } 172 173 //===--------------------------------------------------------------------===// 174 // Symbol Table Accessing functions... 175 176 /// getSymbolTable() - Return the symbol table... 177 /// 178 inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; } 179 inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; } 180 181 182 //===--------------------------------------------------------------------===// 183 // BasicBlock iterator forwarding functions 184 // 185 iterator begin() { return BasicBlocks.begin(); } 186 const_iterator begin() const { return BasicBlocks.begin(); } 187 iterator end () { return BasicBlocks.end(); } 188 const_iterator end () const { return BasicBlocks.end(); } 189 190 size_t size() const { return BasicBlocks.size(); } 191 bool empty() const { return BasicBlocks.empty(); } 192 const BasicBlock &front() const { return BasicBlocks.front(); } 193 BasicBlock &front() { return BasicBlocks.front(); } 194 const BasicBlock &back() const { return BasicBlocks.back(); } 195 BasicBlock &back() { return BasicBlocks.back(); } 196 197 //===--------------------------------------------------------------------===// 198 // Argument iterator forwarding functions 199 // 200 arg_iterator arg_begin() { return ArgumentList.begin(); } 201 const_arg_iterator arg_begin() const { return ArgumentList.begin(); } 202 arg_iterator arg_end () { return ArgumentList.end(); } 203 const_arg_iterator arg_end () const { return ArgumentList.end(); } 204 205 size_t arg_size () const { return ArgumentList.size(); } 206 bool arg_empty() const { return ArgumentList.empty(); } 207 208 virtual void print(std::ostream &OS) const { print(OS, 0); } 209 void print(std::ostream *OS) const { if (OS) print(*OS); } 210 void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const; 211 212 /// viewCFG - This function is meant for use from the debugger. You can just 213 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 214 /// program, displaying the CFG of the current function with the code for each 215 /// basic block inside. This depends on there being a 'dot' and 'gv' program 216 /// in your path. 217 /// 218 void viewCFG() const; 219 220 /// viewCFGOnly - This function is meant for use from the debugger. It works 221 /// just like viewCFG, but it does not include the contents of basic blocks 222 /// into the nodes, just the label. If you are only interested in the CFG 223 /// this can make the graph smaller. 224 /// 225 void viewCFGOnly() const; 226 227 /// Methods for support type inquiry through isa, cast, and dyn_cast: 228 static inline bool classof(const Function *) { return true; } 229 static inline bool classof(const Value *V) { 230 return V->getValueID() == Value::FunctionVal; 231 } 232 233 /// dropAllReferences() - This method causes all the subinstructions to "let 234 /// go" of all references that they are maintaining. This allows one to 235 /// 'delete' a whole module at a time, even though there may be circular 236 /// references... first all references are dropped, and all use counts go to 237 /// zero. Then everything is deleted for real. Note that no operations are 238 /// valid on an object that has "dropped all references", except operator 239 /// delete. 240 /// 241 /// Since no other object in the module can have references into the body of a 242 /// function, dropping all references deletes the entire body of the function, 243 /// including any contained basic blocks. 244 /// 245 void dropAllReferences(); 246 247 static unsigned getBasicBlockListOffset() { 248 Function *Obj = 0; 249 return reinterpret_cast<unsigned>(&Obj->BasicBlocks); 250 } 251 static unsigned getArgumentListOffset() { 252 Function *Obj = 0; 253 return reinterpret_cast<unsigned>(&Obj->ArgumentList); 254 } 255}; 256 257inline ValueSymbolTable * 258ilist_traits<BasicBlock>::getSymTab(Function *F) { 259 return F ? &F->getValueSymbolTable() : 0; 260} 261 262inline ValueSymbolTable * 263ilist_traits<Argument>::getSymTab(Function *F) { 264 return F ? &F->getValueSymbolTable() : 0; 265} 266 267inline int 268ilist_traits<BasicBlock>::getListOffset() { 269 return Function::getBasicBlockListOffset(); 270} 271 272inline int 273ilist_traits<Argument>::getListOffset() { 274 return Function::getArgumentListOffset(); 275} 276 277 278} // End llvm namespace 279 280#endif 281