Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / llvm / b99344f7919e84aef5e0402789e09f1d53473814 / . / docs / ProgrammersManual.html
blob: 046929b5c568bb732eac93b382ea3ad556604e53 [file] [log] [blame]
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]1<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
2<html><head><title>LLVM Programmer's Manual</title></head>
3
4<body bgcolor=white>
5
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]6<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
7<tr><td>&nbsp; <font size=+3 color="#EEEEFF" face="Georgia,Palatino,Times,Roman"><b>LLVM Programmer's Manual</b></font></td>
8</tr></table>
9
10<ol>
11 <li><a href="#introduction">Introduction</a>
Chris Lattnerb99344f2002-09-06 16:40:10 +0000[diff] [blame^]12 <li><a href="#common">Helpful Hints for Common Operations</a>
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]13 <li><a href="#general">General Information</a>
14 <ul>
15 <li><a href="#stl">The C++ Standard Template Library</a>
16 <li>The isa&lt;&gt;, cast&lt;&gt; and dyn_cast&lt;&gt; templates
17 </ul>
Chris Lattnera30ed382002-09-06 16:33:54 +0000[diff] [blame]18 <li><a href="#coreclasses">The Core LLVM Class Heirarchy Reference</a>
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]19 <ul>
20 <li><a href="#Value">The <tt>Value</tt> class</a>
21 <ul>
22 <li><a href="#User">The <tt>User</tt> class</a>
23 <ul>
24 <li><a href="#Instruction">The <tt>Instruction</tt> class</a>
25 <ul>
26 <li>
27 <li>
28 </ul>
29 <li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
30 <ul>
31 <li><a href="#BasicBlock">The <tt>BasicBlock</tt> class</a>
32 <li><a href="#Function">The <tt>Function</tt> class</a>
33 <li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class</a>
34 </ul>
35 <li><a href="#Module">The <tt>Module</tt> class</a>
36 <li><a href="#Constant">The <tt>Constant</tt> class</a>
37 <ul>
38 <li>
39 <li>
40 </ul>
41 </ul>
42 <li><a href="#Type">The <tt>Type</tt> class</a>
43 <li><a href="#Argument">The <tt>Argument</tt> class</a>
44 </ul>
45 <li>The <tt>SymbolTable</tt> class
46 <li>The <tt>ilist</tt> and <tt>iplist</tt> classes
47 <ul>
48 <li>Creating, inserting, moving and deleting from LLVM lists
49 </ul>
50 <li>Important iterator invalidation semantics to be aware of
51 </ul>
52
53<!--
54III. Useful things to know about the LLVM source base:
55
56III.1 Useful links that introduce the STL
57III.2 isa<>, cast<>, dyn_cast<>
58III.3 Makefiles, useful options
59III.4 How to use opt & analyze to debug stuff
60III.5 How to write a regression test
61III.6 DEBUG() and Statistics (-debug & -stats)
62III.7 The -time-passes option
63III.8 ... more as needed ...
64
65-->
66
67 <p><b>Written by <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>
68 and <a href="mailto:sabre@nondot.org">Chris Lattner</a></b><p>
69</ol>
70
71
72<!-- *********************************************************************** -->
73<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
74<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
75<a name="introduction">Introduction
76</b></font></td></tr></table><ul>
77<!-- *********************************************************************** -->
78
79This document is meant to hi-light some of the important classes and interfaces
80available in the LLVM source-base. This manual is not indended to explain what
81LLVM is, how it works, and what LLVM code looks like. It assumes that you know
82the basics of LLVM and are interested in writing transformations or otherwise
83analyzing or manipulating the code.<p>
84
85This document should get you oriented so that you can find your way in the
86continuously growing source code that makes up the LLVM infrastructure. Note
87that this manual is not intended to serve as a replacement for reading the
88source code, so if you think there should be a method in one of these classes to
89do something, but it's not listed, check the source. Links to the <a
90href="/doxygen/">doxygen</a> sources are provided to make this as easy as
91possible.<p>
92
93The first section of this document describes general information that is useful
94to know when working in the LLVM infrastructure, and the second describes the
95Core LLVM classes. In the future this manual will be extended with information
96describing how to use extension libraries, such as dominator information, CFG
97traversal routines, and useful utilities like the <tt><a
98href="/doxygen/InstVisitor_8h-source.html">InstVisitor</a></tt> template.<p>
99
100
101<!-- *********************************************************************** -->
102</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
103<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
104<a name="general">General Information
105</b></font></td></tr></table><ul>
106<!-- *********************************************************************** -->
107
108This section contains general information that is useful if you are working in
109the LLVM source-base, but that isn't specific to any particular API.<p>
110
111
112<!-- ======================================================================= -->
113</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
114<tr><td>&nbsp;</td><td width="100%">&nbsp;
115<font color="#EEEEFF" face="Georgia,Palatino"><b>
116<a name="stl">The C++ Standard Template Library</a>
117</b></font></td></tr></table><ul>
118
119LLVM makes heavy use of the C++ Standard Template Library (STL), perhaps much
120more than you are used to, or have seen before. Because of this, you might want
121to do a little background reading in the techniques used and capabilities of the
122library. There are many good pages that discuss the STL, and several books on
123the subject that you can get, so it will not be discussed in this document.<p>
124
125Here are some useful links:<p>
126<ol>
127<li><a href="http://www.dinkumware.com/htm_cpl/index.html">Dinkumware C++
128Library reference</a> - an excellent reference for the STL and other parts of
129the standard C++ library.<br>
130
131<li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
132Questions</a>
133
134<li><a href="http://www.sgi.com/tech/stl/">SGI's STL Programmer's Guide</a> -
135Contains a useful <a
136href="http://www.sgi.com/tech/stl/stl_introduction.html">Introduction to the
137STL</a>.
138
139<li><a href="http://www.research.att.com/~bs/C++.html">Bjarne Stroustrup's C++
140Page</a>
141
142</ol><p>
143
144You are also encouraged to take a look at the <a
145href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
146to write maintainable code more than where to put your curly braces.<p>
147
148
Chris Lattnerb99344f2002-09-06 16:40:10 +0000[diff] [blame^]149<!-- *********************************************************************** -->
150</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
151<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
152<a name="common">Helpful Hints for Common Operations
153</b></font></td></tr></table><ul>
154<!-- *********************************************************************** -->
155
156
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]157
158<!-- *********************************************************************** -->
159</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
160<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
Chris Lattnera30ed382002-09-06 16:33:54 +0000[diff] [blame]161<a name="coreclasses">The Core LLVM Class Heirarchy Reference
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]162</b></font></td></tr></table><ul>
163<!-- *********************************************************************** -->
164
165The Core LLVM classes are the primary means of representing the program being
166inspected or transformed. The core LLVM classes are defined in header files in
167the <tt>include/llvm/</tt> directory, and implemented in the <tt>lib/VMCore</tt>
168directory.<p>
169
170
171<!-- ======================================================================= -->
172</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
173<tr><td>&nbsp;</td><td width="100%">&nbsp;
174<font color="#EEEEFF" face="Georgia,Palatino"><b>
175<a name="Value">The <tt>Value</tt> class</a>
176</b></font></td></tr></table><ul>
177
178<tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt></b><br>
179doxygen info: <a href="/doxygen/classValue.html">Value Class</a><p>
180
181
182The <tt>Value</tt> class is the most important class in LLVM Source base. It
183represents a typed value that may be used (among other things) as an operand to
184an instruction. There are many different types of <tt>Value</tt>s, such as <a
185href="#Constant"><tt>Constant</tt></a>s, <a
186href="#Argument"><tt>Argument</tt></a>s, and even <a
187href="#Instruction"><tt>Instruction</tt></a>s and <a
188href="#Function"><tt>Function</tt></a>s are <tt>Value</tt>s.<p>
189
190A particular <tt>Value</tt> may be used many times in the LLVM representation
191for a program. For example, an incoming argument to a function (represented
192with an instance of the <a href="#Argument">Argument</a> class) is "used" by
193every instruction in the function that references the argument. To keep track
194of this relationship, the <tt>Value</tt> class keeps a list of all of the <a
195href="#User"><tt>User</tt></a>s that is using it (the <a
196href="#User"><tt>User</tt></a> class is a base class for all nodes in the LLVM
197graph that can refer to <tt>Value</tt>s). This use list is how LLVM represents
198def-use information in the program, and is accessable through the <tt>use_</tt>*
199methods, shown below.<p>
200
201Because LLVM is a typed representation, every LLVM <tt>Value</tt> is typed, and
202this <a href="#Type">Type</a> is available through the <tt>getType()</tt>
203method. <a name="#nameWarning">In addition, all LLVM values can be named. The
204"name" of the <tt>Value</tt> is symbolic string printed in the LLVM code:<p>
205
206<pre>
207 %<b>foo</b> = add int 1, 2
208</pre>
209
210The name of this instruction is "foo". <b>NOTE</b> that the name of any value
211may be missing (an empty string), so names should <b>ONLY</b> be used for
212debugging (making the source code easier to read, debugging printouts), they
213should not be used to keep track of values or map between them. For this
214purpose, use a <tt>std::map</tt> of pointers to the <tt>Value</tt> itself
215instead.<p>
216
217One important aspect of LLVM is that there is no distinction between an SSA
218variable and the operation that produces it. Because of this, any reference to
219the value produced by an instruction (or the value available as an incoming
220argument, for example) is represented as a direct pointer to the class that
221represents this value. Although this may take some getting used to, it
222simplifies the representation and makes it easier to manipulate.<p>
223
224
225<!-- _______________________________________________________________________ -->
226</ul><h4><a name="m_Value"><hr size=0>Important Public Members of
227the <tt>Value</tt> class</h4><ul>
228
229<li><tt>Value::use_iterator</tt> - Typedef for iterator over the use-list<br>
230 <tt>Value::use_const_iterator</tt>
231 - Typedef for const_iterator over the use-list<br>
232 <tt>unsigned use_size()</tt> - Returns the number of users of the value.<br>
233 <tt>bool use_empty()</tt> - Returns true if there are no users.<br>
234 <tt>use_iterator use_begin()</tt>
235 - Get an iterator to the start of the use-list.<br>
236 <tt>use_iterator use_end()</tt>
237 - Get an iterator to the end of the use-list.<br>
238 <tt><a href="#User">User</a> *use_back()</tt>
239 - Returns the last element in the list.<p>
240
241These methods are the interface to access the def-use information in LLVM. As with all other iterators in LLVM, the naming conventions follow the conventions defined by the <a href="#stl">STL</a>.<p>
242
243<li><tt><a href="#Type">Type</a> *getType() const</tt><p>
244This method returns the Type of the Value.
245
246<li><tt>bool hasName() const</tt><br>
247 <tt>std::string getName() const</tt><br>
248 <tt>void setName(const std::string &amp;Name)</tt><p>
249
250This family of methods is used to access and assign a name to a <tt>Value</tt>,
251be aware of the <a href="#nameWarning">precaution above</a>.<p>
252
253
254<li><tt>void replaceAllUsesWith(Value *V)</tt><p>
255
256This method traverses the use list of a <tt>Value</tt> changing all <a
257href="#User"><tt>User</tt>'s</a> of the current value to refer to "<tt>V</tt>"
258instead. For example, if you detect that an instruction always produces a
259constant value (for example through constant folding), you can replace all uses
260of the instruction with the constant like this:<p>
261
262<pre>
263 Inst-&gt;replaceAllUsesWith(ConstVal);
264</pre><p>
265
266
267
268<!-- ======================================================================= -->
269</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
270<tr><td>&nbsp;</td><td width="100%">&nbsp;
271<font color="#EEEEFF" face="Georgia,Palatino"><b>
272<a name="User">The <tt>User</tt> class</a>
273</b></font></td></tr></table><ul>
274
275<tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt></b><br>
276doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
277Superclass: <a href="#Value"><tt>Value</tt></a><p>
278
279
280The <tt>User</tt> class is the common base class of all LLVM nodes that may
281refer to <a href="#Value"><tt>Value</tt></a>s. It exposes a list of "Operands"
282that are all of the <a href="#Value"><tt>Value</tt></a>s that the User is
283referring to. The <tt>User</tt> class itself is a subclass of
284<tt>Value</tt>.<p>
285
286The operands of a <tt>User</tt> point directly to the LLVM <a
287href="#Value"><tt>Value</tt></a> that it refers to. Because LLVM uses Static
288Single Assignment (SSA) form, there can only be one definition referred to,
289allowing this direct connection. This connection provides the use-def
290information in LLVM.<p>
291
292<!-- _______________________________________________________________________ -->
293</ul><h4><a name="m_User"><hr size=0>Important Public Members of
294the <tt>User</tt> class</h4><ul>
295
296The <tt>User</tt> class exposes the operand list in two ways: through an index
297access interface and through an iterator based interface.<p>
298
299<li><tt>Value *getOperand(unsigned i)</tt><br>
300 <tt>unsigned getNumOperands()</tt><p>
301
302These two methods expose the operands of the <tt>User</tt> in a convenient form
303for direct access.<p>
304
305<li><tt>User::op_iterator</tt> - Typedef for iterator over the operand list<br>
306 <tt>User::op_const_iterator</tt>
307 <tt>use_iterator op_begin()</tt>
308 - Get an iterator to the start of the operand list.<br>
309 <tt>use_iterator op_end()</tt>
310 - Get an iterator to the end of the operand list.<p>
311
312Together, these methods make up the iterator based interface to the operands of
313a <tt>User</tt>.<p>
314
315
316
317<!-- ======================================================================= -->
318</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
319<tr><td>&nbsp;</td><td width="100%">&nbsp;
320<font color="#EEEEFF" face="Georgia,Palatino"><b>
321<a name="Instruction">The <tt>Instruction</tt> class</a>
322</b></font></td></tr></table><ul>
323
324<tt>#include "<a
325href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt></b><br>
326doxygen info: <a href="/doxygen/classInstruction.html">Instruction Class</a><br>
327Superclasses: <a href="#User"><tt>User</tt></a>, <a
328href="#Value"><tt>Value</tt></a><p>
329
330The <tt>Instruction</tt> class is the common base class for all LLVM
331instructions. It provides only a few methods, but is a very commonly used
332class. The primary data tracked by the <tt>Instruction</tt> class itself is the
333opcode (instruction type) and the parent <a
334href="#BasicBlock"><tt>BasicBlock</tt></a> the <tt>Instruction</tt> is embedded
335into. To represent a specific type of instruction, one of many subclasses of
336<tt>Instruction</tt> are used.<p>
337
338Because the <tt>Instruction</tt> class subclasses the <a
339href="#User"><tt>User</tt></a> class, its operands can be accessed in the same
340way as for other <a href="#User"><tt>User</tt></a>s (with the
341<tt>getOperand()</tt>/<tt>getNumOperands()</tt> and
342<tt>op_begin()</tt>/<tt>op_end()</tt> methods).<p>
343
344
345<!-- _______________________________________________________________________ -->
346</ul><h4><a name="m_Instruction"><hr size=0>Important Public Members of
347the <tt>Instruction</tt> class</h4><ul>
348
349<li><tt><a href="#BasicBlock">BasicBlock</a> *getParent()</tt><p>
350
351Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
352<tt>Instruction</tt> is embedded into.<p>
353
354<li><tt>bool hasSideEffects()</tt><p>
355
356Returns true if the instruction has side effects, i.e. it is a <tt>call</tt>,
357<tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
358
359<li><tt>unsigned getOpcode()</tt><p>
360
361Returns the opcode for the <tt>Instruction</tt>.<p>
362
363<!--
364
365\subsection{Subclasses of Instruction :}
366\begin{itemize}
367<li>BinaryOperator : This subclass of Instruction defines a general interface to the all the instructions involvong binary operators in LLVM.
368 \begin{itemize}
369 <li><tt>bool swapOperands()</tt>: Exchange the two operands to this instruction. If the instruction cannot be reversed (i.e. if it's a Div), it returns true.
370 \end{itemize}
371<li>TerminatorInst : This subclass of Instructions defines an interface for all instructions that can terminate a BasicBlock.
372 \begin{itemize}
373 <li> <tt>unsigned getNumSuccessors()</tt>: Returns the number of successors for this terminator instruction.
374 <li><tt>BasicBlock *getSuccessor(unsigned i)</tt>: As the name suggests returns the ith successor BasicBlock.
375 <li><tt>void setSuccessor(unsigned i, BasicBlock *B)</tt>: sets BasicBlock B as the ith succesor to this terminator instruction.
376 \end{itemize}
377
378<li>PHINode : This represents the PHI instructions in the SSA form.
379 \begin{itemize}
380 <li><tt> unsigned getNumIncomingValues()</tt>: Returns the number of incoming edges to this PHI node.
381 <li><tt> Value *getIncomingValue(unsigned i)</tt>: Returns the ith incoming Value.
382 <li><tt>void setIncomingValue(unsigned i, Value *V)</tt>: Sets the ith incoming Value as V
383 <li><tt>BasicBlock *getIncomingBlock(unsigned i)</tt>: Returns the Basic Block corresponding to the ith incoming Value.
384 <li><tt> void addIncoming(Value *D, BasicBlock *BB)</tt>:
385 Add an incoming value to the end of the PHI list
386 <li><tt> int getBasicBlockIndex(const BasicBlock *BB) const</tt>:
387 Returns the first index of the specified basic block in the value list for this PHI. Returns -1 if no instance.
388 \end{itemize}
389<li>CastInst : In LLVM all casts have to be done through explicit cast instructions. CastInst defines the interface to the cast instructions.
390<li>CallInst : This defines an interface to the call instruction in LLVM. ARguments to the function are nothing but operands of the instruction.
391 \begin{itemize}
392 <li>: <tt>Function *getCalledFunction()</tt>: Returns a handle to the function that is being called by this Function.
393 \end{itemize}
394<li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
395 \begin{itemize}
396 <li><tt>Value * getPointerOperand ()</tt>: Returns the Pointer Operand which is typically the 0th operand.
397 \end{itemize}
398<li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
399 \begin{itemize}
400 <li><tt>bool isConditional()</tt>: Returns true if the branch is a conditional branch else returns false
401 <li> <tt>Value *getCondition()</tt>: Returns the condition if it is a conditional branch else returns null.
402 <li> <tt>void setUnconditionalDest(BasicBlock *Dest)</tt>: Changes the current branch to an unconditional one targetting the specified block.
403 \end{itemize}
404
405\end{itemize}
406
407-->
408
409
410<!-- ======================================================================= -->
411</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
412<tr><td>&nbsp;</td><td width="100%">&nbsp;
413<font color="#EEEEFF" face="Georgia,Palatino"><b>
414<a name="BasicBlock">The <tt>BasicBlock</tt> class</a>
415</b></font></td></tr></table><ul>
416
417<tt>#include "<a
418href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt></b><br>
419doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
420Superclass: <a href="#Value"><tt>Value</tt></a><p>
421
422
423This class represents a single entry multiple exit section of the code, commonly
424known as a basic block by the compiler community. The <tt>BasicBlock</tt> class
425maintains a list of <a href="#Instruction"><tt>Instruction</tt></a>s, which form
426the body of the block. Matching the language definition, the last element of
427this list of instructions is always a terminator instruction (a subclass of the
428<a href="#TerminatorInst"><tt>TerminatorInst</tt></a> class).<p>
429
430In addition to tracking the list of instructions that make up the block, the
431<tt>BasicBlock</tt> class also keeps track of the <a
432href="#Function"><tt>Function</tt></a> that it is embedded into.<p>
433
434Note that <tt>BasicBlock</tt>s themselves are <a
435href="#Value"><tt>Value</tt></a>s, because they are referenced by instructions
436like branches and can go in the switch tables. <tt>BasicBlock</tt>s have type
437<tt>label</tt>.<p>
438
439
440<!-- _______________________________________________________________________ -->
441</ul><h4><a name="m_BasicBlock"><hr size=0>Important Public Members of
442the <tt>BasicBlock</tt> class</h4><ul>
443
444<li><tt>BasicBlock(const std::string &amp;Name = "", <a
445href="#Function">Function</a> *Parent = 0)</tt><p>
446
447The <tt>BasicBlock</tt> constructor is used to create new basic blocks for
448insertion into a function. The constructor simply takes a name for the new
449block, and optionally a <a href="#Function"><tt>Function</tt></a> to insert it
450into. If the <tt>Parent</tt> parameter is specified, the new
451<tt>BasicBlock</tt> is automatically inserted at the end of the specified <a
452href="#Function"><tt>Function</tt></a>, if not specified, the BasicBlock must be
453manually inserted into the <a href="#Function"><tt>Function</tt></a>.<p>
454
455<li><tt>BasicBlock::iterator</tt> - Typedef for instruction list iterator<br>
456 <tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
457 <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
458 <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
459
460These methods and typedefs are forwarding functions that have the same semantics
461as the standard library methods of the same names. These methods expose the
462underlying instruction list of a basic block in a way that is easy to
463manipulate. To get the full complement of container operations (including
464operations to update the list), you must use the <tt>getInstList()</tt>
465method.<p>
466
467<li><tt>BasicBlock::InstListType &amp;getInstList()</tt><p>
468
469This method is used to get access to the underlying container that actually
470holds the Instructions. This method must be used when there isn't a forwarding
471function in the <tt>BasicBlock</tt> class for the operation that you would like
472to perform. Because there are no forwarding functions for "updating"
473operations, you need to use this if you want to update the contents of a
474<tt>BasicBlock</tt>.<p>
475
476<li><tt><A href="#Function">Function</a> *getParent()</tt><p>
477
478Returns a pointer to <a href="#Function"><tt>Function</tt></a> the block is
479embedded into, or a null pointer if it is homeless.<p>
480
481<li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt><p>
482
483Returns a pointer to the terminator instruction that appears at the end of the
484<tt>BasicBlock</tt>. If there is no terminator instruction, or if the last
485instruction in the block is not a terminator, then a null pointer is
486returned.<p>
487
488
489<!-- ======================================================================= -->
490</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
491<tr><td>&nbsp;</td><td width="100%">&nbsp;
492<font color="#EEEEFF" face="Georgia,Palatino"><b>
493<a name="GlobalValue">The <tt>GlobalValue</tt> class</a>
494</b></font></td></tr></table><ul>
495
496<tt>#include "<a
497href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt></b><br>
498doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue Class</a><br>
499Superclasses: <a href="#User"><tt>User</tt></a>, <a
500href="#Value"><tt>Value</tt></a><p>
501
502Global values (<A href="#GlobalVariable"><tt>GlobalVariable</tt></a>s or <a
503href="#Function"><tt>Function</tt></a>s) are the only LLVM values that are
504visible in the bodies of all <a href="#Function"><tt>Function</tt></a>s.
505Because they are visible at global scope, they are also subject to linking with
506other globals defined in different translation units. To control the linking
507process, <tt>GlobalValue</tt>s know their linkage rules. Specifically,
508<tt>GlobalValue</tt>s know whether they have internal or external linkage.<p>
509
510If a <tt>GlobalValue</tt> has internal linkage (equivalent to being
511<tt>static</tt> in C), it is not visible to code outside the current translation
512unit, and does not participate in linking. If it has external linkage, it is
513visible to external code, and does participate in linking. In addition to
514linkage information, <tt>GlobalValue</tt>s keep track of which <a
515href="#Module"><tt>Module</tt></a> they are currently part of.<p>
516
517Because <tt>GlobalValue</tt>s are memory objects, they are always referred to by
518their address. As such, the <a href="#Type"><tt>Type</tt></a> of a global is
519always a pointer to its contents. This is explained in the LLVM Language
520Reference Manual.<p>
521
522
523<!-- _______________________________________________________________________ -->
524</ul><h4><a name="m_GlobalValue"><hr size=0>Important Public Members of
525the <tt>GlobalValue</tt> class</h4><ul>
526
527<li><tt>bool hasInternalLinkage() const</tt><br>
528 <tt>bool hasExternalLinkage() const</tt><br>
529 <tt>void setInternalLinkage(bool HasInternalLinkage)</tt><p>
530
531These methods manipulate the linkage characteristics of the
532<tt>GlobalValue</tt>.<p>
533
534<li><tt><a href="#Module">Module</a> *getParent()</tt><p>
535
536This returns the <a href="#Module"><tt>Module</tt></a> that the GlobalValue is
537currently embedded into.<p>
538
539
540
541<!-- ======================================================================= -->
542</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
543<tr><td>&nbsp;</td><td width="100%">&nbsp;
544<font color="#EEEEFF" face="Georgia,Palatino"><b>
545<a name="Function">The <tt>Function</tt> class</a>
546</b></font></td></tr></table><ul>
547
548<tt>#include "<a
549href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt></b><br>
550doxygen info: <a href="/doxygen/classFunction.html">Function Class</a><br>
551Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
552href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
553
554The <tt>Function</tt> class represents a single procedure in LLVM. It is
555actually one of the more complex classes in the LLVM heirarchy because it must
556keep track of a large amount of data. The <tt>Function</tt> class keeps track
557of a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, a list of formal <a
558href="#Argument"><tt>Argument</tt></a>s, and a <a
559href="#SymbolTable"><tt>SymbolTable</tt></a>.<p>
560
561The list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s is the most commonly
562used part of <tt>Function</tt> objects. The list imposes an implicit ordering
563of the blocks in the function, which indicate how the code will be layed out by
564the backend. Additionally, the first <a
565href="#BasicBlock"><tt>BasicBlock</tt></a> is the implicit entry node for the
566<tt>Function</tt>. It is not legal in LLVM explicitly branch to this initial
567block. There are no implicit exit nodes, and in fact there may be multiple exit
568nodes from a single <tt>Function</tt>. If the <a
569href="#BasicBlock"><tt>BasicBlock</tt></a> list is empty, this indicates that
570the <tt>Function</tt> is actually a function declaration: the actual body of the
571function hasn't been linked in yet.<p>
572
573In addition to a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, the
574<tt>Function</tt> class also keeps track of the list of formal <a
575href="#Argument"><tt>Argument</tt></a>s that the function receives. This
576container manages the lifetime of the <a href="#Argument"><tt>Argument</tt></a>
577nodes, just like the <a href="#BasicBlock"><tt>BasicBlock</tt></a> list does for
578the <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.<p>
579
580The <a href="#SymbolTable"><tt>SymbolTable</tt></a> is a very rarely used LLVM
581feature that is only used when you have to look up a value by name. Aside from
582that, the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is used internally to
583make sure that there are not conflicts between the names of <a
584href="#Instruction"><tt>Instruction</tt></a>s, <a
585href="#BasicBlock"><tt>BasicBlock</tt></a>s, or <a
586href="#Argument"><tt>Argument</tt></a>s in the function body.<p>
587
588
589<!-- _______________________________________________________________________ -->
590</ul><h4><a name="m_Function"><hr size=0>Important Public Members of
591the <tt>Function</tt> class</h4><ul>
592
593<li><tt>Function(const <a href="#FunctionType">FunctionType</a> *Ty, bool isInternal, const std::string &amp;N = "")</tt><p>
594
595Constructor used when you need to create new <tt>Function</tt>s to add the the
596program. The constructor must specify the type of the function to create and
597whether or not it should start out with internal or external linkage.<p>
598
599<li><tt>bool isExternal()</tt><p>
600
601Return whether or not the <tt>Function</tt> has a body defined. If the function
602is "external", it does not have a body, and thus must be resolved by linking
603with a function defined in a different translation unit.<p>
604
605
606<li><tt>Function::iterator</tt> - Typedef for basic block list iterator<br>
607 <tt>Function::const_iterator</tt> - Typedef for const_iterator.<br>
608 <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
609 <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
610
611These are forwarding methods that make it easy to access the contents of a
612<tt>Function</tt> object's <a href="#BasicBlock"><tt>BasicBlock</tt></a>
613list.<p>
614
615<li><tt>Function::BasicBlockListType &amp;getBasicBlockList()</tt><p>
616
617Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s. This is
618neccesary to use when you need to update the list or perform a complex action
619that doesn't have a forwarding method.<p>
620
621
622<li><tt>Function::aiterator</tt> - Typedef for the argument list iterator<br>
623 <tt>Function::const_aiterator</tt> - Typedef for const_iterator.<br>
624 <tt>abegin()</tt>, <tt>aend()</tt>, <tt>afront()</tt>, <tt>aback()</tt>,
625 <tt>asize()</tt>, <tt>aempty()</tt>, <tt>arbegin()</tt>, <tt>arend()</tt><p>
626
627These are forwarding methods that make it easy to access the contents of a
628<tt>Function</tt> object's <a href="#Argument"><tt>Argument</tt></a> list.<p>
629
630<li><tt>Function::ArgumentListType &amp;getArgumentList()</tt><p>
631
632Returns the list of <a href="#Argument"><tt>Argument</tt></a>s. This is
633neccesary to use when you need to update the list or perform a complex action
634that doesn't have a forwarding method.<p>
635
636
637
638<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryNode()</tt><p>
639
640Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
641function. Because the entry block for the function is always the first block,
642this returns the first block of the <tt>Function</tt>.<p>
643
644<li><tt><a href="#Type">Type</a> *getReturnType()</tt><br>
645 <tt><a href="#FunctionType">FunctionType</a> *getFunctionType()</tt><p>
646
647This traverses the <a href="#Type"><tt>Type</tt></a> of the <tt>Function</tt>
648and returns the return type of the function, or the <a
649href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
650
651
652<li><tt>bool hasSymbolTable() const</tt><p>
653
654Return true if the <tt>Function</tt> has a symbol table allocated to it and if
655there is at least one entry in it.<p>
656
657<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
658
659Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
660<tt>Function</tt> or a null pointer if one has not been allocated (because there
661are no named values in the function).<p>
662
663<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
664
665Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
666<tt>Function</tt> or allocate a new <a
667href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around. This
668should only be used when adding elements to the <a
669href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
670not left laying around.<p>
671
672
673
674<!-- ======================================================================= -->
675</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
676<tr><td>&nbsp;</td><td width="100%">&nbsp;
677<font color="#EEEEFF" face="Georgia,Palatino"><b>
678<a name="GlobalVariable">The <tt>GlobalVariable</tt> class</a>
679</b></font></td></tr></table><ul>
680
681<tt>#include "<a
682href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt></b><br>
683doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable Class</a><br>
684Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
685href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
686
Chris Lattner0377de42002-09-06 14:50:55 +0000[diff] [blame]687Global variables are represented with the (suprise suprise)
688<tt>GlobalVariable</tt> class. Like functions, <tt>GlobalVariable</tt>s are
689also subclasses of <a href="#GlobalValue"><tt>GlobalValue</tt></a>, and as such
690are always referenced by their address (global values must live in memory, so
691their "name" refers to their address). Global variables may have an initial
692value (which must be a <a href="#Constant"><tt>Constant</tt></a>), and if they
693have an initializer, they may be marked as "constant" themselves (indicating
694that their contents never change at runtime).<p>
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]695
696
697<!-- _______________________________________________________________________ -->
Chris Lattner0377de42002-09-06 14:50:55 +0000[diff] [blame]698</ul><h4><a name="m_GlobalVariable"><hr size=0>Important Public Members of the
699<tt>GlobalVariable</tt> class</h4><ul>
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]700
701<li><tt>GlobalVariable(const <a href="#Type">Type</a> *Ty, bool isConstant, bool
702isInternal, <a href="#Constant">Constant</a> *Initializer = 0, const std::string
703&amp;Name = "")</tt><p>
704
Chris Lattner0377de42002-09-06 14:50:55 +0000[diff] [blame]705Create a new global variable of the specified type. If <tt>isConstant</tt> is
706true then the global variable will be marked as unchanging for the program, and
707if <tt>isInternal</tt> is true the resultant global variable will have internal
708linkage. Optionally an initializer and name may be specified for the global variable as well.<p>
709
710
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]711<li><tt>bool isConstant() const</tt><p>
712
713Returns true if this is a global variable is known not to be modified at
714runtime.<p>
715
Chris Lattner0377de42002-09-06 14:50:55 +0000[diff] [blame]716
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]717<li><tt>bool hasInitializer()</tt><p>
718
719Returns true if this <tt>GlobalVariable</tt> has an intializer.<p>
720
Chris Lattner0377de42002-09-06 14:50:55 +0000[diff] [blame]721
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]722<li><tt><a href="#Constant">Constant</a> *getInitializer()</tt><p>
723
Chris Lattner0377de42002-09-06 14:50:55 +0000[diff] [blame]724Returns the intial value for a <tt>GlobalVariable</tt>. It is not legal to call
725this method if there is no initializer.<p>
726
727
728<!-- ======================================================================= -->
729</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
730<tr><td>&nbsp;</td><td width="100%">&nbsp;
731<font color="#EEEEFF" face="Georgia,Palatino"><b>
732<a name="Module">The <tt>Module</tt> class</a>
733</b></font></td></tr></table><ul>
734
735<tt>#include "<a
736href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt></b><br>
737doxygen info: <a href="/doxygen/classModule.html">Module Class</a><p>
738
739The <tt>Module</tt> class represents the top level structure present in LLVM
740programs. An LLVM module is effectively either a translation unit of the
741original program or a combination of several translation units merged by the
742linker. The <tt>Module</tt> class keeps track of a list of <a
743href="#Function"><tt>Function</tt></a>s, a list of <a
744href="#GlobalVariable"><tt>GlobalVariable</tt></a>s, and a <a
745href="#SymbolTable"><tt>SymbolTable</tt></a>. Additionally, it contains a few
746helpful member functions that try to make common operations easy.<p>
747
748
749<!-- _______________________________________________________________________ -->
750</ul><h4><a name="m_Module"><hr size=0>Important Public Members of the
751<tt>Module</tt> class</h4><ul>
752
753<li><tt>Module::iterator</tt> - Typedef for function list iterator<br>
754 <tt>Module::const_iterator</tt> - Typedef for const_iterator.<br>
755 <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
756 <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
757
758These are forwarding methods that make it easy to access the contents of a
759<tt>Module</tt> object's <a href="#Function"><tt>Function</tt></a>
760list.<p>
761
762<li><tt>Module::FunctionListType &amp;getFunctionList()</tt><p>
763
764Returns the list of <a href="#Function"><tt>Function</tt></a>s. This is
765neccesary to use when you need to update the list or perform a complex action
766that doesn't have a forwarding method.<p>
767
768<!-- Global Variable -->
769<hr size=0>
770
771<li><tt>Module::giterator</tt> - Typedef for global variable list iterator<br>
772 <tt>Module::const_giterator</tt> - Typedef for const_iterator.<br>
773 <tt>gbegin()</tt>, <tt>gend()</tt>, <tt>gfront()</tt>, <tt>gback()</tt>,
774 <tt>gsize()</tt>, <tt>gempty()</tt>, <tt>grbegin()</tt>, <tt>grend()</tt><p>
775
776These are forwarding methods that make it easy to access the contents of a
777<tt>Module</tt> object's <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>
778list.<p>
779
780<li><tt>Module::GlobalListType &amp;getGlobalList()</tt><p>
781
782Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
783This is neccesary to use when you need to update the list or perform a complex
784action that doesn't have a forwarding method.<p>
785
786
787<!-- Symbol table stuff -->
788<hr size=0>
789
790<li><tt>bool hasSymbolTable() const</tt><p>
791
792Return true if the <tt>Module</tt> has a symbol table allocated to it and if
793there is at least one entry in it.<p>
794
795<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
796
797Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
798<tt>Module</tt> or a null pointer if one has not been allocated (because there
799are no named values in the function).<p>
800
801<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
802
803Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
804<tt>Module</tt> or allocate a new <a
805href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around. This
806should only be used when adding elements to the <a
807href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
808not left laying around.<p>
809
810
811<!-- Convenience methods -->
812<hr size=0>
813
814<li><tt><a href="#Function">Function</a> *getFunction(const std::string &amp;Name, const <a href="#FunctionType">FunctionType</a> *Ty)</tt><p>
815
816Look up the specified function in the <tt>Module</tt> <a
817href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, return
818<tt>null</tt>.<p>
819
820
821<li><tt><a href="#Function">Function</a> *getOrInsertFunction(const std::string
822 &amp;Name, const <a href="#FunctionType">FunctionType</a> *T)</tt><p>
823
824Look up the specified function in the <tt>Module</tt> <a
825href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, add an
826external declaration for the function and return it.<p>
827
828
829<li><tt>std::string getTypeName(const <a href="#Type">Type</a> *Ty)</tt><p>
830
831If there is at least one entry in the <a
832href="#SymbolTable"><tt>SymbolTable</tt></a> for the specified <a
833href="#Type"><tt>Type</tt></a>, return it. Otherwise return the empty
834string.<p>
835
836
837<li><tt>bool addTypeName(const std::string &Name, const <a href="#Type">Type</a>
838*Ty)</tt><p>
839
840Insert an entry in the <a href="#SymbolTable"><tt>SymbolTable</tt></a> mapping
841<tt>Name</tt> to <tt>Ty</tt>. If there is already an entry for this name, true
842is returned and the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is not
843modified.<p>
844
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]845
846<!-- ======================================================================= -->
847</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
848<tr><td>&nbsp;</td><td width="100%">&nbsp;
849<font color="#EEEEFF" face="Georgia,Palatino"><b>
850<a name="Constant">The <tt>Constant</tt> class and subclasses</a>
851</b></font></td></tr></table><ul>
852
853Constant represents a base class for different types of constants. It is
854subclassed by ConstantBool, ConstantInt, ConstantSInt, ConstantUInt,
855ConstantArray etc for representing the various types of Constants.<p>
856
857
858<!-- _______________________________________________________________________ -->
859</ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
860
861<li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
862
863
864
865
866\subsection{Important Subclasses of Constant}
867\begin{itemize}
868<li>ConstantSInt : This subclass of Constant represents a signed integer constant.
869 \begin{itemize}
870 <li><tt>int64_t getValue () const</tt>: Returns the underlying value of this constant.
871 \end{itemize}
872<li>ConstantUInt : This class represents an unsigned integer.
873 \begin{itemize}
874 <li><tt>uint64_t getValue () const</tt>: Returns the underlying value of this constant.
875 \end{itemize}
876<li>ConstantFP : This class represents a floating point constant.
877 \begin{itemize}
878 <li><tt>double getValue () const</tt>: Returns the underlying value of this constant.
879 \end{itemize}
880<li>ConstantBool : This represents a boolean constant.
881 \begin{itemize}
882 <li><tt>bool getValue () const</tt>: Returns the underlying value of this constant.
883 \end{itemize}
884<li>ConstantArray : This represents a constant array.
885 \begin{itemize}
886 <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
887 \end{itemize}
888<li>ConstantStruct : This represents a constant struct.
889 \begin{itemize}
890 <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
891 \end{itemize}
892<li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
893 \begin{itemize}
894<li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
895 \end{itemize}
896\end{itemize}
897
898
899<!-- ======================================================================= -->
900</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
901<tr><td>&nbsp;</td><td width="100%">&nbsp;
902<font color="#EEEEFF" face="Georgia,Palatino"><b>
903<a name="Type">The <tt>Type</tt> class and Derived Types</a>
904</b></font></td></tr></table><ul>
905
906Type as noted earlier is also a subclass of a Value class. Any primitive
907type (like int, short etc) in LLVM is an instance of Type Class. All
908other types are instances of subclasses of type like FunctionType,
909ArrayType etc. DerivedType is the interface for all such dervied types
910including FunctionType, ArrayType, PointerType, StructType. Types can have
911names. They can be recursive (StructType). There exists exactly one instance
912of any type structure at a time. This allows using pointer equality of Type *s for comparing types.
913
914<!-- _______________________________________________________________________ -->
915</ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
916
917<li><tt>PrimitiveID getPrimitiveID () const</tt>: Returns the base type of the type.
918<li><tt> bool isSigned () const</tt>: Returns whether an integral numeric type is signed. This is true for SByteTy, ShortTy, IntTy, LongTy. Note that this is not true for Float and Double.
919<li><tt>bool isUnsigned () const</tt>: Returns whether a numeric type is unsigned. This is not quite the complement of isSigned... nonnumeric types return false as they do with isSigned. This returns true for UByteTy, UShortTy, UIntTy, and ULongTy.
920<li><tt> bool isInteger () const</tt>: Equilivent to isSigned() || isUnsigned(), but with only a single virtual function invocation.
921<li><tt>bool isIntegral () const</tt>: Returns true if this is an integral type, which is either Bool type or one of the Integer types.
922
923<li><tt>bool isFloatingPoint ()</tt>: Return true if this is one of the two floating point types.
924<li><tt>bool isRecursive () const</tt>: Returns rue if the type graph contains a cycle.
925<li><tt>isLosslesslyConvertableTo (const Type *Ty) const</tt>: Return true if this type can be converted to 'Ty' without any reinterpretation of bits. For example, uint to int.
926<li><tt>bool isPrimitiveType () const</tt>: Returns true if it is a primitive type.
927<li><tt>bool isDerivedType () const</tt>: Returns true if it is a derived type.
928<li><tt>const Type * getContainedType (unsigned i) const</tt>:
929This method is used to implement the type iterator. For derived types, this returns the types 'contained' in the derived type, returning 0 when 'i' becomes invalid. This allows the user to iterate over the types in a struct, for example, really easily.
930<li><tt>unsigned getNumContainedTypes () const</tt>: Return the number of types in the derived type.
931
932
933
934\subsection{Derived Types}
935\begin{itemize}
936<li>SequentialType : This is subclassed by ArrayType and PointerType
937 \begin{itemize}
938 <li><tt>const Type * getElementType () const</tt>: Returns the type of each of the elements in the sequential type.
939 \end{itemize}
940<li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
941 \begin{itemize}
942 <li><tt>unsigned getNumElements () const</tt>: Returns the number of elements in the array.
943 \end{itemize}
944<li>PointerType : Subclass of SequentialType for pointer types.
945<li>StructType : subclass of DerivedTypes for struct types
946<li>FunctionType : subclass of DerivedTypes for function types.
947 \begin{itemize}
948
949 <li><tt>bool isVarArg () const</tt>: Returns true if its a vararg function
950 <li><tt> const Type * getReturnType () const</tt>: Returns the return type of the function.
951 <li><tt> const ParamTypes &amp;getParamTypes () const</tt>: Returns a vector of parameter types.
952 <li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
953 <li><tt> const unsigned getNumParams () const</tt>: Returns the number of formal parameters.
954 \end{itemize}
955\end{itemize}
956
957
958
959
960<!-- ======================================================================= -->
961</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
962<tr><td>&nbsp;</td><td width="100%">&nbsp;
963<font color="#EEEEFF" face="Georgia,Palatino"><b>
964<a name="Argument">The <tt>Argument</tt> class</a>
965</b></font></td></tr></table><ul>
966
967This subclass of Value defines the interface for incoming formal arguments to a
968function. A Function maitanis a list of its formal arguments. An argument has a
969pointer to the parent Function.
970
971
972
973
974<!-- *********************************************************************** -->
975</ul>
976<!-- *********************************************************************** -->
977
978<hr><font size-1>
979<address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
980<a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
981<!-- Created: Tue Aug 6 15:00:33 CDT 2002 -->
982<!-- hhmts start -->
Chris Lattnerb99344f2002-09-06 16:40:10 +0000[diff] [blame^]983Last modified: Fri Sep 6 11:39:58 CDT 2002
Chris Lattner9355b472002-09-06 02:50:58 +0000[diff] [blame]984<!-- hhmts end -->
985</font></body></html>