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/CallingConv.h"
23
#include "llvm/BasicBlock.h"
24
#include "llvm/Argument.h"
25
#include "llvm/Attributes.h"
26
#include "llvm/Support/Compiler.h"
33
// Traits for intrusive list of basic blocks...
34
template<> struct ilist_traits<BasicBlock>
35
: public SymbolTableListTraits<BasicBlock, Function> {
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);
42
static void destroySentinel(BasicBlock*) {}
44
BasicBlock *provideInitialHead() const { return createSentinel(); }
45
BasicBlock *ensureHead(BasicBlock*) const { return createSentinel(); }
46
static void noteHead(BasicBlock*, BasicBlock*) {}
48
static ValueSymbolTable *getSymTab(Function *ItemParent);
50
mutable ilist_half_node<BasicBlock> Sentinel;
53
template<> struct ilist_traits<Argument>
54
: public SymbolTableListTraits<Argument, Function> {
56
Argument *createSentinel() const {
57
return static_cast<Argument*>(&Sentinel);
59
static void destroySentinel(Argument*) {}
61
Argument *provideInitialHead() const { return createSentinel(); }
62
Argument *ensureHead(Argument*) const { return createSentinel(); }
63
static void noteHead(Argument*, Argument*) {}
65
static ValueSymbolTable *getSymTab(Function *ItemParent);
67
mutable ilist_half_node<Argument> Sentinel;
70
class Function : public GlobalValue,
71
public ilist_node<Function> {
73
typedef iplist<Argument> ArgumentListType;
74
typedef iplist<BasicBlock> BasicBlockListType;
76
// BasicBlock iterators...
77
typedef BasicBlockListType::iterator iterator;
78
typedef BasicBlockListType::const_iterator const_iterator;
80
typedef ArgumentListType::iterator arg_iterator;
81
typedef ArgumentListType::const_iterator const_arg_iterator;
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
90
// HasLazyArguments is stored in Value::SubclassData.
91
/*bool HasLazyArguments;*/
93
// The Calling Convention is stored in Value::SubclassData.
94
/*CallingConv::ID CallingConvention;*/
96
friend class SymbolTableListTraits<Function, Module>;
98
void setParent(Module *parent);
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;
107
void CheckLazyArguments() const {
108
if (hasLazyArguments())
109
BuildLazyArguments();
111
void BuildLazyArguments() const;
113
Function(const Function&); // DO NOT IMPLEMENT
114
void operator=(const Function&); // DO NOT IMPLEMENT
116
/// Function ctor - If the (optional) Module argument is specified, the
117
/// function is automatically inserted into the end of the function list for
120
Function(const FunctionType *Ty, LinkageTypes Linkage,
121
const Twine &N = "", Module *M = 0);
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);
131
const Type *getReturnType() const; // Return the type of the ret val
132
const FunctionType *getFunctionType() const; // Return the FunctionType for me
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;
138
/// isVarArg - Return true if this function takes a variable number of
140
bool isVarArg() const;
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.
146
virtual bool isDeclaration() const { return BasicBlocks.empty(); }
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.
155
unsigned getIntrinsicID() const ATTRIBUTE_READONLY;
156
bool isIntrinsic() const { return getIntrinsicID() != 0; }
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);
164
void setCallingConv(CallingConv::ID CC) {
165
setValueSubclassData((getSubclassDataFromValue() & 1) |
166
(static_cast<unsigned>(CC) << 1));
169
/// getAttributes - Return the attribute list for this Function.
171
const AttrListPtr &getAttributes() const { return AttributeList; }
173
/// setAttributes - Set the attribute list for this Function.
175
void setAttributes(const AttrListPtr &attrs) { AttributeList = attrs; }
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);
183
/// addFnAttr - Add function attributes to this function.
185
void addFnAttr(Attributes N) {
186
// Function Attributes are stored at ~0 index
187
addAttribute(~0U, N);
190
/// removeFnAttr - Remove function attributes from this function.
192
void removeFnAttr(Attributes N) {
193
// Function Attributes are stored at ~0 index
194
removeAttribute(~0U, N);
197
/// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
198
/// to use during code generation.
200
const char *getGC() const;
201
void setGC(const char *Str);
204
/// @brief Determine whether the function has the given attribute.
205
bool paramHasAttr(unsigned i, Attributes attr) const {
206
return AttributeList.paramHasAttr(i, attr);
209
/// addAttribute - adds the attribute to the list of attributes.
210
void addAttribute(unsigned i, Attributes attr);
212
/// removeAttribute - removes the attribute from the list of attributes.
213
void removeAttribute(unsigned i, Attributes attr);
215
/// @brief Extract the alignment for a call or parameter (0=unknown).
216
unsigned getParamAlignment(unsigned i) const {
217
return AttributeList.getParamAlignment(i);
220
/// @brief Determine if the function does not access memory.
221
bool doesNotAccessMemory() const {
222
return hasFnAttr(Attribute::ReadNone);
224
void setDoesNotAccessMemory(bool DoesNotAccessMemory = true) {
225
if (DoesNotAccessMemory) addFnAttr(Attribute::ReadNone);
226
else removeFnAttr(Attribute::ReadNone);
229
/// @brief Determine if the function does not access or only reads memory.
230
bool onlyReadsMemory() const {
231
return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
233
void setOnlyReadsMemory(bool OnlyReadsMemory = true) {
234
if (OnlyReadsMemory) addFnAttr(Attribute::ReadOnly);
235
else removeFnAttr(Attribute::ReadOnly | Attribute::ReadNone);
238
/// @brief Determine if the function cannot return.
239
bool doesNotReturn() const {
240
return hasFnAttr(Attribute::NoReturn);
242
void setDoesNotReturn(bool DoesNotReturn = true) {
243
if (DoesNotReturn) addFnAttr(Attribute::NoReturn);
244
else removeFnAttr(Attribute::NoReturn);
247
/// @brief Determine if the function cannot unwind.
248
bool doesNotThrow() const {
249
return hasFnAttr(Attribute::NoUnwind);
251
void setDoesNotThrow(bool DoesNotThrow = true) {
252
if (DoesNotThrow) addFnAttr(Attribute::NoUnwind);
253
else removeFnAttr(Attribute::NoUnwind);
256
/// @brief Determine if the function returns a structure through first
257
/// pointer argument.
258
bool hasStructRetAttr() const {
259
return paramHasAttr(1, Attribute::StructRet);
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);
267
void setDoesNotAlias(unsigned n, bool DoesNotAlias = true) {
268
if (DoesNotAlias) addAttribute(n, Attribute::NoAlias);
269
else removeAttribute(n, Attribute::NoAlias);
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);
277
void setDoesNotCapture(unsigned n, bool DoesNotCapture = true) {
278
if (DoesNotCapture) addAttribute(n, Attribute::NoCapture);
279
else removeAttribute(n, Attribute::NoCapture);
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);
286
/// deleteBody - This method deletes the body of the function, and converts
287
/// the linkage to external.
291
setLinkage(ExternalLinkage);
294
/// removeFromParent - This method unlinks 'this' from the containing module,
295
/// but does not delete it.
297
virtual void removeFromParent();
299
/// eraseFromParent - This method unlinks 'this' from the containing module
302
virtual void eraseFromParent();
305
/// Get the underlying elements of the Function... the basic block list is
306
/// empty for external functions.
308
const ArgumentListType &getArgumentList() const {
309
CheckLazyArguments();
312
ArgumentListType &getArgumentList() {
313
CheckLazyArguments();
316
static iplist<Argument> Function::*getSublistAccess(Argument*) {
317
return &Function::ArgumentList;
320
const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
321
BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
322
static iplist<BasicBlock> Function::*getSublistAccess(BasicBlock*) {
323
return &Function::BasicBlocks;
326
const BasicBlock &getEntryBlock() const { return front(); }
327
BasicBlock &getEntryBlock() { return front(); }
329
//===--------------------------------------------------------------------===//
330
// Symbol Table Accessing functions...
332
/// getSymbolTable() - Return the symbol table...
334
inline ValueSymbolTable &getValueSymbolTable() { return *SymTab; }
335
inline const ValueSymbolTable &getValueSymbolTable() const { return *SymTab; }
338
//===--------------------------------------------------------------------===//
339
// BasicBlock iterator forwarding functions
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(); }
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(); }
353
//===--------------------------------------------------------------------===//
354
// Argument iterator forwarding functions
356
arg_iterator arg_begin() {
357
CheckLazyArguments();
358
return ArgumentList.begin();
360
const_arg_iterator arg_begin() const {
361
CheckLazyArguments();
362
return ArgumentList.begin();
364
arg_iterator arg_end() {
365
CheckLazyArguments();
366
return ArgumentList.end();
368
const_arg_iterator arg_end() const {
369
CheckLazyArguments();
370
return ArgumentList.end();
373
size_t arg_size() const;
374
bool arg_empty() const;
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
382
void viewCFG() const;
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.
389
void viewCFGOnly() const;
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;
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
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.
409
void dropAllReferences();
411
/// hasAddressTaken - returns true if there are any uses of this function
412
/// other than direct calls or invokes to it.
413
bool hasAddressTaken() const;
415
// Shadow Value::setValueSubclassData with a private forwarding method so that
416
// subclasses cannot accidentally use it.
417
void setValueSubclassData(unsigned short D) {
418
Value::setValueSubclassData(D);
422
inline ValueSymbolTable *
423
ilist_traits<BasicBlock>::getSymTab(Function *F) {
424
return F ? &F->getValueSymbolTable() : 0;
427
inline ValueSymbolTable *
428
ilist_traits<Argument>::getSymTab(Function *F) {
429
return F ? &F->getValueSymbolTable() : 0;
432
} // End llvm namespace