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