Function.h revision c6c98af9e5814e8066c82f20ca11cf646a5fc289
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 84 // getNext/Prev - Return the next or previous function in the list. These 85 // methods should never be used directly, and are only used to implement the 86 // function list as part of the module. 87 // 88 Function *getNext() { return Next; } 89 const Function *getNext() const { return Next; } 90 Function *getPrev() { return Prev; } 91 const Function *getPrev() const { return Prev; } 92 93public: 94 /// Function ctor - If the (optional) Module argument is specified, the 95 /// function is automatically inserted into the end of the function list for 96 /// the module. 97 /// 98 Function(const FunctionType *Ty, LinkageTypes Linkage, 99 const std::string &N = "", Module *M = 0); 100 ~Function(); 101 102 const Type *getReturnType() const; // Return the type of the ret val 103 const FunctionType *getFunctionType() const; // Return the FunctionType for me 104 105 /// isVarArg - Return true if this function takes a variable number of 106 /// arguments. 107 bool isVarArg() const; 108 109 /// isDeclaration - Is the body of this function unknown? (The basic block 110 /// list is empty if so.) This is true for function declarations, but not 111 /// true for function definitions. 112 /// 113 virtual bool isDeclaration() const { return BasicBlocks.empty(); } 114 115 /// getIntrinsicID - This method returns the ID number of the specified 116 /// function, or Intrinsic::not_intrinsic if the function is not an 117 /// instrinsic, or if the pointer is null. This value is always defined to be 118 /// zero to allow easy checking for whether a function is intrinsic or not. 119 /// The particular intrinsic functions which correspond to this value are 120 /// defined in llvm/Intrinsics.h. 121 /// 122 unsigned getIntrinsicID(bool noAssert = false) const; 123 bool isIntrinsic() const { return getIntrinsicID() != 0; } 124 125 /// getCallingConv()/setCallingConv(uint) - These method get and set the 126 /// calling convention of this function. The enum values for the known 127 /// calling conventions are defined in CallingConv.h. 128 unsigned getCallingConv() const { return SubclassData; } 129 void setCallingConv(unsigned CC) { SubclassData = CC; } 130 131 /// Obtains a constant pointer to the ParamAttrsList object which holds the 132 /// parameter attributes information, if any. 133 /// @returns 0 if no parameter attributes have been set. 134 /// @brief Get the parameter attributes. 135 const ParamAttrsList *getParamAttrs() const { return ParamAttrs; } 136 137 /// Sets the parameter attributes for this Function. To construct a 138 /// ParamAttrsList, see ParameterAttributes.h 139 /// @brief Set the parameter attributes. 140 void setParamAttrs(ParamAttrsList *attrs); 141 142 /// deleteBody - This method deletes the body of the function, and converts 143 /// the linkage to external. 144 /// 145 void deleteBody() { 146 dropAllReferences(); 147 setLinkage(ExternalLinkage); 148 } 149 150 /// removeFromParent - This method unlinks 'this' from the containing module, 151 /// but does not delete it. 152 /// 153 void removeFromParent(); 154 155 /// eraseFromParent - This method unlinks 'this' from the containing module 156 /// and deletes it. 157 /// 158 void eraseFromParent(); 159 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 unsigned(reinterpret_cast<uintptr_t>(&Obj->BasicBlocks)); 250 } 251 static unsigned getArgumentListOffset() { 252 Function *Obj = 0; 253 return unsigned(reinterpret_cast<uintptr_t>(&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