Function.h revision c063502e326fe0206942192773b263a3d88d93f5 
1//===-- llvm/Function.h - Class to represent a single function --*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source 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
26namespace llvm {
27
28class FunctionType;
29
30// Traits for intrusive list of instructions...
31template<> struct ilist_traits<BasicBlock>
32  : public SymbolTableListTraits<BasicBlock, Function, Function> {
33
34  // createNode is used to create a node that marks the end of the list...
35  static BasicBlock *createNode();
36
37  static iplist<BasicBlock> &getList(Function *F);
38};
39
40template<> struct ilist_traits<Argument>
41  : public SymbolTableListTraits<Argument, Function, Function> {
42
43  // createNode is used to create a node that marks the end of the list...
44  static Argument *createNode();
45  static iplist<Argument> &getList(Function *F);
46};
47
48class Function : public GlobalValue, public Annotable {
49public:
50  typedef iplist<Argument> ArgumentListType;
51  typedef iplist<BasicBlock> BasicBlockListType;
52
53  // BasicBlock iterators...
54  typedef BasicBlockListType::iterator iterator;
55  typedef BasicBlockListType::const_iterator const_iterator;
56  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
57  typedef std::reverse_iterator<iterator>             reverse_iterator;
58
59  typedef ArgumentListType::iterator aiterator;
60  typedef ArgumentListType::const_iterator const_aiterator;
61  typedef std::reverse_iterator<const_aiterator> const_reverse_aiterator;
62  typedef std::reverse_iterator<aiterator>             reverse_aiterator;
63
64private:
65  // Important things that make up a function!
66  BasicBlockListType  BasicBlocks;      // The basic blocks
67  ArgumentListType ArgumentList;        // The formal arguments
68
69  SymbolTable *SymTab;
70
71  friend class SymbolTableListTraits<Function, Module, Module>;
72
73  void setParent(Module *parent);
74  Function *Prev, *Next;
75  void setNext(Function *N) { Next = N; }
76  void setPrev(Function *N) { Prev = N; }
77
78public:
79  /// Function ctor - If the (optional) Module argument is specified, the
80  /// function is automatically inserted into the end of the function list for
81  /// the module.
82  ///
83  Function(const FunctionType *Ty, LinkageTypes Linkage,
84           const std::string &N = "", Module *M = 0);
85  ~Function();
86
87  // Specialize setName to handle symbol table majik...
88  virtual void setName(const std::string &name, SymbolTable *ST = 0);
89
90  const Type *getReturnType() const;           // Return the type of the ret val
91  const FunctionType *getFunctionType() const; // Return the FunctionType for me
92
93  /// isExternal - Is the body of this function unknown? (The basic block list
94  /// is empty if so.) This is true for external functions, defined as forward
95  /// "declare"ations
96  ///
97  virtual bool isExternal() const { return BasicBlocks.empty(); }
98
99  /// getIntrinsicID - This method returns the ID number of the specified
100  /// function, or Intrinsic::not_intrinsic if the function is not an
101  /// instrinsic, or if the pointer is null.  This value is always defined to be
102  /// zero to allow easy checking for whether a function is intrinsic or not.
103  /// The particular intrinsic functions which correspond to this value are
104  /// defined in llvm/Intrinsics.h.
105  ///
106  unsigned getIntrinsicID() const;
107  bool isIntrinsic() const { return getIntrinsicID() != 0; }
108
109  /// deleteBody - This method deletes the body of the function, and converts
110  /// the linkage to external.
111  ///
112  void deleteBody() {
113    dropAllReferences();
114    setLinkage(ExternalLinkage);
115  }
116
117  /// removeFromParent - This method unlinks 'this' from the containing module,
118  /// but does not delete it.
119  ///
120  void removeFromParent();
121
122  /// eraseFromParent - This method unlinks 'this' from the containing module
123  /// and deletes it.
124  ///
125  void eraseFromParent();
126
127
128  // getNext/Prev - Return the next or previous function in the list.  These
129  // methods should never be used directly, and are only used to implement the
130  // function list as part of the module.
131  //
132        Function *getNext()       { return Next; }
133  const Function *getNext() const { return Next; }
134        Function *getPrev()       { return Prev; }
135  const Function *getPrev() const { return Prev; }
136
137  /// Get the underlying elements of the Function... the basic block list is
138  /// empty for external functions.
139  ///
140  const ArgumentListType &getArgumentList() const { return ArgumentList; }
141        ArgumentListType &getArgumentList()       { return ArgumentList; }
142
143  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
144        BasicBlockListType &getBasicBlockList()       { return BasicBlocks; }
145
146  const BasicBlock       &getEntryBlock() const   { return front(); }
147        BasicBlock       &getEntryBlock()         { return front(); }
148
149  //===--------------------------------------------------------------------===//
150  // Symbol Table Accessing functions...
151
152  /// getSymbolTable() - Return the symbol table...
153  ///
154  inline       SymbolTable &getSymbolTable()       { return *SymTab; }
155  inline const SymbolTable &getSymbolTable() const { return *SymTab; }
156
157
158  //===--------------------------------------------------------------------===//
159  // BasicBlock iterator forwarding functions
160  //
161  iterator                begin()       { return BasicBlocks.begin(); }
162  const_iterator          begin() const { return BasicBlocks.begin(); }
163  iterator                end  ()       { return BasicBlocks.end();   }
164  const_iterator          end  () const { return BasicBlocks.end();   }
165
166  reverse_iterator       rbegin()       { return BasicBlocks.rbegin(); }
167  const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); }
168  reverse_iterator       rend  ()       { return BasicBlocks.rend();   }
169  const_reverse_iterator rend  () const { return BasicBlocks.rend();   }
170
171  size_t                   size() const { return BasicBlocks.size();  }
172  bool                    empty() const { return BasicBlocks.empty(); }
173  const BasicBlock       &front() const { return BasicBlocks.front(); }
174        BasicBlock       &front()       { return BasicBlocks.front(); }
175  const BasicBlock        &back() const { return BasicBlocks.back();  }
176        BasicBlock        &back()       { return BasicBlocks.back();  }
177
178  //===--------------------------------------------------------------------===//
179  // Argument iterator forwarding functions
180  //
181  aiterator                abegin()       { return ArgumentList.begin(); }
182  const_aiterator          abegin() const { return ArgumentList.begin(); }
183  aiterator                aend  ()       { return ArgumentList.end();   }
184  const_aiterator          aend  () const { return ArgumentList.end();   }
185
186  reverse_aiterator       arbegin()       { return ArgumentList.rbegin(); }
187  const_reverse_aiterator arbegin() const { return ArgumentList.rbegin(); }
188  reverse_aiterator       arend  ()       { return ArgumentList.rend();   }
189  const_reverse_aiterator arend  () const { return ArgumentList.rend();   }
190
191  size_t                    asize() const { return ArgumentList.size();  }
192  bool                     aempty() const { return ArgumentList.empty(); }
193  const Argument          &afront() const { return ArgumentList.front(); }
194        Argument          &afront()       { return ArgumentList.front(); }
195  const Argument           &aback() const { return ArgumentList.back();  }
196        Argument           &aback()       { return ArgumentList.back();  }
197
198  virtual void print(std::ostream &OS) const { print(OS, 0); }
199  void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
200
201  /// viewCFG - This function is meant for use from the debugger.  You can just
202  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
203  /// program, displaying the CFG of the current function with the code for each
204  /// basic block inside.  This depends on there being a 'dot' and 'gv' program
205  /// in your path.
206  ///
207  void viewCFG() const;
208
209  /// viewCFGOnly - This function is meant for use from the debugger.  It works
210  /// just like viewCFG, but it does not include the contents of basic blocks
211  /// into the nodes, just the label.  If you are only interested in the CFG
212  /// this can make the graph smaller.
213  ///
214  void viewCFGOnly() const;
215
216  /// Methods for support type inquiry through isa, cast, and dyn_cast:
217  static inline bool classof(const Function *) { return true; }
218  static inline bool classof(const Value *V) {
219    return V->getValueType() == Value::FunctionVal;
220  }
221
222  /// dropAllReferences() - This method causes all the subinstructions to "let
223  /// go" of all references that they are maintaining.  This allows one to
224  /// 'delete' a whole module at a time, even though there may be circular
225  /// references... first all references are dropped, and all use counts go to
226  /// zero.  Then everything is deleted for real.  Note that no operations are
227  /// valid on an object that has "dropped all references", except operator
228  /// delete.
229  ///
230  /// Since no other object in the module can have references into the body of a
231  /// function, dropping all references deletes the entire body of the function,
232  /// including any contained basic blocks.
233  ///
234  void dropAllReferences();
235};
236
237} // End llvm namespace
238
239#endif
240