1 //===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the declaration of the Function class, which represents a
11 // single function/procedure in LLVM.
13 // A function basically consists of a list of basic blocks, a list of arguments,
14 // and a symbol table.
16 //===----------------------------------------------------------------------===//
18 #ifndef LLVM_FUNCTION_H
19 #define LLVM_FUNCTION_H
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"
31 // Traits for intrusive list of instructions...
32 template<> struct ilist_traits<BasicBlock>
33 : public SymbolTableListTraits<BasicBlock, Function> {
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();
43 template<> struct ilist_traits<Argument>
44 : public SymbolTableListTraits<Argument, Function> {
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();
54 typedef unsigned FunctionNotes;
55 const FunctionNotes FN_NOTE_None = 0;
56 const FunctionNotes FN_NOTE_NoInline = 1<<0;
57 const FunctionNotes FN_NOTE_AlwaysInline = 1<<1;
58 const FunctionNotes FN_NOTE_OptimizeForSize = 1<<2;
60 class Function : public GlobalValue, public Annotable,
61 public ilist_node<Function> {
63 typedef iplist<Argument> ArgumentListType;
64 typedef iplist<BasicBlock> BasicBlockListType;
66 // BasicBlock iterators...
67 typedef BasicBlockListType::iterator iterator;
68 typedef BasicBlockListType::const_iterator const_iterator;
70 typedef ArgumentListType::iterator arg_iterator;
71 typedef ArgumentListType::const_iterator const_arg_iterator;
74 // Important things that make up a function!
75 BasicBlockListType BasicBlocks; ///< The basic blocks
76 mutable ArgumentListType ArgumentList; ///< The formal arguments
77 ValueSymbolTable *SymTab; ///< Symbol table of args/instructions
78 PAListPtr ParamAttrs; ///< Parameter attributes
79 FunctionNotes Notes; ///< Function properties
81 // The Calling Convention is stored in Value::SubclassData.
82 /*unsigned CallingConvention;*/
84 friend class SymbolTableListTraits<Function, Module>;
86 void setParent(Module *parent);
88 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
89 /// built on demand, so that the list isn't allocated until the first client
90 /// needs it. The hasLazyArguments predicate returns true if the arg list
91 /// hasn't been set up yet.
92 bool hasLazyArguments() const {
93 return SubclassData & 1;
95 void CheckLazyArguments() const {
96 if (hasLazyArguments())
99 void BuildLazyArguments() const;
101 Function(const Function&); // DO NOT IMPLEMENT
102 void operator=(const Function&); // DO NOT IMPLEMENT
104 /// Function ctor - If the (optional) Module argument is specified, the
105 /// function is automatically inserted into the end of the function list for
108 Function(const FunctionType *Ty, LinkageTypes Linkage,
109 const std::string &N = "", Module *M = 0);
112 static Function *Create(const FunctionType *Ty, LinkageTypes Linkage,
113 const std::string &N = "", Module *M = 0) {
114 return new(0) Function(Ty, Linkage, N, M);
119 const Type *getReturnType() const; // Return the type of the ret val
120 const FunctionType *getFunctionType() const; // Return the FunctionType for me
122 /// isVarArg - Return true if this function takes a variable number of
124 bool isVarArg() const;
126 /// isDeclaration - Is the body of this function unknown? (The basic block
127 /// list is empty if so.) This is true for function declarations, but not
128 /// true for function definitions.
130 virtual bool isDeclaration() const { return BasicBlocks.empty(); }
132 /// getIntrinsicID - This method returns the ID number of the specified
133 /// function, or Intrinsic::not_intrinsic if the function is not an
134 /// instrinsic, or if the pointer is null. This value is always defined to be
135 /// zero to allow easy checking for whether a function is intrinsic or not.
136 /// The particular intrinsic functions which correspond to this value are
137 /// defined in llvm/Intrinsics.h.
139 unsigned getIntrinsicID(bool noAssert = false) const;
140 bool isIntrinsic() const { return getIntrinsicID() != 0; }
142 /// getCallingConv()/setCallingConv(uint) - These method get and set the
143 /// calling convention of this function. The enum values for the known
144 /// calling conventions are defined in CallingConv.h.
145 unsigned getCallingConv() const { return SubclassData >> 1; }
146 void setCallingConv(unsigned CC) {
147 SubclassData = (SubclassData & 1) | (CC << 1);
150 /// getParamAttrs - Return the parameter attributes for this Function.
152 const PAListPtr &getParamAttrs() const { return ParamAttrs; }
154 /// setParamAttrs - Set the parameter attributes for this Function.
156 void setParamAttrs(const PAListPtr &attrs) { ParamAttrs = attrs; }
158 /// getNotes - Return function notes
160 const FunctionNotes &getNotes() const { return Notes; }
162 /// setNotes - Set notes for this function
164 void setNotes(const FunctionNotes P) { Notes = Notes | P;}
166 /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
167 /// to use during code generation.
169 const char *getGC() const;
170 void setGC(const char *Str);
173 /// @brief Determine whether the function has the given attribute.
174 bool paramHasAttr(unsigned i, ParameterAttributes attr) const {
175 return ParamAttrs.paramHasAttr(i, attr);
178 /// addParamAttr - adds the attribute to the list of attributes.
179 void addParamAttr(unsigned i, ParameterAttributes attr);
181 /// removeParamAttr - removes the attribute from the list of attributes.
182 void removeParamAttr(unsigned i, ParameterAttributes attr);
184 /// @brief Extract the alignment for a call or parameter (0=unknown).
185 unsigned getParamAlignment(unsigned i) const {
186 return ParamAttrs.getParamAlignment(i);
189 /// @brief Determine if the function does not access memory.
190 bool doesNotAccessMemory() const {
191 return paramHasAttr(0, ParamAttr::ReadNone);
193 void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
194 if (DoesNotAccessMemory) addParamAttr(0, ParamAttr::ReadNone);
195 else removeParamAttr(0, ParamAttr::ReadNone);
198 /// @brief Determine if the function does not access or only reads memory.
199 bool onlyReadsMemory() const {
200 return doesNotAccessMemory() || paramHasAttr(0, ParamAttr::ReadOnly);
202 void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
203 if (OnlyReadsMemory) addParamAttr(0, ParamAttr::ReadOnly);
204 else removeParamAttr(0, ParamAttr::ReadOnly | ParamAttr::ReadNone);
207 /// @brief Determine if the function cannot return.
208 bool doesNotReturn() const {
209 return paramHasAttr(0, ParamAttr::NoReturn);
211 void setDoesNotReturn(bool DoesNotReturn = true) {
212 if (DoesNotReturn) addParamAttr(0, ParamAttr::NoReturn);
213 else removeParamAttr(0, ParamAttr::NoReturn);
216 /// @brief Determine if the function cannot unwind.
217 bool doesNotThrow() const {
218 return paramHasAttr(0, ParamAttr::NoUnwind);
220 void setDoesNotThrow(bool DoesNotThrow = true) {
221 if (DoesNotThrow) addParamAttr(0, ParamAttr::NoUnwind);
222 else removeParamAttr(0, ParamAttr::NoUnwind);
225 /// @brief Determine if the function returns a structure through first
226 /// pointer argument.
227 bool hasStructRetAttr() const {
228 return paramHasAttr(1, ParamAttr::StructRet);
231 /// copyAttributesFrom - copy all additional attributes (those not needed to
232 /// create a Function) from the Function Src to this one.
233 void copyAttributesFrom(const GlobalValue *Src);
235 /// deleteBody - This method deletes the body of the function, and converts
236 /// the linkage to external.
240 setLinkage(ExternalLinkage);
243 /// removeFromParent - This method unlinks 'this' from the containing module,
244 /// but does not delete it.
246 virtual void removeFromParent();
248 /// eraseFromParent - This method unlinks 'this' from the containing module
251 virtual void eraseFromParent();
254 /// Get the underlying elements of the Function... the basic block list is
255 /// empty for external functions.
257 const ArgumentListType &getArgumentList() const {
258 CheckLazyArguments();
261 ArgumentListType &getArgumentList() {
262 CheckLazyArguments();
266 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
267 BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
269 const BasicBlock &getEntryBlock() const { return front(); }
270 BasicBlock &getEntryBlock() { return front(); }
272 //===--------------------------------------------------------------------===//
273 // Symbol Table Accessing functions...
275 /// getSymbolTable() - Return the symbol table...
277 inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; }
278 inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
281 //===--------------------------------------------------------------------===//
282 // BasicBlock iterator forwarding functions
284 iterator begin() { return BasicBlocks.begin(); }
285 const_iterator begin() const { return BasicBlocks.begin(); }
286 iterator end () { return BasicBlocks.end(); }
287 const_iterator end () const { return BasicBlocks.end(); }
289 size_t size() const { return BasicBlocks.size(); }
290 bool empty() const { return BasicBlocks.empty(); }
291 const BasicBlock &front() const { return BasicBlocks.front(); }
292 BasicBlock &front() { return BasicBlocks.front(); }
293 const BasicBlock &back() const { return BasicBlocks.back(); }
294 BasicBlock &back() { return BasicBlocks.back(); }
296 //===--------------------------------------------------------------------===//
297 // Argument iterator forwarding functions
299 arg_iterator arg_begin() {
300 CheckLazyArguments();
301 return ArgumentList.begin();
303 const_arg_iterator arg_begin() const {
304 CheckLazyArguments();
305 return ArgumentList.begin();
307 arg_iterator arg_end() {
308 CheckLazyArguments();
309 return ArgumentList.end();
311 const_arg_iterator arg_end() const {
312 CheckLazyArguments();
313 return ArgumentList.end();
316 size_t arg_size() const;
317 bool arg_empty() const;
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
325 void viewCFG() const;
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.
332 void viewCFGOnly() const;
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;
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
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.
352 void dropAllReferences();
354 static unsigned getBasicBlockListOffset() {
356 return unsigned(reinterpret_cast<uintptr_t>(&Obj->BasicBlocks));
358 static unsigned getArgumentListOffset() {
360 return unsigned(reinterpret_cast<uintptr_t>(&Obj->ArgumentList));
364 inline ValueSymbolTable *
365 ilist_traits<BasicBlock>::getSymTab(Function *F) {
366 return F ? &F->getValueSymbolTable() : 0;
369 inline ValueSymbolTable *
370 ilist_traits<Argument>::getSymTab(Function *F) {
371 return F ? &F->getValueSymbolTable() : 0;
375 ilist_traits<BasicBlock>::getListOffset() {
376 return Function::getBasicBlockListOffset();
380 ilist_traits<Argument>::getListOffset() {
381 return Function::getArgumentListOffset();
385 } // End llvm namespace