Function.h revision 80a75bfae980df96f969f1c05b0c4a80ce975240
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/ParameterAttributes.h" 25#include "llvm/Support/Annotation.h" 26 27namespace llvm { 28 29class FunctionType; 30class ParamAttrsList; 31 32// Traits for intrusive list of instructions... 33template<> struct ilist_traits<BasicBlock> 34 : public SymbolTableListTraits<BasicBlock, Function> { 35 36 // createSentinel is used to create a node that marks the end of the list... 37 static BasicBlock *createSentinel(); 38 static void destroySentinel(BasicBlock *BB) { delete BB; } 39 static iplist<BasicBlock> &getList(Function *F); 40 static ValueSymbolTable *getSymTab(Function *ItemParent); 41 static int getListOffset(); 42}; 43 44template<> struct ilist_traits<Argument> 45 : public SymbolTableListTraits<Argument, Function> { 46 47 // createSentinel is used to create a node that marks the end of the list... 48 static Argument *createSentinel(); 49 static void destroySentinel(Argument *A) { delete A; } 50 static iplist<Argument> &getList(Function *F); 51 static ValueSymbolTable *getSymTab(Function *ItemParent); 52 static int getListOffset(); 53}; 54 55class Function : public GlobalValue, public Annotable { 56public: 57 typedef iplist<Argument> ArgumentListType; 58 typedef iplist<BasicBlock> BasicBlockListType; 59 60 // BasicBlock iterators... 61 typedef BasicBlockListType::iterator iterator; 62 typedef BasicBlockListType::const_iterator const_iterator; 63 64 typedef ArgumentListType::iterator arg_iterator; 65 typedef ArgumentListType::const_iterator const_arg_iterator; 66 67private: 68 // Important things that make up a function! 69 BasicBlockListType BasicBlocks; ///< The basic blocks 70 mutable ArgumentListType ArgumentList; ///< The formal arguments 71 ValueSymbolTable *SymTab; ///< Symbol table of args/instructions 72 const ParamAttrsList *ParamAttrs; ///< Parameter attributes 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 93 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is 94 /// built on demand, so that the list isn't allocated until the first client 95 /// needs it. The hasLazyArguments predicate returns true if the arg list 96 /// hasn't been set up yet. 97 bool hasLazyArguments() const { 98 return SubclassData & 1; 99 } 100 void CheckLazyArguments() const { 101 if (hasLazyArguments()) 102 BuildLazyArguments(); 103 } 104 void BuildLazyArguments() const; 105public: 106 /// Function ctor - If the (optional) Module argument is specified, the 107 /// function is automatically inserted into the end of the function list for 108 /// the module. 109 /// 110 Function(const FunctionType *Ty, LinkageTypes Linkage, 111 const std::string &N = "", Module *M = 0); 112 ~Function(); 113 114 const Type *getReturnType() const; // Return the type of the ret val 115 const FunctionType *getFunctionType() const; // Return the FunctionType for me 116 117 /// isVarArg - Return true if this function takes a variable number of 118 /// arguments. 119 bool isVarArg() const; 120 121 /// isDeclaration - Is the body of this function unknown? (The basic block 122 /// list is empty if so.) This is true for function declarations, but not 123 /// true for function definitions. 124 /// 125 virtual bool isDeclaration() const { return BasicBlocks.empty(); } 126 127 /// getIntrinsicID - This method returns the ID number of the specified 128 /// function, or Intrinsic::not_intrinsic if the function is not an 129 /// instrinsic, or if the pointer is null. This value is always defined to be 130 /// zero to allow easy checking for whether a function is intrinsic or not. 131 /// The particular intrinsic functions which correspond to this value are 132 /// defined in llvm/Intrinsics.h. 133 /// 134 unsigned getIntrinsicID(bool noAssert = false) const; 135 bool isIntrinsic() const { return getIntrinsicID() != 0; } 136 137 /// getCallingConv()/setCallingConv(uint) - These method get and set the 138 /// calling convention of this function. The enum values for the known 139 /// calling conventions are defined in CallingConv.h. 140 unsigned getCallingConv() const { return SubclassData >> 1; } 141 void setCallingConv(unsigned CC) { 142 SubclassData = (SubclassData & 1) | (CC << 1); 143 } 144 145 /// Obtains a constant pointer to the ParamAttrsList object which holds the 146 /// parameter attributes information, if any. 147 /// @returns 0 if no parameter attributes have been set. 148 /// @brief Get the parameter attributes. 149 const ParamAttrsList *getParamAttrs() const { return ParamAttrs; } 150 151 /// Sets the parameter attributes for this Function. To construct a 152 /// ParamAttrsList, see ParameterAttributes.h 153 /// @brief Set the parameter attributes. 154 void setParamAttrs(const ParamAttrsList *attrs); 155 156 /// hasCollector/getCollector/setCollector/clearCollector - The name of the 157 /// garbage collection algorithm to use during code generation. 158 bool hasCollector() const; 159 const char *getCollector() const; 160 void setCollector(const char *Str); 161 void clearCollector(); 162 163 /// @brief Determine whether the function has the given attribute. 164 bool paramHasAttr(uint16_t i, ParameterAttributes attr) const { 165 return ParamAttrs && ParamAttrs->paramHasAttr(i, attr); 166 } 167 168 /// @brief Determine if the function does not access memory. 169 bool doesNotAccessMemory() const { 170 return paramHasAttr(0, ParamAttr::ReadNone); 171 } 172 173 /// @brief Determine if the function does not access or only reads memory. 174 bool onlyReadsMemory() const { 175 return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly); 176 } 177 178 /// @brief Determine if the function returns a structure. 179 bool isStructReturn() const { 180 return paramHasAttr(1, ParamAttr::StructRet); 181 } 182 183 /// deleteBody - This method deletes the body of the function, and converts 184 /// the linkage to external. 185 /// 186 void deleteBody() { 187 dropAllReferences(); 188 setLinkage(ExternalLinkage); 189 } 190 191 /// removeFromParent - This method unlinks 'this' from the containing module, 192 /// but does not delete it. 193 /// 194 void removeFromParent(); 195 196 /// eraseFromParent - This method unlinks 'this' from the containing module 197 /// and deletes it. 198 /// 199 void eraseFromParent(); 200 201 202 /// Get the underlying elements of the Function... the basic block list is 203 /// empty for external functions. 204 /// 205 const ArgumentListType &getArgumentList() const { 206 CheckLazyArguments(); 207 return ArgumentList; 208 } 209 ArgumentListType &getArgumentList() { 210 CheckLazyArguments(); 211 return ArgumentList; 212 } 213 214 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } 215 BasicBlockListType &getBasicBlockList() { return BasicBlocks; } 216 217 const BasicBlock &getEntryBlock() const { return front(); } 218 BasicBlock &getEntryBlock() { return front(); } 219 220 //===--------------------------------------------------------------------===// 221 // Symbol Table Accessing functions... 222 223 /// getSymbolTable() - Return the symbol table... 224 /// 225 inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; } 226 inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; } 227 228 229 //===--------------------------------------------------------------------===// 230 // BasicBlock iterator forwarding functions 231 // 232 iterator begin() { return BasicBlocks.begin(); } 233 const_iterator begin() const { return BasicBlocks.begin(); } 234 iterator end () { return BasicBlocks.end(); } 235 const_iterator end () const { return BasicBlocks.end(); } 236 237 size_t size() const { return BasicBlocks.size(); } 238 bool empty() const { return BasicBlocks.empty(); } 239 const BasicBlock &front() const { return BasicBlocks.front(); } 240 BasicBlock &front() { return BasicBlocks.front(); } 241 const BasicBlock &back() const { return BasicBlocks.back(); } 242 BasicBlock &back() { return BasicBlocks.back(); } 243 244 //===--------------------------------------------------------------------===// 245 // Argument iterator forwarding functions 246 // 247 arg_iterator arg_begin() { 248 CheckLazyArguments(); 249 return ArgumentList.begin(); 250 } 251 const_arg_iterator arg_begin() const { 252 CheckLazyArguments(); 253 return ArgumentList.begin(); 254 } 255 arg_iterator arg_end() { 256 CheckLazyArguments(); 257 return ArgumentList.end(); 258 } 259 const_arg_iterator arg_end() const { 260 CheckLazyArguments(); 261 return ArgumentList.end(); 262 } 263 264 size_t arg_size() const; 265 bool arg_empty() const; 266 267 virtual void print(std::ostream &OS) const { print(OS, 0); } 268 void print(std::ostream *OS) const { if (OS) print(*OS); } 269 void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const; 270 271 /// viewCFG - This function is meant for use from the debugger. You can just 272 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 273 /// program, displaying the CFG of the current function with the code for each 274 /// basic block inside. This depends on there being a 'dot' and 'gv' program 275 /// in your path. 276 /// 277 void viewCFG() const; 278 279 /// viewCFGOnly - This function is meant for use from the debugger. It works 280 /// just like viewCFG, but it does not include the contents of basic blocks 281 /// into the nodes, just the label. If you are only interested in the CFG 282 /// this can make the graph smaller. 283 /// 284 void viewCFGOnly() const; 285 286 /// Methods for support type inquiry through isa, cast, and dyn_cast: 287 static inline bool classof(const Function *) { return true; } 288 static inline bool classof(const Value *V) { 289 return V->getValueID() == Value::FunctionVal; 290 } 291 292 /// dropAllReferences() - This method causes all the subinstructions to "let 293 /// go" of all references that they are maintaining. This allows one to 294 /// 'delete' a whole module at a time, even though there may be circular 295 /// references... first all references are dropped, and all use counts go to 296 /// zero. Then everything is deleted for real. Note that no operations are 297 /// valid on an object that has "dropped all references", except operator 298 /// delete. 299 /// 300 /// Since no other object in the module can have references into the body of a 301 /// function, dropping all references deletes the entire body of the function, 302 /// including any contained basic blocks. 303 /// 304 void dropAllReferences(); 305 306 static unsigned getBasicBlockListOffset() { 307 Function *Obj = 0; 308 return unsigned(reinterpret_cast<uintptr_t>(&Obj->BasicBlocks)); 309 } 310 static unsigned getArgumentListOffset() { 311 Function *Obj = 0; 312 return unsigned(reinterpret_cast<uintptr_t>(&Obj->ArgumentList)); 313 } 314}; 315 316inline ValueSymbolTable * 317ilist_traits<BasicBlock>::getSymTab(Function *F) { 318 return F ? &F->getValueSymbolTable() : 0; 319} 320 321inline ValueSymbolTable * 322ilist_traits<Argument>::getSymTab(Function *F) { 323 return F ? &F->getValueSymbolTable() : 0; 324} 325 326inline int 327ilist_traits<BasicBlock>::getListOffset() { 328 return Function::getBasicBlockListOffset(); 329} 330 331inline int 332ilist_traits<Argument>::getListOffset() { 333 return Function::getArgumentListOffset(); 334} 335 336 337} // End llvm namespace 338 339#endif 340