Function.h revision 0b8c9a80f20772c3793201ab5b251d3520b9cea3
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/IR/Argument.h" 22#include "llvm/IR/Attributes.h" 23#include "llvm/IR/BasicBlock.h" 24#include "llvm/IR/CallingConv.h" 25#include "llvm/IR/GlobalValue.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 AttributeSet 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&) LLVM_DELETED_FUNCTION; 114 void operator=(const Function&) LLVM_DELETED_FUNCTION; 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(FunctionType *Ty, LinkageTypes Linkage, 121 const Twine &N = "", Module *M = 0); 122 123public: 124 static Function *Create(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 Type *getReturnType() const; // Return the type of the ret val 132 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 /// getIntrinsicID - This method returns the ID number of the specified 143 /// function, or Intrinsic::not_intrinsic if the function is not an 144 /// instrinsic, or if the pointer is null. This value is always defined to be 145 /// zero to allow easy checking for whether a function is intrinsic or not. 146 /// The particular intrinsic functions which correspond to this value are 147 /// defined in llvm/Intrinsics.h. 148 /// 149 unsigned getIntrinsicID() const LLVM_READONLY; 150 bool isIntrinsic() const { return getName().startswith("llvm."); } 151 152 /// getCallingConv()/setCallingConv(CC) - These method get and set the 153 /// calling convention of this function. The enum values for the known 154 /// calling conventions are defined in CallingConv.h. 155 CallingConv::ID getCallingConv() const { 156 return static_cast<CallingConv::ID>(getSubclassDataFromValue() >> 1); 157 } 158 void setCallingConv(CallingConv::ID CC) { 159 setValueSubclassData((getSubclassDataFromValue() & 1) | 160 (static_cast<unsigned>(CC) << 1)); 161 } 162 163 /// getAttributes - Return the attribute list for this Function. 164 /// 165 const AttributeSet &getAttributes() const { return AttributeList; } 166 167 /// setAttributes - Set the attribute list for this Function. 168 /// 169 void setAttributes(const AttributeSet &attrs) { AttributeList = attrs; } 170 171 /// addFnAttr - Add function attributes to this function. 172 /// 173 void addFnAttr(Attribute::AttrKind N) { 174 // Function Attribute are stored at ~0 index 175 addAttribute(AttributeSet::FunctionIndex, Attribute::get(getContext(), N)); 176 } 177 178 /// removeFnAttr - Remove function attributes from this function. 179 /// 180 void removeFnAttr(Attribute N) { 181 // Function Attribute are stored at ~0 index 182 removeAttribute(~0U, N); 183 } 184 185 /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm 186 /// to use during code generation. 187 bool hasGC() const; 188 const char *getGC() const; 189 void setGC(const char *Str); 190 void clearGC(); 191 192 /// addAttribute - adds the attribute to the list of attributes. 193 void addAttribute(unsigned i, Attribute attr); 194 195 /// removeAttribute - removes the attribute from the list of attributes. 196 void removeAttribute(unsigned i, Attribute attr); 197 198 /// @brief Extract the alignment for a call or parameter (0=unknown). 199 unsigned getParamAlignment(unsigned i) const { 200 return AttributeList.getParamAlignment(i); 201 } 202 203 /// @brief Determine if the function does not access memory. 204 bool doesNotAccessMemory() const { 205 return AttributeList.hasAttribute(AttributeSet::FunctionIndex, 206 Attribute::ReadNone); 207 } 208 void setDoesNotAccessMemory() { 209 addFnAttr(Attribute::ReadNone); 210 } 211 212 /// @brief Determine if the function does not access or only reads memory. 213 bool onlyReadsMemory() const { 214 return doesNotAccessMemory() || 215 AttributeList.hasAttribute(AttributeSet::FunctionIndex, 216 Attribute::ReadOnly); 217 } 218 void setOnlyReadsMemory() { 219 addFnAttr(Attribute::ReadOnly); 220 } 221 222 /// @brief Determine if the function cannot return. 223 bool doesNotReturn() const { 224 return AttributeList.hasAttribute(AttributeSet::FunctionIndex, 225 Attribute::NoReturn); 226 } 227 void setDoesNotReturn() { 228 addFnAttr(Attribute::NoReturn); 229 } 230 231 /// @brief Determine if the function cannot unwind. 232 bool doesNotThrow() const { 233 return AttributeList.hasAttribute(AttributeSet::FunctionIndex, 234 Attribute::NoUnwind); 235 } 236 void setDoesNotThrow() { 237 addFnAttr(Attribute::NoUnwind); 238 } 239 240 /// @brief Determine if the call cannot be duplicated. 241 bool cannotDuplicate() const { 242 return AttributeList.hasAttribute(AttributeSet::FunctionIndex, 243 Attribute::NoDuplicate); 244 } 245 void setCannotDuplicate() { 246 addFnAttr(Attribute::NoDuplicate); 247 } 248 249 /// @brief True if the ABI mandates (or the user requested) that this 250 /// function be in a unwind table. 251 bool hasUWTable() const { 252 return AttributeList.hasAttribute(AttributeSet::FunctionIndex, 253 Attribute::UWTable); 254 } 255 void setHasUWTable() { 256 addFnAttr(Attribute::UWTable); 257 } 258 259 /// @brief True if this function needs an unwind table. 260 bool needsUnwindTableEntry() const { 261 return hasUWTable() || !doesNotThrow(); 262 } 263 264 /// @brief Determine if the function returns a structure through first 265 /// pointer argument. 266 bool hasStructRetAttr() const { 267 return AttributeList.hasAttribute(1, Attribute::StructRet); 268 } 269 270 /// @brief Determine if the parameter does not alias other parameters. 271 /// @param n The parameter to check. 1 is the first parameter, 0 is the return 272 bool doesNotAlias(unsigned n) const { 273 return AttributeList.hasAttribute(n, Attribute::NoAlias); 274 } 275 void setDoesNotAlias(unsigned n) { 276 addAttribute(n, Attribute::get(getContext(), Attribute::NoAlias)); 277 } 278 279 /// @brief Determine if the parameter can be captured. 280 /// @param n The parameter to check. 1 is the first parameter, 0 is the return 281 bool doesNotCapture(unsigned n) const { 282 return AttributeList.hasAttribute(n, Attribute::NoCapture); 283 } 284 void setDoesNotCapture(unsigned n) { 285 addAttribute(n, Attribute::get(getContext(), Attribute::NoCapture)); 286 } 287 288 /// copyAttributesFrom - copy all additional attributes (those not needed to 289 /// create a Function) from the Function Src to this one. 290 void copyAttributesFrom(const GlobalValue *Src); 291 292 /// deleteBody - This method deletes the body of the function, and converts 293 /// the linkage to external. 294 /// 295 void deleteBody() { 296 dropAllReferences(); 297 setLinkage(ExternalLinkage); 298 } 299 300 /// removeFromParent - This method unlinks 'this' from the containing module, 301 /// but does not delete it. 302 /// 303 virtual void removeFromParent(); 304 305 /// eraseFromParent - This method unlinks 'this' from the containing module 306 /// and deletes it. 307 /// 308 virtual void eraseFromParent(); 309 310 311 /// Get the underlying elements of the Function... the basic block list is 312 /// empty for external functions. 313 /// 314 const ArgumentListType &getArgumentList() const { 315 CheckLazyArguments(); 316 return ArgumentList; 317 } 318 ArgumentListType &getArgumentList() { 319 CheckLazyArguments(); 320 return ArgumentList; 321 } 322 static iplist<Argument> Function::*getSublistAccess(Argument*) { 323 return &Function::ArgumentList; 324 } 325 326 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } 327 BasicBlockListType &getBasicBlockList() { return BasicBlocks; } 328 static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) { 329 return &Function::BasicBlocks; 330 } 331 332 const BasicBlock &getEntryBlock() const { return front(); } 333 BasicBlock &getEntryBlock() { return front(); } 334 335 //===--------------------------------------------------------------------===// 336 // Symbol Table Accessing functions... 337 338 /// getSymbolTable() - Return the symbol table... 339 /// 340 inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; } 341 inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; } 342 343 344 //===--------------------------------------------------------------------===// 345 // BasicBlock iterator forwarding functions 346 // 347 iterator begin() { return BasicBlocks.begin(); } 348 const_iterator begin() const { return BasicBlocks.begin(); } 349 iterator end () { return BasicBlocks.end(); } 350 const_iterator end () const { return BasicBlocks.end(); } 351 352 size_t size() const { return BasicBlocks.size(); } 353 bool empty() const { return BasicBlocks.empty(); } 354 const BasicBlock &front() const { return BasicBlocks.front(); } 355 BasicBlock &front() { return BasicBlocks.front(); } 356 const BasicBlock &back() const { return BasicBlocks.back(); } 357 BasicBlock &back() { return BasicBlocks.back(); } 358 359 //===--------------------------------------------------------------------===// 360 // Argument iterator forwarding functions 361 // 362 arg_iterator arg_begin() { 363 CheckLazyArguments(); 364 return ArgumentList.begin(); 365 } 366 const_arg_iterator arg_begin() const { 367 CheckLazyArguments(); 368 return ArgumentList.begin(); 369 } 370 arg_iterator arg_end() { 371 CheckLazyArguments(); 372 return ArgumentList.end(); 373 } 374 const_arg_iterator arg_end() const { 375 CheckLazyArguments(); 376 return ArgumentList.end(); 377 } 378 379 size_t arg_size() const; 380 bool arg_empty() const; 381 382 /// viewCFG - This function is meant for use from the debugger. You can just 383 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 384 /// program, displaying the CFG of the current function with the code for each 385 /// basic block inside. This depends on there being a 'dot' and 'gv' program 386 /// in your path. 387 /// 388 void viewCFG() const; 389 390 /// viewCFGOnly - This function is meant for use from the debugger. It works 391 /// just like viewCFG, but it does not include the contents of basic blocks 392 /// into the nodes, just the label. If you are only interested in the CFG 393 /// this can make the graph smaller. 394 /// 395 void viewCFGOnly() const; 396 397 /// Methods for support type inquiry through isa, cast, and dyn_cast: 398 static inline bool classof(const Value *V) { 399 return V->getValueID() == Value::FunctionVal; 400 } 401 402 /// dropAllReferences() - This method causes all the subinstructions to "let 403 /// go" of all references that they are maintaining. This allows one to 404 /// 'delete' a whole module at a time, even though there may be circular 405 /// references... first all references are dropped, and all use counts go to 406 /// zero. Then everything is deleted for real. Note that no operations are 407 /// valid on an object that has "dropped all references", except operator 408 /// delete. 409 /// 410 /// Since no other object in the module can have references into the body of a 411 /// function, dropping all references deletes the entire body of the function, 412 /// including any contained basic blocks. 413 /// 414 void dropAllReferences(); 415 416 /// hasAddressTaken - returns true if there are any uses of this function 417 /// other than direct calls or invokes to it, or blockaddress expressions. 418 /// Optionally passes back an offending user for diagnostic purposes. 419 /// 420 bool hasAddressTaken(const User** = 0) const; 421 422 /// isDefTriviallyDead - Return true if it is trivially safe to remove 423 /// this function definition from the module (because it isn't externally 424 /// visible, does not have its address taken, and has no callers). To make 425 /// this more accurate, call removeDeadConstantUsers first. 426 bool isDefTriviallyDead() const; 427 428 /// callsFunctionThatReturnsTwice - Return true if the function has a call to 429 /// setjmp or other function that gcc recognizes as "returning twice". 430 bool callsFunctionThatReturnsTwice() const; 431 432private: 433 // Shadow Value::setValueSubclassData with a private forwarding method so that 434 // subclasses cannot accidentally use it. 435 void setValueSubclassData(unsigned short D) { 436 Value::setValueSubclassData(D); 437 } 438}; 439 440inline ValueSymbolTable * 441ilist_traits<BasicBlock>::getSymTab(Function *F) { 442 return F ? &F->getValueSymbolTable() : 0; 443} 444 445inline ValueSymbolTable * 446ilist_traits<Argument>::getSymTab(Function *F) { 447 return F ? &F->getValueSymbolTable() : 0; 448} 449 450} // End llvm namespace 451 452#endif 453