Function.h revision c9f7500d1752feac7cece26d20007a99d21f677c
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/CallingConv.h" 23#include "llvm/BasicBlock.h" 24#include "llvm/Argument.h" 25#include "llvm/Attributes.h" 26#include "llvm/Support/Compiler.h" 27 28namespace llvm { 29 30class FunctionType; 31class LLVMContext; 32 33// Traits for intrusive list of basic blocks... 34template<> struct ilist_traits<BasicBlock> 35 : public SymbolTableListTraits<BasicBlock, Function> { 36 37 // createSentinel is used to get hold of the node that marks the end of the 38 // list... (same trick used here as in ilist_traits<Instruction>) 39 BasicBlock *createSentinel() const { 40 return static_cast<BasicBlock*>(&Sentinel); 41 } 42 static void destroySentinel(BasicBlock*) {} 43 44 BasicBlock *provideInitialHead() const { return createSentinel(); } 45 BasicBlock *ensureHead(BasicBlock*) const { return createSentinel(); } 46 static void noteHead(BasicBlock*, BasicBlock*) {} 47 48 static ValueSymbolTable *getSymTab(Function *ItemParent); 49private: 50 mutable ilist_half_node<BasicBlock> Sentinel; 51}; 52 53template<> struct ilist_traits<Argument> 54 : public SymbolTableListTraits<Argument, Function> { 55 56 Argument *createSentinel() const { 57 return static_cast<Argument*>(&Sentinel); 58 } 59 static void destroySentinel(Argument*) {} 60 61 Argument *provideInitialHead() const { return createSentinel(); } 62 Argument *ensureHead(Argument*) const { return createSentinel(); } 63 static void noteHead(Argument*, Argument*) {} 64 65 static ValueSymbolTable *getSymTab(Function *ItemParent); 66private: 67 mutable ilist_half_node<Argument> Sentinel; 68}; 69 70class Function : public GlobalValue, 71 public ilist_node<Function> { 72public: 73 typedef iplist<Argument> ArgumentListType; 74 typedef iplist<BasicBlock> BasicBlockListType; 75 76 // BasicBlock iterators... 77 typedef BasicBlockListType::iterator iterator; 78 typedef BasicBlockListType::const_iterator const_iterator; 79 80 typedef ArgumentListType::iterator arg_iterator; 81 typedef ArgumentListType::const_iterator const_arg_iterator; 82 83private: 84 // Important things that make up a function! 85 BasicBlockListType BasicBlocks; ///< The basic blocks 86 mutable ArgumentListType ArgumentList; ///< The formal arguments 87 ValueSymbolTable *SymTab; ///< Symbol table of args/instructions 88 AttrListPtr AttributeList; ///< Parameter attributes 89 90 // HasLazyArguments is stored in Value::SubclassData. 91 /*bool HasLazyArguments;*/ 92 93 // The Calling Convention is stored in Value::SubclassData. 94 /*CallingConv::ID CallingConvention;*/ 95 96 friend class SymbolTableListTraits<Function, Module>; 97 98 void setParent(Module *parent); 99 100 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is 101 /// built on demand, so that the list isn't allocated until the first client 102 /// needs it. The hasLazyArguments predicate returns true if the arg list 103 /// hasn't been set up yet. 104 bool hasLazyArguments() const { 105 return getSubclassDataFromValue() & 1; 106 } 107 void CheckLazyArguments() const { 108 if (hasLazyArguments()) 109 BuildLazyArguments(); 110 } 111 void BuildLazyArguments() const; 112 113 Function(const Function&); // DO NOT IMPLEMENT 114 void operator=(const Function&); // DO NOT IMPLEMENT 115 116 /// Function ctor - If the (optional) Module argument is specified, the 117 /// function is automatically inserted into the end of the function list for 118 /// the module. 119 /// 120 Function(const FunctionType *Ty, LinkageTypes Linkage, 121 const Twine &N = "", Module *M = 0); 122 123public: 124 static Function *Create(const FunctionType *Ty, LinkageTypes Linkage, 125 const Twine &N = "", Module *M = 0) { 126 return new(0) Function(Ty, Linkage, N, M); 127 } 128 129 ~Function(); 130 131 const Type *getReturnType() const; // Return the type of the ret val 132 const FunctionType *getFunctionType() const; // Return the FunctionType for me 133 134 /// getContext - Return a pointer to the LLVMContext associated with this 135 /// function, or NULL if this function is not bound to a context yet. 136 LLVMContext &getContext() const; 137 138 /// isVarArg - Return true if this function takes a variable number of 139 /// arguments. 140 bool isVarArg() const; 141 142 /// isDeclaration - Is the body of this function unknown? (The basic block 143 /// list is empty if so.) This is true for function declarations, but not 144 /// true for function definitions. 145 /// 146 virtual bool isDeclaration() const { return BasicBlocks.empty(); } 147 148 /// getIntrinsicID - This method returns the ID number of the specified 149 /// function, or Intrinsic::not_intrinsic if the function is not an 150 /// instrinsic, or if the pointer is null. This value is always defined to be 151 /// zero to allow easy checking for whether a function is intrinsic or not. 152 /// The particular intrinsic functions which correspond to this value are 153 /// defined in llvm/Intrinsics.h. 154 /// 155 unsigned getIntrinsicID() const ATTRIBUTE_READONLY; 156 bool isIntrinsic() const { return getIntrinsicID() != 0; } 157 158 /// getCallingConv()/setCallingConv(CC) - These method get and set the 159 /// calling convention of this function. The enum values for the known 160 /// calling conventions are defined in CallingConv.h. 161 CallingConv::ID getCallingConv() const { 162 return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 1); 163 } 164 void setCallingConv(CallingConv::ID CC) { 165 setValueSubclassData((getSubclassDataFromValue() & 1) | 166 (static_cast<unsigned>(CC) << 1)); 167 } 168 169 /// getAttributes - Return the attribute list for this Function. 170 /// 171 const AttrListPtr &getAttributes() const { return AttributeList; } 172 173 /// setAttributes - Set the attribute list for this Function. 174 /// 175 void setAttributes(const AttrListPtr &attrs) { AttributeList = attrs; } 176 177 /// hasFnAttr - Return true if this function has the given attribute. 178 bool hasFnAttr(Attributes N) const { 179 // Function Attributes are stored at ~0 index 180 return AttributeList.paramHasAttr(~0U, N); 181 } 182 183 /// addFnAttr - Add function attributes to this function. 184 /// 185 void addFnAttr(Attributes N) { 186 // Function Attributes are stored at ~0 index 187 addAttribute(~0U, N); 188 } 189 190 /// removeFnAttr - Remove function attributes from this function. 191 /// 192 void removeFnAttr(Attributes N) { 193 // Function Attributes are stored at ~0 index 194 removeAttribute(~0U, N); 195 } 196 197 /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm 198 /// to use during code generation. 199 bool hasGC() const; 200 const char *getGC() const; 201 void setGC(const char *Str); 202 void clearGC(); 203 204 /// @brief Determine whether the function has the given attribute. 205 bool paramHasAttr(unsigned i, Attributes attr) const { 206 return AttributeList.paramHasAttr(i, attr); 207 } 208 209 /// addAttribute - adds the attribute to the list of attributes. 210 void addAttribute(unsigned i, Attributes attr); 211 212 /// removeAttribute - removes the attribute from the list of attributes. 213 void removeAttribute(unsigned i, Attributes attr); 214 215 /// @brief Extract the alignment for a call or parameter (0=unknown). 216 unsigned getParamAlignment(unsigned i) const { 217 return AttributeList.getParamAlignment(i); 218 } 219 220 /// @brief Determine if the function does not access memory. 221 bool doesNotAccessMemory() const { 222 return hasFnAttr(Attribute::ReadNone); 223 } 224 void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) { 225 if (DoesNotAccessMemory) addFnAttr(Attribute::ReadNone); 226 else removeFnAttr(Attribute::ReadNone); 227 } 228 229 /// @brief Determine if the function does not access or only reads memory. 230 bool onlyReadsMemory() const { 231 return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly); 232 } 233 void setOnlyReadsMemory(bool OnlyReadsMemory = true) { 234 if (OnlyReadsMemory) addFnAttr(Attribute::ReadOnly); 235 else removeFnAttr(Attribute::ReadOnly | Attribute::ReadNone); 236 } 237 238 /// @brief Determine if the function cannot return. 239 bool doesNotReturn() const { 240 return hasFnAttr(Attribute::NoReturn); 241 } 242 void setDoesNotReturn(bool DoesNotReturn = true) { 243 if (DoesNotReturn) addFnAttr(Attribute::NoReturn); 244 else removeFnAttr(Attribute::NoReturn); 245 } 246 247 /// @brief Determine if the function cannot unwind. 248 bool doesNotThrow() const { 249 return hasFnAttr(Attribute::NoUnwind); 250 } 251 void setDoesNotThrow(bool DoesNotThrow = true) { 252 if (DoesNotThrow) addFnAttr(Attribute::NoUnwind); 253 else removeFnAttr(Attribute::NoUnwind); 254 } 255 256 /// @brief Determine if the function returns a structure through first 257 /// pointer argument. 258 bool hasStructRetAttr() const { 259 return paramHasAttr(1, Attribute::StructRet); 260 } 261 262 /// @brief Determine if the parameter does not alias other parameters. 263 /// @param n The parameter to check. 1 is the first parameter, 0 is the return 264 bool doesNotAlias(unsigned n) const { 265 return paramHasAttr(n, Attribute::NoAlias); 266 } 267 void setDoesNotAlias(unsigned n, bool DoesNotAlias = true) { 268 if (DoesNotAlias) addAttribute(n, Attribute::NoAlias); 269 else removeAttribute(n, Attribute::NoAlias); 270 } 271 272 /// @brief Determine if the parameter can be captured. 273 /// @param n The parameter to check. 1 is the first parameter, 0 is the return 274 bool doesNotCapture(unsigned n) const { 275 return paramHasAttr(n, Attribute::NoCapture); 276 } 277 void setDoesNotCapture(unsigned n, bool DoesNotCapture = true) { 278 if (DoesNotCapture) addAttribute(n, Attribute::NoCapture); 279 else removeAttribute(n, Attribute::NoCapture); 280 } 281 282 /// copyAttributesFrom - copy all additional attributes (those not needed to 283 /// create a Function) from the Function Src to this one. 284 void copyAttributesFrom(const GlobalValue *Src); 285 286 /// deleteBody - This method deletes the body of the function, and converts 287 /// the linkage to external. 288 /// 289 void deleteBody() { 290 dropAllReferences(); 291 setLinkage(ExternalLinkage); 292 } 293 294 /// removeFromParent - This method unlinks 'this' from the containing module, 295 /// but does not delete it. 296 /// 297 virtual void removeFromParent(); 298 299 /// eraseFromParent - This method unlinks 'this' from the containing module 300 /// and deletes it. 301 /// 302 virtual void eraseFromParent(); 303 304 305 /// Get the underlying elements of the Function... the basic block list is 306 /// empty for external functions. 307 /// 308 const ArgumentListType &getArgumentList() const { 309 CheckLazyArguments(); 310 return ArgumentList; 311 } 312 ArgumentListType &getArgumentList() { 313 CheckLazyArguments(); 314 return ArgumentList; 315 } 316 static iplist<Argument> Function::*getSublistAccess(Argument*) { 317 return &Function::ArgumentList; 318 } 319 320 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } 321 BasicBlockListType &getBasicBlockList() { return BasicBlocks; } 322 static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) { 323 return &Function::BasicBlocks; 324 } 325 326 const BasicBlock &getEntryBlock() const { return front(); } 327 BasicBlock &getEntryBlock() { return front(); } 328 329 //===--------------------------------------------------------------------===// 330 // Symbol Table Accessing functions... 331 332 /// getSymbolTable() - Return the symbol table... 333 /// 334 inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; } 335 inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; } 336 337 338 //===--------------------------------------------------------------------===// 339 // BasicBlock iterator forwarding functions 340 // 341 iterator begin() { return BasicBlocks.begin(); } 342 const_iterator begin() const { return BasicBlocks.begin(); } 343 iterator end () { return BasicBlocks.end(); } 344 const_iterator end () const { return BasicBlocks.end(); } 345 346 size_t size() const { return BasicBlocks.size(); } 347 bool empty() const { return BasicBlocks.empty(); } 348 const BasicBlock &front() const { return BasicBlocks.front(); } 349 BasicBlock &front() { return BasicBlocks.front(); } 350 const BasicBlock &back() const { return BasicBlocks.back(); } 351 BasicBlock &back() { return BasicBlocks.back(); } 352 353 //===--------------------------------------------------------------------===// 354 // Argument iterator forwarding functions 355 // 356 arg_iterator arg_begin() { 357 CheckLazyArguments(); 358 return ArgumentList.begin(); 359 } 360 const_arg_iterator arg_begin() const { 361 CheckLazyArguments(); 362 return ArgumentList.begin(); 363 } 364 arg_iterator arg_end() { 365 CheckLazyArguments(); 366 return ArgumentList.end(); 367 } 368 const_arg_iterator arg_end() const { 369 CheckLazyArguments(); 370 return ArgumentList.end(); 371 } 372 373 size_t arg_size() const; 374 bool arg_empty() const; 375 376 /// viewCFG - This function is meant for use from the debugger. You can just 377 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 378 /// program, displaying the CFG of the current function with the code for each 379 /// basic block inside. This depends on there being a 'dot' and 'gv' program 380 /// in your path. 381 /// 382 void viewCFG() const; 383 384 /// viewCFGOnly - This function is meant for use from the debugger. It works 385 /// just like viewCFG, but it does not include the contents of basic blocks 386 /// into the nodes, just the label. If you are only interested in the CFG 387 /// this can make the graph smaller. 388 /// 389 void viewCFGOnly() const; 390 391 /// Methods for support type inquiry through isa, cast, and dyn_cast: 392 static inline bool classof(const Function *) { return true; } 393 static inline bool classof(const Value *V) { 394 return V->getValueID() == Value::FunctionVal; 395 } 396 397 /// dropAllReferences() - This method causes all the subinstructions to "let 398 /// go" of all references that they are maintaining. This allows one to 399 /// 'delete' a whole module at a time, even though there may be circular 400 /// references... first all references are dropped, and all use counts go to 401 /// zero. Then everything is deleted for real. Note that no operations are 402 /// valid on an object that has "dropped all references", except operator 403 /// delete. 404 /// 405 /// Since no other object in the module can have references into the body of a 406 /// function, dropping all references deletes the entire body of the function, 407 /// including any contained basic blocks. 408 /// 409 void dropAllReferences(); 410 411 /// hasAddressTaken - returns true if there are any uses of this function 412 /// other than direct calls or invokes to it. Optionally passes back the 413 /// offending user for diagnostic purposes. 414 /// 415 bool hasAddressTaken(const User** = 0) const; 416 417private: 418 // Shadow Value::setValueSubclassData with a private forwarding method so that 419 // subclasses cannot accidentally use it. 420 void setValueSubclassData(unsigned short D) { 421 Value::setValueSubclassData(D); 422 } 423}; 424 425inline ValueSymbolTable * 426ilist_traits<BasicBlock>::getSymTab(Function *F) { 427 return F ? &F->getValueSymbolTable() : 0; 428} 429 430inline ValueSymbolTable * 431ilist_traits<Argument>::getSymTab(Function *F) { 432 return F ? &F->getValueSymbolTable() : 0; 433} 434 435} // End llvm namespace 436 437#endif 438