Function.h revision cfa3c236b23aff80e48df11ef5833b7e63fab802
1//===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// 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#include "llvm/ParameterAttributes.h" 26 27namespace llvm { 28 29class FunctionType; 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 mutable ArgumentListType ArgumentList; ///< The formal arguments 70 ValueSymbolTable *SymTab; ///< Symbol table of args/instructions 71 PAListPtr ParamAttrs; ///< Parameter attributes 72 73 // The Calling Convention is stored in Value::SubclassData. 74 /*unsigned CallingConvention;*/ 75 76 friend class SymbolTableListTraits<Function, Module>; 77 78 void setParent(Module *parent); 79 Function *Prev, *Next; 80 void setNext(Function *N) { Next = N; } 81 void setPrev(Function *N) { Prev = N; } 82 83 // getNext/Prev - Return the next or previous function in the list. These 84 // methods should never be used directly, and are only used to implement the 85 // function list as part of the module. 86 // 87 Function *getNext() { return Next; } 88 const Function *getNext() const { return Next; } 89 Function *getPrev() { return Prev; } 90 const Function *getPrev() const { return Prev; } 91 92 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is 93 /// built on demand, so that the list isn't allocated until the first client 94 /// needs it. The hasLazyArguments predicate returns true if the arg list 95 /// hasn't been set up yet. 96 bool hasLazyArguments() const { 97 return SubclassData & 1; 98 } 99 void CheckLazyArguments() const { 100 if (hasLazyArguments()) 101 BuildLazyArguments(); 102 } 103 void BuildLazyArguments() const; 104 105 Function(const Function&); // DO NOT IMPLEMENT 106 void operator=(const Function&); // DO NOT IMPLEMENT 107 108 /// Function ctor - If the (optional) Module argument is specified, the 109 /// function is automatically inserted into the end of the function list for 110 /// the module. 111 /// 112 Function(const FunctionType *Ty, LinkageTypes Linkage, 113 const std::string &N = "", Module *M = 0); 114 115public: 116 static Function *Create(const FunctionType *Ty, LinkageTypes Linkage, 117 const std::string &N = "", Module *M = 0) { 118 return new(0) Function(Ty, Linkage, N, M); 119 } 120 121 ~Function(); 122 123 const Type *getReturnType() const; // Return the type of the ret val 124 const FunctionType *getFunctionType() const; // Return the FunctionType for me 125 126 /// isVarArg - Return true if this function takes a variable number of 127 /// arguments. 128 bool isVarArg() const; 129 130 /// isDeclaration - Is the body of this function unknown? (The basic block 131 /// list is empty if so.) This is true for function declarations, but not 132 /// true for function definitions. 133 /// 134 virtual bool isDeclaration() const { return BasicBlocks.empty(); } 135 136 /// getIntrinsicID - This method returns the ID number of the specified 137 /// function, or Intrinsic::not_intrinsic if the function is not an 138 /// instrinsic, or if the pointer is null. This value is always defined to be 139 /// zero to allow easy checking for whether a function is intrinsic or not. 140 /// The particular intrinsic functions which correspond to this value are 141 /// defined in llvm/Intrinsics.h. 142 /// 143 unsigned getIntrinsicID(bool noAssert = false) const; 144 bool isIntrinsic() const { return getIntrinsicID() != 0; } 145 146 /// getCallingConv()/setCallingConv(uint) - These method get and set the 147 /// calling convention of this function. The enum values for the known 148 /// calling conventions are defined in CallingConv.h. 149 unsigned getCallingConv() const { return SubclassData >> 1; } 150 void setCallingConv(unsigned CC) { 151 SubclassData = (SubclassData & 1) | (CC << 1); 152 } 153 154 /// getParamAttrs - Return the parameter attributes for this Function. 155 /// 156 const PAListPtr &getParamAttrs() const { return ParamAttrs; } 157 158 /// setParamAttrs - Set the parameter attributes for this Function. 159 /// 160 void setParamAttrs(const PAListPtr &attrs) { ParamAttrs = attrs; } 161 162 /// hasCollector/getCollector/setCollector/clearCollector - The name of the 163 /// garbage collection algorithm to use during code generation. 164 bool hasCollector() const; 165 const char *getCollector() const; 166 void setCollector(const char *Str); 167 void clearCollector(); 168 169 /// @brief Determine whether the function has the given attribute. 170 bool paramHasAttr(unsigned i, ParameterAttributes attr) const { 171 return ParamAttrs.paramHasAttr(i, attr); 172 } 173 174 /// addParamAttr - adds the attribute to the list of attributes. 175 void addParamAttr(unsigned i, ParameterAttributes attr); 176 177 /// removeParamAttr - removes the attribute from the list of attributes. 178 void removeParamAttr(unsigned i, ParameterAttributes attr); 179 180 /// @brief Extract the alignment for a call or parameter (0=unknown). 181 unsigned getParamAlignment(unsigned i) const { 182 return ParamAttrs.getParamAlignment(i); 183 } 184 185 /// @brief Determine if the function does not access memory. 186 bool doesNotAccessMemory() const { 187 return paramHasAttr(0, ParamAttr::ReadNone); 188 } 189 void setDoesNotAccessMemory(bool doesNotAccessMemory = true) { 190 if (doesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone); 191 else removeParamAttr(0, ParamAttr::ReadNone); 192 } 193 194 /// @brief Determine if the function does not access or only reads memory. 195 bool onlyReadsMemory() const { 196 return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly); 197 } 198 void setOnlyReadsMemory(bool onlyReadsMemory = true) { 199 if (onlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly); 200 else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone); 201 } 202 203 /// @brief Determine if the function cannot return. 204 bool doesNotReturn() const { 205 return paramHasAttr(0, ParamAttr::NoReturn); 206 } 207 void setDoesNotReturn(bool doesNotReturn = true) { 208 if (doesNotReturn) addParamAttr(0, ParamAttr::NoReturn); 209 else removeParamAttr(0, ParamAttr::NoReturn); 210 } 211 212 /// @brief Determine if the function cannot unwind. 213 bool doesNotThrow() const { 214 return paramHasAttr(0, ParamAttr::NoUnwind); 215 } 216 void setDoesNotThrow(bool doesNotThrow = true) { 217 if (doesNotThrow) addParamAttr(0, ParamAttr::NoUnwind); 218 else removeParamAttr(0, ParamAttr::NoUnwind); 219 } 220 221 /// @brief Determine if the function returns a structure through first 222 /// pointer argument. 223 bool hasStructRetAttr() const { 224 return paramHasAttr(1, ParamAttr::StructRet); 225 } 226 227 /// copyAttributesFrom - copy all additional attributes (those not needed to 228 /// create a Function) from the Function Src to this one. 229 void copyAttributesFrom(const GlobalValue *Src); 230 231 /// deleteBody - This method deletes the body of the function, and converts 232 /// the linkage to external. 233 /// 234 void deleteBody() { 235 dropAllReferences(); 236 setLinkage(ExternalLinkage); 237 } 238 239 /// removeFromParent - This method unlinks 'this' from the containing module, 240 /// but does not delete it. 241 /// 242 void removeFromParent(); 243 244 /// eraseFromParent - This method unlinks 'this' from the containing module 245 /// and deletes it. 246 /// 247 void eraseFromParent(); 248 249 250 /// Get the underlying elements of the Function... the basic block list is 251 /// empty for external functions. 252 /// 253 const ArgumentListType &getArgumentList() const { 254 CheckLazyArguments(); 255 return ArgumentList; 256 } 257 ArgumentListType &getArgumentList() { 258 CheckLazyArguments(); 259 return ArgumentList; 260 } 261 262 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } 263 BasicBlockListType &getBasicBlockList() { return BasicBlocks; } 264 265 const BasicBlock &getEntryBlock() const { return front(); } 266 BasicBlock &getEntryBlock() { return front(); } 267 268 //===--------------------------------------------------------------------===// 269 // Symbol Table Accessing functions... 270 271 /// getSymbolTable() - Return the symbol table... 272 /// 273 inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; } 274 inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; } 275 276 277 //===--------------------------------------------------------------------===// 278 // BasicBlock iterator forwarding functions 279 // 280 iterator begin() { return BasicBlocks.begin(); } 281 const_iterator begin() const { return BasicBlocks.begin(); } 282 iterator end () { return BasicBlocks.end(); } 283 const_iterator end () const { return BasicBlocks.end(); } 284 285 size_t size() const { return BasicBlocks.size(); } 286 bool empty() const { return BasicBlocks.empty(); } 287 const BasicBlock &front() const { return BasicBlocks.front(); } 288 BasicBlock &front() { return BasicBlocks.front(); } 289 const BasicBlock &back() const { return BasicBlocks.back(); } 290 BasicBlock &back() { return BasicBlocks.back(); } 291 292 //===--------------------------------------------------------------------===// 293 // Argument iterator forwarding functions 294 // 295 arg_iterator arg_begin() { 296 CheckLazyArguments(); 297 return ArgumentList.begin(); 298 } 299 const_arg_iterator arg_begin() const { 300 CheckLazyArguments(); 301 return ArgumentList.begin(); 302 } 303 arg_iterator arg_end() { 304 CheckLazyArguments(); 305 return ArgumentList.end(); 306 } 307 const_arg_iterator arg_end() const { 308 CheckLazyArguments(); 309 return ArgumentList.end(); 310 } 311 312 size_t arg_size() const; 313 bool arg_empty() const; 314 315 virtual void print(std::ostream &OS) const { print(OS, 0); } 316 void print(std::ostream *OS) const { if (OS) print(*OS); } 317 void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const; 318 319 /// viewCFG - This function is meant for use from the debugger. You can just 320 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 321 /// program, displaying the CFG of the current function with the code for each 322 /// basic block inside. This depends on there being a 'dot' and 'gv' program 323 /// in your path. 324 /// 325 void viewCFG() const; 326 327 /// viewCFGOnly - This function is meant for use from the debugger. It works 328 /// just like viewCFG, but it does not include the contents of basic blocks 329 /// into the nodes, just the label. If you are only interested in the CFG 330 /// this can make the graph smaller. 331 /// 332 void viewCFGOnly() const; 333 334 /// Methods for support type inquiry through isa, cast, and dyn_cast: 335 static inline bool classof(const Function *) { return true; } 336 static inline bool classof(const Value *V) { 337 return V->getValueID() == Value::FunctionVal; 338 } 339 340 /// dropAllReferences() - This method causes all the subinstructions to "let 341 /// go" of all references that they are maintaining. This allows one to 342 /// 'delete' a whole module at a time, even though there may be circular 343 /// references... first all references are dropped, and all use counts go to 344 /// zero. Then everything is deleted for real. Note that no operations are 345 /// valid on an object that has "dropped all references", except operator 346 /// delete. 347 /// 348 /// Since no other object in the module can have references into the body of a 349 /// function, dropping all references deletes the entire body of the function, 350 /// including any contained basic blocks. 351 /// 352 void dropAllReferences(); 353 354 static unsigned getBasicBlockListOffset() { 355 Function *Obj = 0; 356 return unsigned(reinterpret_cast<uintptr_t>(&Obj->BasicBlocks)); 357 } 358 static unsigned getArgumentListOffset() { 359 Function *Obj = 0; 360 return unsigned(reinterpret_cast<uintptr_t>(&Obj->ArgumentList)); 361 } 362}; 363 364inline ValueSymbolTable * 365ilist_traits<BasicBlock>::getSymTab(Function *F) { 366 return F ? &F->getValueSymbolTable() : 0; 367} 368 369inline ValueSymbolTable * 370ilist_traits<Argument>::getSymTab(Function *F) { 371 return F ? &F->getValueSymbolTable() : 0; 372} 373 374inline int 375ilist_traits<BasicBlock>::getListOffset() { 376 return Function::getBasicBlockListOffset(); 377} 378 379inline int 380ilist_traits<Argument>::getListOffset() { 381 return Function::getArgumentListOffset(); 382} 383 384 385} // End llvm namespace 386 387#endif 388