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