blob: 2709b2298d8353e4078ec8eae91e1fa1b96a74a5 [file] [log] [blame]
Chris Lattner9355b472002-09-06 02:50:58 +00001<!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 +00006<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>
12 <li><a href="#general">General Information</a>
13 <ul>
14 <li><a href="#stl">The C++ Standard Template Library</a>
Chris Lattner1d43fd42002-09-09 05:53:21 +000015 <li><a href="#isa">The <tt>isa&lt;&gt;</tt>, <tt>cast&lt;&gt;</tt> and
16 <tt>dyn_cast&lt;&gt;</tt> templates</a>
Chris Lattner9355b472002-09-06 02:50:58 +000017 </ul>
Chris Lattnerae7f7592002-09-06 18:31:18 +000018 <li><a href="#common">Helpful Hints for Common Operations</a>
19 <ul>
20 <li><a href="#inspection">Basic Inspection and Traversal Routines</a>
21 <ul>
22 <li><a href="#iterate_function">Iterating over the <tt>BasicBlock</tt>s
23 in a <tt>Function</tt></a>
24 <li><a href="#iterate_basicblock">Iterating over the <tt>Instruction</tt>s
25 in a <tt>BasicBlock</tt></a>
Chris Lattner1a3105b2002-09-09 05:49:39 +000026 <li><a href="#iterate_institer">Iterating over the <tt>Instruction</tt>s
27 in a <tt>Function</tt></a>
Chris Lattnerae7f7592002-09-06 18:31:18 +000028 <li><a href="#iterate_convert">Turning an iterator into a class
29 pointer</a>
Chris Lattnerf1ebdc32002-09-06 22:09:21 +000030 <li><a href="#iterate_complex">Finding call sites: a more complex
31 example</a>
Chris Lattner1a3105b2002-09-09 05:49:39 +000032 <li><a href="#iterate_chains">Iterating over def-use &amp; use-def
33 chains</a>
Chris Lattnerae7f7592002-09-06 18:31:18 +000034 </ul>
35 <li><a href="#simplechanges">Making simple changes</a>
36 <ul>
37 <li>Creating and inserting new <tt>Instruction</tt>s
38 <li>Deleting <tt>Instruction</tt>s
39 <li>Replacing an <tt>Instruction</tt> with another <tt>Value</tt>
40 </ul>
41<!--
42 <li>Working with the Control Flow Graph
43 <ul>
44 <li>Accessing predecessors and successors of a <tt>BasicBlock</tt>
45 <li>
46 <li>
47 </ul>
Chris Lattnerae7f7592002-09-06 18:31:18 +000048 <li>Useful LLVM APIs
49 <ul>
Chris Lattnerae7f7592002-09-06 18:31:18 +000050 <li>The general graph API
51 <li>The <tt>InstVisitor</tt> template
52 <li>The DEBUG() macro
53 <li>The <tt>Statistic</tt> template
54-->
55 </ul>
56<!--
57 <li>Useful related topics
58 <ul>
59 <li>The <tt>-time-passes</tt> option
60 <li>How to use the LLVM Makefile system
61 <li>How to write a regression test
62 <li>
63 </ul>
64-->
65 </ul>
Joel Stanley9b96c442002-09-06 21:55:13 +000066 <li><a href="#coreclasses">The Core LLVM Class Hierarchy Reference</a>
Chris Lattner9355b472002-09-06 02:50:58 +000067 <ul>
68 <li><a href="#Value">The <tt>Value</tt> class</a>
69 <ul>
70 <li><a href="#User">The <tt>User</tt> class</a>
71 <ul>
72 <li><a href="#Instruction">The <tt>Instruction</tt> class</a>
73 <ul>
74 <li>
Chris Lattner9355b472002-09-06 02:50:58 +000075 </ul>
76 <li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
77 <ul>
78 <li><a href="#BasicBlock">The <tt>BasicBlock</tt> class</a>
79 <li><a href="#Function">The <tt>Function</tt> class</a>
80 <li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class</a>
81 </ul>
82 <li><a href="#Module">The <tt>Module</tt> class</a>
83 <li><a href="#Constant">The <tt>Constant</tt> class</a>
84 <ul>
85 <li>
86 <li>
87 </ul>
88 </ul>
89 <li><a href="#Type">The <tt>Type</tt> class</a>
90 <li><a href="#Argument">The <tt>Argument</tt> class</a>
91 </ul>
92 <li>The <tt>SymbolTable</tt> class
93 <li>The <tt>ilist</tt> and <tt>iplist</tt> classes
94 <ul>
95 <li>Creating, inserting, moving and deleting from LLVM lists
96 </ul>
97 <li>Important iterator invalidation semantics to be aware of
98 </ul>
99
Chris Lattner6b121f12002-09-10 15:20:46 +0000100 <p><b>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a>,
101 <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>, and
Chris Lattnerf1ebdc32002-09-06 22:09:21 +0000102 <a href="mailto:jstanley@cs.uiuc.edu">Joel Stanley</a></b><p>
Chris Lattner9355b472002-09-06 02:50:58 +0000103</ol>
104
105
106<!-- *********************************************************************** -->
107<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
108<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
109<a name="introduction">Introduction
110</b></font></td></tr></table><ul>
111<!-- *********************************************************************** -->
112
Joel Stanley9b96c442002-09-06 21:55:13 +0000113This document is meant to highlight some of the important classes and interfaces
114available in the LLVM source-base. This manual is not intended to explain what
Chris Lattner9355b472002-09-06 02:50:58 +0000115LLVM is, how it works, and what LLVM code looks like. It assumes that you know
116the basics of LLVM and are interested in writing transformations or otherwise
117analyzing or manipulating the code.<p>
118
119This document should get you oriented so that you can find your way in the
120continuously growing source code that makes up the LLVM infrastructure. Note
121that this manual is not intended to serve as a replacement for reading the
122source code, so if you think there should be a method in one of these classes to
123do something, but it's not listed, check the source. Links to the <a
124href="/doxygen/">doxygen</a> sources are provided to make this as easy as
125possible.<p>
126
127The first section of this document describes general information that is useful
128to know when working in the LLVM infrastructure, and the second describes the
129Core LLVM classes. In the future this manual will be extended with information
130describing how to use extension libraries, such as dominator information, CFG
131traversal routines, and useful utilities like the <tt><a
132href="/doxygen/InstVisitor_8h-source.html">InstVisitor</a></tt> template.<p>
133
134
135<!-- *********************************************************************** -->
136</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
137<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
138<a name="general">General Information
139</b></font></td></tr></table><ul>
140<!-- *********************************************************************** -->
141
142This section contains general information that is useful if you are working in
143the LLVM source-base, but that isn't specific to any particular API.<p>
144
145
146<!-- ======================================================================= -->
147</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
148<tr><td>&nbsp;</td><td width="100%">&nbsp;
149<font color="#EEEEFF" face="Georgia,Palatino"><b>
150<a name="stl">The C++ Standard Template Library</a>
151</b></font></td></tr></table><ul>
152
153LLVM makes heavy use of the C++ Standard Template Library (STL), perhaps much
154more than you are used to, or have seen before. Because of this, you might want
155to do a little background reading in the techniques used and capabilities of the
156library. There are many good pages that discuss the STL, and several books on
157the subject that you can get, so it will not be discussed in this document.<p>
158
159Here are some useful links:<p>
160<ol>
161<li><a href="http://www.dinkumware.com/htm_cpl/index.html">Dinkumware C++
162Library reference</a> - an excellent reference for the STL and other parts of
163the standard C++ library.<br>
164
165<li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
166Questions</a>
167
168<li><a href="http://www.sgi.com/tech/stl/">SGI's STL Programmer's Guide</a> -
169Contains a useful <a
170href="http://www.sgi.com/tech/stl/stl_introduction.html">Introduction to the
171STL</a>.
172
173<li><a href="http://www.research.att.com/~bs/C++.html">Bjarne Stroustrup's C++
174Page</a>
175
176</ol><p>
177
178You are also encouraged to take a look at the <a
179href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
180to write maintainable code more than where to put your curly braces.<p>
181
182
Chris Lattner1d43fd42002-09-09 05:53:21 +0000183<!-- ======================================================================= -->
184</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
185<tr><td>&nbsp;</td><td width="100%">&nbsp;
186<font color="#EEEEFF" face="Georgia,Palatino"><b>
187<a name="isa">The isa&lt;&gt;, cast&lt;&gt; and dyn_cast&lt;&gt; templates</a>
188</b></font></td></tr></table><ul>
189
Chris Lattner979d9b72002-09-10 00:39:05 +0000190The LLVM source-base makes extensive use of a custom form of RTTI. These
191templates have many similarities to the C++ <tt>dynamic_cast&lt;&gt;</tt>
192operator, but they don't have some drawbacks (primarily stemming from the fact
193that <tt>dynamic_cast&lt;&gt;</tt> only works on classes that have a v-table).
194Because they are used so often, you must know what they do and how they work.
195All of these templates are defined in the <a
196href="/doxygen/Casting_8h-source.html"><tt>Support/Casting.h</tt></a> file (note
197that you very rarely have to include this file directly).<p>
Chris Lattner1d43fd42002-09-09 05:53:21 +0000198
Chris Lattner979d9b72002-09-10 00:39:05 +0000199<dl>
200
201<dt><tt>isa&lt;&gt;</tt>:
202
203<dd>The <tt>isa&lt;&gt;</tt> operator works exactly like the Java
204"<tt>instanceof</tt>" operator. It returns true or false depending on whether a
205reference or pointer points to an instance of the specified class. This can be
206very useful for constraint checking of various sorts (example below).<p>
207
208
209<dt><tt>cast&lt;&gt;</tt>:
210
211<dd>The <tt>cast&lt;&gt;</tt> operator is a "checked cast" operation. It
212converts a pointer or reference from a base class to a derived cast, causing an
213assertion failure if it is not really an instance of the right type. This
214should be used in cases where you have some information that makes you believe
215that something is of the right type. An example of the <tt>isa&lt;&gt;</tt> and
216<tt>cast&lt;&gt;</tt> template is:<p>
217
218<pre>
219static bool isLoopInvariant(const <a href="#Value">Value</a> *V, const Loop *L) {
220 if (isa&lt;<a href="#Constant">Constant</a>&gt;(V) || isa&lt;<a href="#Argument">Argument</a>&gt;(V) || isa&lt;<a href="#GlobalValue">GlobalValue</a>&gt;(V))
221 return true;
222
223 <i>// Otherwise, it must be an instruction...</i>
224 return !L->contains(cast&lt;<a href="#Instruction">Instruction</a>&gt;(V)->getParent());
225</pre><p>
226
227Note that you should <b>not</b> use an <tt>isa&lt;&gt;</tt> test followed by a
228<tt>cast&lt;&gt;</tt>, for that use the <tt>dyn_cast&lt;&gt;</tt> operator.<p>
229
230
231<dt><tt>dyn_cast&lt;&gt;</tt>:
232
233<dd>The <tt>dyn_cast&lt;&gt;</tt> operator is a "checking cast" operation. It
234checks to see if the operand is of the specified type, and if so, returns a
235pointer to it (this operator does not work with references). If the operand is
236not of the correct type, a null pointer is returned. Thus, this works very much
237like the <tt>dynamic_cast</tt> operator in C++, and should be used in the same
Chris Lattner6b121f12002-09-10 15:20:46 +0000238circumstances. Typically, the <tt>dyn_cast&lt;&gt;</tt> operator is used in an
239<tt>if</tt> statement or some other flow control statement like this:<p>
240
241<pre>
242 if (<a href="#AllocationInst">AllocationInst</a> *AI = dyn_cast&lt;<a href="#AllocationInst">AllocationInst</a>&gt;(Val)) {
243 ...
244 }
245</pre><p>
246
247This form of the <tt>if</tt> statement effectively combines together a call to
248<tt>isa&lt;&gt;</tt> and a call to <tt>cast&lt;&gt;</tt> into one statement,
249which is very convenient.<p>
250
251Another common example is:<p>
Chris Lattner979d9b72002-09-10 00:39:05 +0000252
253<pre>
254 <i>// Loop over all of the phi nodes in a basic block</i>
255 BasicBlock::iterator BBI = BB->begin();
256 for (; <a href="#PhiNode">PHINode</a> *PN = dyn_cast&lt;<a href="#PHINode">PHINode</a>&gt;(&amp;*BBI); ++BBI)
257 cerr &lt;&lt; *PN;
258</pre><p>
259
Chris Lattner6b121f12002-09-10 15:20:46 +0000260Note that the <tt>dyn_cast&lt;&gt;</tt> operator, like C++'s
261<tt>dynamic_cast</tt> or Java's <tt>instanceof</tt> operator, can be abused. In
262particular you should not use big chained <tt>if/then/else</tt> blocks to check
263for lots of different variants of classes. If you find yourself wanting to do
264this, it is much cleaner and more efficient to use the InstVisitor class to
265dispatch over the instruction type directly.<p>
Chris Lattner979d9b72002-09-10 00:39:05 +0000266
267
Chris Lattner6b121f12002-09-10 15:20:46 +0000268<dt><tt>cast_or_null&lt;&gt;</tt>:
269
270<dd>The <tt>cast_or_null&lt;&gt;</tt> operator works just like the
271<tt>cast&lt;&gt;</tt> operator, except that it allows for a null pointer as an
272argument (which it then propogates). This can sometimes be useful, allowing you
273to combine several null checks into one.<p>
274
275
276<dt><tt>dyn_cast_or_null&lt;&gt;</tt>:
277
278<dd>The <tt>dyn_cast_or_null&lt;&gt;</tt> operator works just like the
279<tt>dyn_cast&lt;&gt;</tt> operator, except that it allows for a null pointer as
280an argument (which it then propogates). This can sometimes be useful, allowing
281you to combine several null checks into one.<p>
282
Chris Lattner979d9b72002-09-10 00:39:05 +0000283</dl>
Chris Lattner1d43fd42002-09-09 05:53:21 +0000284
Chris Lattner6b121f12002-09-10 15:20:46 +0000285These five templates can be used with any classes, whether they have a v-table
286or not. To add support for these templates, you simply need to add
287<tt>classof</tt> static methods to the class you are interested casting to.
288Describing this is currently outside the scope of this document, but there are
289lots of examples in the LLVM sourcebase.<p>
Chris Lattner1d43fd42002-09-09 05:53:21 +0000290
291
Chris Lattnerae7f7592002-09-06 18:31:18 +0000292
Chris Lattnerb99344f2002-09-06 16:40:10 +0000293<!-- *********************************************************************** -->
294</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
295<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
296<a name="common">Helpful Hints for Common Operations
297</b></font></td></tr></table><ul>
298<!-- *********************************************************************** -->
299
Chris Lattnerae7f7592002-09-06 18:31:18 +0000300This section describes how to perform some very simple transformations of LLVM
301code. This is meant to give examples of common idioms used, showing the
302practical side of LLVM transformations.<p>
303
Joel Stanley9b96c442002-09-06 21:55:13 +0000304Because this is a "how-to" section, you should also read about the main classes
Chris Lattnerae7f7592002-09-06 18:31:18 +0000305that you will be working with. The <a href="#coreclasses">Core LLVM Class
Joel Stanley9b96c442002-09-06 21:55:13 +0000306Hierarchy Reference</a> contains details and descriptions of the main classes
Chris Lattnerae7f7592002-09-06 18:31:18 +0000307that you should know about.<p>
308
309<!-- NOTE: this section should be heavy on example code -->
310
311
312<!-- ======================================================================= -->
313</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
314<tr><td>&nbsp;</td><td width="100%">&nbsp;
315<font color="#EEEEFF" face="Georgia,Palatino"><b>
316<a name="inspection">Basic Inspection and Traversal Routines</a>
317</b></font></td></tr></table><ul>
318
Chris Lattnercaa5d132002-09-09 19:58:18 +0000319The LLVM compiler infrastructure have many different data structures that may be
320traversed. Following the example of the C++ standard template library, the
321techniques used to traverse these various data structures are all basically the
322same. For a enumerable sequence of values, the <tt>XXXbegin()</tt> function (or
323method) returns an iterator to the start of the sequence, the <tt>XXXend()</tt>
324function returns an iterator pointing to one past the last valid element of the
325sequence, and there is some <tt>XXXiterator</tt> data type that is common
326between the two operations.<p>
Chris Lattnerae7f7592002-09-06 18:31:18 +0000327
Chris Lattnercaa5d132002-09-09 19:58:18 +0000328Because the pattern for iteration is common across many different aspects of the
329program representation, the standard template library algorithms may be used on
330them, and it is easier to remember how to iterate. First we show a few common
331examples of the data structures that need to be traversed. Other data
332structures are traversed in very similar ways.<p>
333
Chris Lattnerae7f7592002-09-06 18:31:18 +0000334
335<!-- _______________________________________________________________________ -->
Chris Lattnercaa5d132002-09-09 19:58:18 +0000336</ul><h4><a name="iterate_function"><hr size=0>Iterating over the <a
337href="#BasicBlock"><tt>BasicBlock</tt></a>s in a <a
338href="#Function"><tt>Function</tt></a> </h4><ul>
Chris Lattnerae7f7592002-09-06 18:31:18 +0000339
Joel Stanley9b96c442002-09-06 21:55:13 +0000340It's quite common to have a <tt>Function</tt> instance that you'd like
341to transform in some way; in particular, you'd like to manipulate its
342<tt>BasicBlock</tt>s. To facilitate this, you'll need to iterate over
343all of the <tt>BasicBlock</tt>s that constitute the <tt>Function</tt>.
344The following is an example that prints the name of a
345<tt>BasicBlock</tt> and the number of <tt>Instruction</tt>s it
346contains:
Chris Lattnerae7f7592002-09-06 18:31:18 +0000347
Joel Stanley9b96c442002-09-06 21:55:13 +0000348<pre>
349 // func is a pointer to a Function instance
350 for(Function::iterator i = func->begin(), e = func->end(); i != e; ++i) {
351
352 // print out the name of the basic block if it has one, and then the
353 // number of instructions that it contains
354
Joel Stanley72ef35e2002-09-06 23:05:12 +0000355 cerr &lt;&lt "Basic block (name=" &lt;&lt i-&gt;getName() &lt;&lt; ") has "
356 &lt;&lt i-&gt;size() &lt;&lt " instructions.\n";
Joel Stanley9b96c442002-09-06 21:55:13 +0000357 }
358</pre>
359
360Note that i can be used as if it were a pointer for the purposes of
361invoking member functions of the <tt>Instruction</tt> class. This is
362because the indirection operator is overloaded for the iterator
363classes. In the above code, the expression <tt>i->size()</tt> is
364exactly equivalent to <tt>(*i).size()</tt> just like you'd expect.
Chris Lattnerae7f7592002-09-06 18:31:18 +0000365
366<!-- _______________________________________________________________________ -->
Chris Lattnercaa5d132002-09-09 19:58:18 +0000367</ul><h4><a name="iterate_basicblock"><hr size=0>Iterating over the <a
368href="#Instruction"><tt>Instruction</tt></a>s in a <a
369href="#BasicBlock"><tt>BasicBlock</tt></a> </h4><ul>
Chris Lattnerae7f7592002-09-06 18:31:18 +0000370
Joel Stanleyaaeb1c12002-09-06 23:42:40 +0000371Just like when dealing with <tt>BasicBlock</tt>s in
372<tt>Function</tt>s, it's easy to iterate over the individual
373instructions that make up <tt>BasicBlock</tt>s. Here's a code snippet
374that prints out each instruction in a <tt>BasicBlock</tt>:
Chris Lattnerae7f7592002-09-06 18:31:18 +0000375
Joel Stanley9b96c442002-09-06 21:55:13 +0000376<pre>
377 // blk is a pointer to a BasicBlock instance
Chris Lattnercaa5d132002-09-09 19:58:18 +0000378 for(BasicBlock::iterator i = blk-&gt;begin(), e = blk-&gt;end(); i != e; ++i)
Chris Lattner2b763062002-09-06 22:51:10 +0000379 // the next statement works since operator&lt;&lt;(ostream&amp;,...)
380 // is overloaded for Instruction&amp;
Chris Lattnercaa5d132002-09-09 19:58:18 +0000381 cerr &lt;&lt; *i &lt;&lt; "\n";
Joel Stanley9b96c442002-09-06 21:55:13 +0000382</pre>
383
384However, this isn't really the best way to print out the contents of a
385<tt>BasicBlock</tt>! Since the ostream operators are overloaded for
386virtually anything you'll care about, you could have just invoked the
Chris Lattner2b763062002-09-06 22:51:10 +0000387print routine on the basic block itself: <tt>cerr &lt;&lt; *blk &lt;&lt;
388"\n";</tt>.<p>
389
390Note that currently operator&lt;&lt; is implemented for <tt>Value*</tt>, so it
391will print out the contents of the pointer, instead of
392the pointer value you might expect. This is a deprecated interface that will
393be removed in the future, so it's best not to depend on it. To print out the
394pointer value for now, you must cast to <tt>void*</tt>.<p>
Chris Lattnerae7f7592002-09-06 18:31:18 +0000395
Chris Lattnercaa5d132002-09-09 19:58:18 +0000396
Chris Lattnerae7f7592002-09-06 18:31:18 +0000397<!-- _______________________________________________________________________ -->
Chris Lattnercaa5d132002-09-09 19:58:18 +0000398</ul><h4><a name="iterate_institer"><hr size=0>Iterating over the <a
399href="#Instruction"><tt>Instruction</tt></a>s in a <a
400href="#Function"><tt>Function</tt></a></h4><ul>
Chris Lattner1a3105b2002-09-09 05:49:39 +0000401
Joel Stanleye7be6502002-09-09 15:50:33 +0000402If you're finding that you commonly iterate over a <tt>Function</tt>'s
403<tt>BasicBlock</tt>s and then that <tt>BasicBlock</tt>'s
404<tt>Instruction</tt>s, <tt>InstIterator</tt> should be used instead.
Chris Lattnercaa5d132002-09-09 19:58:18 +0000405You'll need to include <a href="/doxygen/InstIterator_8h-source.html"><tt>llvm/Support/InstIterator.h</tt></a>, and then
Joel Stanleye7be6502002-09-09 15:50:33 +0000406instantiate <tt>InstIterator</tt>s explicitly in your code. Here's a
407small example that shows how to dump all instructions in a function to
408stderr (<b>Note:</b> Dereferencing an <tt>InstIterator</tt> yields an
409<tt>Instruction*</tt>, <i>not</i> an <tt>Instruction&amp</tt>!):
Chris Lattner1a3105b2002-09-09 05:49:39 +0000410
Joel Stanleye7be6502002-09-09 15:50:33 +0000411<pre>
Chris Lattnercaa5d132002-09-09 19:58:18 +0000412#include "<a href="/doxygen/InstIterator_8h-source.html">llvm/Support/InstIterator.h</a>"
Joel Stanleye7be6502002-09-09 15:50:33 +0000413...
414// Suppose F is a ptr to a function
415for(inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i)
416 cerr &lt;&lt **i &lt;&lt "\n";
417</pre>
Chris Lattner1a3105b2002-09-09 05:49:39 +0000418
Joel Stanleye7be6502002-09-09 15:50:33 +0000419Easy, isn't it? You can also use <tt>InstIterator</tt>s to fill a
420worklist with its initial contents. For example, if you wanted to
421initialize a worklist to contain all instructions in a
422<tt>Function</tt> F, all you would need to do is something like:
Chris Lattner1a3105b2002-09-09 05:49:39 +0000423
Joel Stanleye7be6502002-09-09 15:50:33 +0000424<pre>
425std::set&lt;Instruction*&gt worklist;
426worklist.insert(inst_begin(F), inst_end(F));
427</pre>
Chris Lattner1a3105b2002-09-09 05:49:39 +0000428
Joel Stanleye7be6502002-09-09 15:50:33 +0000429The STL set <tt>worklist</tt> would now contain all instructions in
430the <tt>Function</tt> pointed to by F.
Chris Lattner1a3105b2002-09-09 05:49:39 +0000431
432<!-- _______________________________________________________________________ -->
Chris Lattnerae7f7592002-09-06 18:31:18 +0000433</ul><h4><a name="iterate_convert"><hr size=0>Turning an iterator into a class
Joel Stanleye7be6502002-09-09 15:50:33 +0000434pointer (and vice-versa) </h4><ul>
Chris Lattnerae7f7592002-09-06 18:31:18 +0000435
Joel Stanley9b96c442002-09-06 21:55:13 +0000436Sometimes, it'll be useful to grab a reference (or pointer) to a class
437instance when all you've got at hand is an iterator. Well, extracting
438a reference or a pointer from an iterator is very straightforward.
439Assuming that <tt>i</tt> is a <tt>BasicBlock::iterator</tt> and
440<tt>j</tt> is a <tt>BasicBlock::const_iterator</tt>:
441
442<pre>
Chris Lattner83b5ee02002-09-06 22:12:58 +0000443 Instruction&amp; inst = *i; // grab reference to instruction reference
444 Instruction* pinst = &amp;*i; // grab pointer to instruction reference
445 const Instruction&amp; inst = *j;
Joel Stanley9b96c442002-09-06 21:55:13 +0000446</pre>
447However, the iterators you'll be working with in the LLVM framework
448are special: they will automatically convert to a ptr-to-instance type
449whenever they need to. Instead of dereferencing the iterator and then
450taking the address of the result, you can simply assign the iterator
451to the proper pointer type and you get the dereference and address-of
452operation as a result of the assignment (behind the scenes, this is a
453result of overloading casting mechanisms). Thus the last line of the
454last example,
455
Chris Lattner83b5ee02002-09-06 22:12:58 +0000456<pre>Instruction* pinst = &amp;*i;</pre>
Joel Stanley9b96c442002-09-06 21:55:13 +0000457
458is semantically equivalent to
459
460<pre>Instruction* pinst = i;</pre>
461
Chris Lattner979d9b72002-09-10 00:39:05 +0000462<b>Caveat emptor</b>: The above syntax works <i>only</i> when you're <i>not</i>
463working with <tt>dyn_cast</tt>. The template definition of <tt><a
464href="#isa">dyn_cast</a></tt> isn't implemented to handle this yet, so you'll
Joel Stanley9b96c442002-09-06 21:55:13 +0000465still need the following in order for things to work properly:
466
467<pre>
468BasicBlock::iterator bbi = ...;
Chris Lattnercaa5d132002-09-09 19:58:18 +0000469<a href="#BranchInst">BranchInst</a>* b = <a href="#isa">dyn_cast</a>&lt;<a href="#BranchInst">BranchInst</a>&gt;(&amp;*bbi);
Joel Stanley9b96c442002-09-06 21:55:13 +0000470</pre>
471
Joel Stanleye7be6502002-09-09 15:50:33 +0000472It's also possible to turn a class pointer into the corresponding
473iterator. Usually, this conversion is quite inexpensive. The
474following code snippet illustrates use of the conversion constructors
475provided by LLVM iterators. By using these, you can explicitly grab
476the iterator of something without actually obtaining it via iteration
477over some structure:
Joel Stanley9b96c442002-09-06 21:55:13 +0000478
479<pre>
480void printNextInstruction(Instruction* inst) {
481 BasicBlock::iterator it(inst);
482 ++it; // after this line, it refers to the instruction after *inst.
Chris Lattnercaa5d132002-09-09 19:58:18 +0000483 if(it != inst-&gt;getParent()->end()) cerr &lt;&lt; *it &lt;&lt; "\n";
Joel Stanley9b96c442002-09-06 21:55:13 +0000484}
485</pre>
Joel Stanleyaaeb1c12002-09-06 23:42:40 +0000486Of course, this example is strictly pedagogical, because it'd be much
487better to explicitly grab the next instruction directly from inst.
Joel Stanley9b96c442002-09-06 21:55:13 +0000488
Chris Lattnerae7f7592002-09-06 18:31:18 +0000489
Chris Lattner1a3105b2002-09-09 05:49:39 +0000490<!--_______________________________________________________________________-->
491</ul><h4><a name="iterate_complex"><hr size=0>Finding call sites: a slightly
492more complex example </h4><ul>
Joel Stanley9b96c442002-09-06 21:55:13 +0000493
494Say that you're writing a FunctionPass and would like to count all the
Joel Stanleye7be6502002-09-09 15:50:33 +0000495locations in the entire module (that is, across every
Joel Stanleyd8aabb22002-09-09 16:29:58 +0000496<tt>Function</tt>) where a certain function (i.e. some
497<tt>Function</tt>*) already in scope. As you'll learn later, you may
498want to use an <tt>InstVisitor</tt> to accomplish this in a much more
499straightforward manner, but this example will allow us to explore how
500you'd do it if you didn't have <tt>InstVisitor</tt> around. In
Joel Stanleye7be6502002-09-09 15:50:33 +0000501pseudocode, this is what we want to do:
Joel Stanley9b96c442002-09-06 21:55:13 +0000502
503<pre>
504initialize callCounter to zero
505for each Function f in the Module
506 for each BasicBlock b in f
507 for each Instruction i in b
Joel Stanleye7be6502002-09-09 15:50:33 +0000508 if(i is a CallInst and calls the given function)
Joel Stanley9b96c442002-09-06 21:55:13 +0000509 increment callCounter
510</pre>
511
512And the actual code is (remember, since we're writing a
Joel Stanleyd8aabb22002-09-09 16:29:58 +0000513<tt>FunctionPass</tt>, our <tt>FunctionPass</tt>-derived class simply
Joel Stanley9b96c442002-09-06 21:55:13 +0000514has to override the <tt>runOnFunction</tt> method...):
515
516<pre>
Joel Stanleyd8aabb22002-09-09 16:29:58 +0000517Function* targetFunc = ...;
518
Joel Stanleye7be6502002-09-09 15:50:33 +0000519class OurFunctionPass : public FunctionPass {
520 public:
Joel Stanleyd8aabb22002-09-09 16:29:58 +0000521 OurFunctionPass(): callCounter(0) { }
Joel Stanley9b96c442002-09-06 21:55:13 +0000522
Chris Lattnercaa5d132002-09-09 19:58:18 +0000523 virtual runOnFunction(Function&amp; F) {
Joel Stanleye7be6502002-09-09 15:50:33 +0000524 for(Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
525 for(BasicBlock::iterator i = b-&gt;begin(); ie = b-&gt;end(); i != ie; ++i) {
Chris Lattner979d9b72002-09-10 00:39:05 +0000526 if (<a href="#CallInst">CallInst</a>* callInst = <a href="#isa">dyn_cast</a>&lt;<a href="#CallInst">CallInst</a>&gt;(&amp;*inst)) {
Joel Stanleye7be6502002-09-09 15:50:33 +0000527 // we know we've encountered a call instruction, so we
528 // need to determine if it's a call to the
529 // function pointed to by m_func or not.
530
Joel Stanleyd8aabb22002-09-09 16:29:58 +0000531 if(callInst-&gt;getCalledFunction() == targetFunc)
Joel Stanleye7be6502002-09-09 15:50:33 +0000532 ++callCounter;
533 }
534 }
Joel Stanley9b96c442002-09-06 21:55:13 +0000535 }
Joel Stanleye7be6502002-09-09 15:50:33 +0000536
537 private:
Joel Stanleyd8aabb22002-09-09 16:29:58 +0000538 unsigned callCounter;
Joel Stanleye7be6502002-09-09 15:50:33 +0000539};
Joel Stanley9b96c442002-09-06 21:55:13 +0000540</pre>
541
Chris Lattner1a3105b2002-09-09 05:49:39 +0000542<!--_______________________________________________________________________-->
543</ul><h4><a name="iterate_chains"><hr size=0>Iterating over def-use &amp;
544use-def chains</h4><ul>
545
Chris Lattner1a3105b2002-09-09 05:49:39 +0000546<!--
547 def-use chains ("finding all users of"): Value::use_begin/use_end
548 use-def chains ("finding all values used"): User::op_begin/op_end [op=operand]
549-->
550
Chris Lattnerae7f7592002-09-06 18:31:18 +0000551<!-- ======================================================================= -->
552</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
553<tr><td>&nbsp;</td><td width="100%">&nbsp;
554<font color="#EEEEFF" face="Georgia,Palatino"><b>
555<a name="simplechanges">Making simple changes</a>
556</b></font></td></tr></table><ul>
557
558<!-- Value::replaceAllUsesWith
559 User::replaceUsesOfWith
560 Point out: include/llvm/Transforms/Utils/
561 especially BasicBlockUtils.h with:
562 ReplaceInstWithValue, ReplaceInstWithInst
563
564-->
Chris Lattnerb99344f2002-09-06 16:40:10 +0000565
Chris Lattner9355b472002-09-06 02:50:58 +0000566
567<!-- *********************************************************************** -->
568</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
569<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
Joel Stanley9b96c442002-09-06 21:55:13 +0000570<a name="coreclasses">The Core LLVM Class Hierarchy Reference
Chris Lattner9355b472002-09-06 02:50:58 +0000571</b></font></td></tr></table><ul>
572<!-- *********************************************************************** -->
573
574The Core LLVM classes are the primary means of representing the program being
575inspected or transformed. The core LLVM classes are defined in header files in
576the <tt>include/llvm/</tt> directory, and implemented in the <tt>lib/VMCore</tt>
577directory.<p>
578
579
580<!-- ======================================================================= -->
581</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
582<tr><td>&nbsp;</td><td width="100%">&nbsp;
583<font color="#EEEEFF" face="Georgia,Palatino"><b>
584<a name="Value">The <tt>Value</tt> class</a>
585</b></font></td></tr></table><ul>
586
587<tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt></b><br>
588doxygen info: <a href="/doxygen/classValue.html">Value Class</a><p>
589
590
591The <tt>Value</tt> class is the most important class in LLVM Source base. It
592represents a typed value that may be used (among other things) as an operand to
593an instruction. There are many different types of <tt>Value</tt>s, such as <a
594href="#Constant"><tt>Constant</tt></a>s, <a
595href="#Argument"><tt>Argument</tt></a>s, and even <a
596href="#Instruction"><tt>Instruction</tt></a>s and <a
597href="#Function"><tt>Function</tt></a>s are <tt>Value</tt>s.<p>
598
599A particular <tt>Value</tt> may be used many times in the LLVM representation
600for a program. For example, an incoming argument to a function (represented
601with an instance of the <a href="#Argument">Argument</a> class) is "used" by
602every instruction in the function that references the argument. To keep track
603of this relationship, the <tt>Value</tt> class keeps a list of all of the <a
604href="#User"><tt>User</tt></a>s that is using it (the <a
605href="#User"><tt>User</tt></a> class is a base class for all nodes in the LLVM
606graph that can refer to <tt>Value</tt>s). This use list is how LLVM represents
Joel Stanley9b96c442002-09-06 21:55:13 +0000607def-use information in the program, and is accessible through the <tt>use_</tt>*
Chris Lattner9355b472002-09-06 02:50:58 +0000608methods, shown below.<p>
609
610Because LLVM is a typed representation, every LLVM <tt>Value</tt> is typed, and
611this <a href="#Type">Type</a> is available through the <tt>getType()</tt>
612method. <a name="#nameWarning">In addition, all LLVM values can be named. The
613"name" of the <tt>Value</tt> is symbolic string printed in the LLVM code:<p>
614
615<pre>
616 %<b>foo</b> = add int 1, 2
617</pre>
618
619The name of this instruction is "foo". <b>NOTE</b> that the name of any value
620may be missing (an empty string), so names should <b>ONLY</b> be used for
621debugging (making the source code easier to read, debugging printouts), they
622should not be used to keep track of values or map between them. For this
623purpose, use a <tt>std::map</tt> of pointers to the <tt>Value</tt> itself
624instead.<p>
625
626One important aspect of LLVM is that there is no distinction between an SSA
627variable and the operation that produces it. Because of this, any reference to
628the value produced by an instruction (or the value available as an incoming
629argument, for example) is represented as a direct pointer to the class that
630represents this value. Although this may take some getting used to, it
631simplifies the representation and makes it easier to manipulate.<p>
632
633
634<!-- _______________________________________________________________________ -->
635</ul><h4><a name="m_Value"><hr size=0>Important Public Members of
636the <tt>Value</tt> class</h4><ul>
637
638<li><tt>Value::use_iterator</tt> - Typedef for iterator over the use-list<br>
639 <tt>Value::use_const_iterator</tt>
640 - Typedef for const_iterator over the use-list<br>
641 <tt>unsigned use_size()</tt> - Returns the number of users of the value.<br>
642 <tt>bool use_empty()</tt> - Returns true if there are no users.<br>
643 <tt>use_iterator use_begin()</tt>
644 - Get an iterator to the start of the use-list.<br>
645 <tt>use_iterator use_end()</tt>
646 - Get an iterator to the end of the use-list.<br>
647 <tt><a href="#User">User</a> *use_back()</tt>
648 - Returns the last element in the list.<p>
649
650These 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>
651
652<li><tt><a href="#Type">Type</a> *getType() const</tt><p>
653This method returns the Type of the Value.
654
655<li><tt>bool hasName() const</tt><br>
656 <tt>std::string getName() const</tt><br>
657 <tt>void setName(const std::string &amp;Name)</tt><p>
658
659This family of methods is used to access and assign a name to a <tt>Value</tt>,
660be aware of the <a href="#nameWarning">precaution above</a>.<p>
661
662
663<li><tt>void replaceAllUsesWith(Value *V)</tt><p>
664
665This method traverses the use list of a <tt>Value</tt> changing all <a
666href="#User"><tt>User</tt>'s</a> of the current value to refer to "<tt>V</tt>"
667instead. For example, if you detect that an instruction always produces a
668constant value (for example through constant folding), you can replace all uses
669of the instruction with the constant like this:<p>
670
671<pre>
672 Inst-&gt;replaceAllUsesWith(ConstVal);
673</pre><p>
674
675
676
677<!-- ======================================================================= -->
678</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
679<tr><td>&nbsp;</td><td width="100%">&nbsp;
680<font color="#EEEEFF" face="Georgia,Palatino"><b>
681<a name="User">The <tt>User</tt> class</a>
682</b></font></td></tr></table><ul>
683
684<tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt></b><br>
685doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
686Superclass: <a href="#Value"><tt>Value</tt></a><p>
687
688
689The <tt>User</tt> class is the common base class of all LLVM nodes that may
690refer to <a href="#Value"><tt>Value</tt></a>s. It exposes a list of "Operands"
691that are all of the <a href="#Value"><tt>Value</tt></a>s that the User is
692referring to. The <tt>User</tt> class itself is a subclass of
693<tt>Value</tt>.<p>
694
695The operands of a <tt>User</tt> point directly to the LLVM <a
696href="#Value"><tt>Value</tt></a> that it refers to. Because LLVM uses Static
697Single Assignment (SSA) form, there can only be one definition referred to,
698allowing this direct connection. This connection provides the use-def
699information in LLVM.<p>
700
701<!-- _______________________________________________________________________ -->
702</ul><h4><a name="m_User"><hr size=0>Important Public Members of
703the <tt>User</tt> class</h4><ul>
704
705The <tt>User</tt> class exposes the operand list in two ways: through an index
706access interface and through an iterator based interface.<p>
707
708<li><tt>Value *getOperand(unsigned i)</tt><br>
709 <tt>unsigned getNumOperands()</tt><p>
710
711These two methods expose the operands of the <tt>User</tt> in a convenient form
712for direct access.<p>
713
714<li><tt>User::op_iterator</tt> - Typedef for iterator over the operand list<br>
715 <tt>User::op_const_iterator</tt>
716 <tt>use_iterator op_begin()</tt>
717 - Get an iterator to the start of the operand list.<br>
718 <tt>use_iterator op_end()</tt>
719 - Get an iterator to the end of the operand list.<p>
720
721Together, these methods make up the iterator based interface to the operands of
722a <tt>User</tt>.<p>
723
724
725
726<!-- ======================================================================= -->
727</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
728<tr><td>&nbsp;</td><td width="100%">&nbsp;
729<font color="#EEEEFF" face="Georgia,Palatino"><b>
730<a name="Instruction">The <tt>Instruction</tt> class</a>
731</b></font></td></tr></table><ul>
732
733<tt>#include "<a
734href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt></b><br>
735doxygen info: <a href="/doxygen/classInstruction.html">Instruction Class</a><br>
736Superclasses: <a href="#User"><tt>User</tt></a>, <a
737href="#Value"><tt>Value</tt></a><p>
738
739The <tt>Instruction</tt> class is the common base class for all LLVM
740instructions. It provides only a few methods, but is a very commonly used
741class. The primary data tracked by the <tt>Instruction</tt> class itself is the
742opcode (instruction type) and the parent <a
743href="#BasicBlock"><tt>BasicBlock</tt></a> the <tt>Instruction</tt> is embedded
744into. To represent a specific type of instruction, one of many subclasses of
745<tt>Instruction</tt> are used.<p>
746
747Because the <tt>Instruction</tt> class subclasses the <a
748href="#User"><tt>User</tt></a> class, its operands can be accessed in the same
749way as for other <a href="#User"><tt>User</tt></a>s (with the
750<tt>getOperand()</tt>/<tt>getNumOperands()</tt> and
751<tt>op_begin()</tt>/<tt>op_end()</tt> methods).<p>
752
753
754<!-- _______________________________________________________________________ -->
755</ul><h4><a name="m_Instruction"><hr size=0>Important Public Members of
756the <tt>Instruction</tt> class</h4><ul>
757
758<li><tt><a href="#BasicBlock">BasicBlock</a> *getParent()</tt><p>
759
760Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
761<tt>Instruction</tt> is embedded into.<p>
762
763<li><tt>bool hasSideEffects()</tt><p>
764
765Returns true if the instruction has side effects, i.e. it is a <tt>call</tt>,
766<tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
767
768<li><tt>unsigned getOpcode()</tt><p>
769
770Returns the opcode for the <tt>Instruction</tt>.<p>
771
772<!--
773
774\subsection{Subclasses of Instruction :}
775\begin{itemize}
776<li>BinaryOperator : This subclass of Instruction defines a general interface to the all the instructions involvong binary operators in LLVM.
777 \begin{itemize}
778 <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.
779 \end{itemize}
780<li>TerminatorInst : This subclass of Instructions defines an interface for all instructions that can terminate a BasicBlock.
781 \begin{itemize}
782 <li> <tt>unsigned getNumSuccessors()</tt>: Returns the number of successors for this terminator instruction.
783 <li><tt>BasicBlock *getSuccessor(unsigned i)</tt>: As the name suggests returns the ith successor BasicBlock.
784 <li><tt>void setSuccessor(unsigned i, BasicBlock *B)</tt>: sets BasicBlock B as the ith succesor to this terminator instruction.
785 \end{itemize}
786
787<li>PHINode : This represents the PHI instructions in the SSA form.
788 \begin{itemize}
789 <li><tt> unsigned getNumIncomingValues()</tt>: Returns the number of incoming edges to this PHI node.
790 <li><tt> Value *getIncomingValue(unsigned i)</tt>: Returns the ith incoming Value.
791 <li><tt>void setIncomingValue(unsigned i, Value *V)</tt>: Sets the ith incoming Value as V
792 <li><tt>BasicBlock *getIncomingBlock(unsigned i)</tt>: Returns the Basic Block corresponding to the ith incoming Value.
793 <li><tt> void addIncoming(Value *D, BasicBlock *BB)</tt>:
794 Add an incoming value to the end of the PHI list
795 <li><tt> int getBasicBlockIndex(const BasicBlock *BB) const</tt>:
796 Returns the first index of the specified basic block in the value list for this PHI. Returns -1 if no instance.
797 \end{itemize}
798<li>CastInst : In LLVM all casts have to be done through explicit cast instructions. CastInst defines the interface to the cast instructions.
799<li>CallInst : This defines an interface to the call instruction in LLVM. ARguments to the function are nothing but operands of the instruction.
800 \begin{itemize}
801 <li>: <tt>Function *getCalledFunction()</tt>: Returns a handle to the function that is being called by this Function.
802 \end{itemize}
803<li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
804 \begin{itemize}
805 <li><tt>Value * getPointerOperand ()</tt>: Returns the Pointer Operand which is typically the 0th operand.
806 \end{itemize}
807<li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
808 \begin{itemize}
809 <li><tt>bool isConditional()</tt>: Returns true if the branch is a conditional branch else returns false
810 <li> <tt>Value *getCondition()</tt>: Returns the condition if it is a conditional branch else returns null.
811 <li> <tt>void setUnconditionalDest(BasicBlock *Dest)</tt>: Changes the current branch to an unconditional one targetting the specified block.
812 \end{itemize}
813
814\end{itemize}
815
816-->
817
818
819<!-- ======================================================================= -->
820</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
821<tr><td>&nbsp;</td><td width="100%">&nbsp;
822<font color="#EEEEFF" face="Georgia,Palatino"><b>
823<a name="BasicBlock">The <tt>BasicBlock</tt> class</a>
824</b></font></td></tr></table><ul>
825
826<tt>#include "<a
827href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt></b><br>
828doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
829Superclass: <a href="#Value"><tt>Value</tt></a><p>
830
831
832This class represents a single entry multiple exit section of the code, commonly
833known as a basic block by the compiler community. The <tt>BasicBlock</tt> class
834maintains a list of <a href="#Instruction"><tt>Instruction</tt></a>s, which form
835the body of the block. Matching the language definition, the last element of
836this list of instructions is always a terminator instruction (a subclass of the
837<a href="#TerminatorInst"><tt>TerminatorInst</tt></a> class).<p>
838
839In addition to tracking the list of instructions that make up the block, the
840<tt>BasicBlock</tt> class also keeps track of the <a
841href="#Function"><tt>Function</tt></a> that it is embedded into.<p>
842
843Note that <tt>BasicBlock</tt>s themselves are <a
844href="#Value"><tt>Value</tt></a>s, because they are referenced by instructions
845like branches and can go in the switch tables. <tt>BasicBlock</tt>s have type
846<tt>label</tt>.<p>
847
848
849<!-- _______________________________________________________________________ -->
850</ul><h4><a name="m_BasicBlock"><hr size=0>Important Public Members of
851the <tt>BasicBlock</tt> class</h4><ul>
852
853<li><tt>BasicBlock(const std::string &amp;Name = "", <a
854href="#Function">Function</a> *Parent = 0)</tt><p>
855
856The <tt>BasicBlock</tt> constructor is used to create new basic blocks for
857insertion into a function. The constructor simply takes a name for the new
858block, and optionally a <a href="#Function"><tt>Function</tt></a> to insert it
859into. If the <tt>Parent</tt> parameter is specified, the new
860<tt>BasicBlock</tt> is automatically inserted at the end of the specified <a
861href="#Function"><tt>Function</tt></a>, if not specified, the BasicBlock must be
862manually inserted into the <a href="#Function"><tt>Function</tt></a>.<p>
863
864<li><tt>BasicBlock::iterator</tt> - Typedef for instruction list iterator<br>
865 <tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
866 <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
867 <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
868
869These methods and typedefs are forwarding functions that have the same semantics
870as the standard library methods of the same names. These methods expose the
871underlying instruction list of a basic block in a way that is easy to
872manipulate. To get the full complement of container operations (including
873operations to update the list), you must use the <tt>getInstList()</tt>
874method.<p>
875
876<li><tt>BasicBlock::InstListType &amp;getInstList()</tt><p>
877
878This method is used to get access to the underlying container that actually
879holds the Instructions. This method must be used when there isn't a forwarding
880function in the <tt>BasicBlock</tt> class for the operation that you would like
881to perform. Because there are no forwarding functions for "updating"
882operations, you need to use this if you want to update the contents of a
883<tt>BasicBlock</tt>.<p>
884
885<li><tt><A href="#Function">Function</a> *getParent()</tt><p>
886
887Returns a pointer to <a href="#Function"><tt>Function</tt></a> the block is
888embedded into, or a null pointer if it is homeless.<p>
889
890<li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt><p>
891
892Returns a pointer to the terminator instruction that appears at the end of the
893<tt>BasicBlock</tt>. If there is no terminator instruction, or if the last
894instruction in the block is not a terminator, then a null pointer is
895returned.<p>
896
897
898<!-- ======================================================================= -->
899</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
900<tr><td>&nbsp;</td><td width="100%">&nbsp;
901<font color="#EEEEFF" face="Georgia,Palatino"><b>
902<a name="GlobalValue">The <tt>GlobalValue</tt> class</a>
903</b></font></td></tr></table><ul>
904
905<tt>#include "<a
906href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt></b><br>
907doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue Class</a><br>
908Superclasses: <a href="#User"><tt>User</tt></a>, <a
909href="#Value"><tt>Value</tt></a><p>
910
911Global values (<A href="#GlobalVariable"><tt>GlobalVariable</tt></a>s or <a
912href="#Function"><tt>Function</tt></a>s) are the only LLVM values that are
913visible in the bodies of all <a href="#Function"><tt>Function</tt></a>s.
914Because they are visible at global scope, they are also subject to linking with
915other globals defined in different translation units. To control the linking
916process, <tt>GlobalValue</tt>s know their linkage rules. Specifically,
917<tt>GlobalValue</tt>s know whether they have internal or external linkage.<p>
918
919If a <tt>GlobalValue</tt> has internal linkage (equivalent to being
920<tt>static</tt> in C), it is not visible to code outside the current translation
921unit, and does not participate in linking. If it has external linkage, it is
922visible to external code, and does participate in linking. In addition to
923linkage information, <tt>GlobalValue</tt>s keep track of which <a
924href="#Module"><tt>Module</tt></a> they are currently part of.<p>
925
926Because <tt>GlobalValue</tt>s are memory objects, they are always referred to by
927their address. As such, the <a href="#Type"><tt>Type</tt></a> of a global is
928always a pointer to its contents. This is explained in the LLVM Language
929Reference Manual.<p>
930
931
932<!-- _______________________________________________________________________ -->
933</ul><h4><a name="m_GlobalValue"><hr size=0>Important Public Members of
934the <tt>GlobalValue</tt> class</h4><ul>
935
936<li><tt>bool hasInternalLinkage() const</tt><br>
937 <tt>bool hasExternalLinkage() const</tt><br>
938 <tt>void setInternalLinkage(bool HasInternalLinkage)</tt><p>
939
940These methods manipulate the linkage characteristics of the
941<tt>GlobalValue</tt>.<p>
942
943<li><tt><a href="#Module">Module</a> *getParent()</tt><p>
944
945This returns the <a href="#Module"><tt>Module</tt></a> that the GlobalValue is
946currently embedded into.<p>
947
948
949
950<!-- ======================================================================= -->
951</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
952<tr><td>&nbsp;</td><td width="100%">&nbsp;
953<font color="#EEEEFF" face="Georgia,Palatino"><b>
954<a name="Function">The <tt>Function</tt> class</a>
955</b></font></td></tr></table><ul>
956
957<tt>#include "<a
958href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt></b><br>
959doxygen info: <a href="/doxygen/classFunction.html">Function Class</a><br>
960Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
961href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
962
963The <tt>Function</tt> class represents a single procedure in LLVM. It is
964actually one of the more complex classes in the LLVM heirarchy because it must
965keep track of a large amount of data. The <tt>Function</tt> class keeps track
966of a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, a list of formal <a
967href="#Argument"><tt>Argument</tt></a>s, and a <a
968href="#SymbolTable"><tt>SymbolTable</tt></a>.<p>
969
970The list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s is the most commonly
971used part of <tt>Function</tt> objects. The list imposes an implicit ordering
972of the blocks in the function, which indicate how the code will be layed out by
973the backend. Additionally, the first <a
974href="#BasicBlock"><tt>BasicBlock</tt></a> is the implicit entry node for the
975<tt>Function</tt>. It is not legal in LLVM explicitly branch to this initial
976block. There are no implicit exit nodes, and in fact there may be multiple exit
977nodes from a single <tt>Function</tt>. If the <a
978href="#BasicBlock"><tt>BasicBlock</tt></a> list is empty, this indicates that
979the <tt>Function</tt> is actually a function declaration: the actual body of the
980function hasn't been linked in yet.<p>
981
982In addition to a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, the
983<tt>Function</tt> class also keeps track of the list of formal <a
984href="#Argument"><tt>Argument</tt></a>s that the function receives. This
985container manages the lifetime of the <a href="#Argument"><tt>Argument</tt></a>
986nodes, just like the <a href="#BasicBlock"><tt>BasicBlock</tt></a> list does for
987the <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.<p>
988
989The <a href="#SymbolTable"><tt>SymbolTable</tt></a> is a very rarely used LLVM
990feature that is only used when you have to look up a value by name. Aside from
991that, the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is used internally to
992make sure that there are not conflicts between the names of <a
993href="#Instruction"><tt>Instruction</tt></a>s, <a
994href="#BasicBlock"><tt>BasicBlock</tt></a>s, or <a
995href="#Argument"><tt>Argument</tt></a>s in the function body.<p>
996
997
998<!-- _______________________________________________________________________ -->
999</ul><h4><a name="m_Function"><hr size=0>Important Public Members of
1000the <tt>Function</tt> class</h4><ul>
1001
1002<li><tt>Function(const <a href="#FunctionType">FunctionType</a> *Ty, bool isInternal, const std::string &amp;N = "")</tt><p>
1003
1004Constructor used when you need to create new <tt>Function</tt>s to add the the
1005program. The constructor must specify the type of the function to create and
1006whether or not it should start out with internal or external linkage.<p>
1007
1008<li><tt>bool isExternal()</tt><p>
1009
1010Return whether or not the <tt>Function</tt> has a body defined. If the function
1011is "external", it does not have a body, and thus must be resolved by linking
1012with a function defined in a different translation unit.<p>
1013
1014
1015<li><tt>Function::iterator</tt> - Typedef for basic block list iterator<br>
1016 <tt>Function::const_iterator</tt> - Typedef for const_iterator.<br>
1017 <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
1018 <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
1019
1020These are forwarding methods that make it easy to access the contents of a
1021<tt>Function</tt> object's <a href="#BasicBlock"><tt>BasicBlock</tt></a>
1022list.<p>
1023
1024<li><tt>Function::BasicBlockListType &amp;getBasicBlockList()</tt><p>
1025
1026Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s. This is
1027neccesary to use when you need to update the list or perform a complex action
1028that doesn't have a forwarding method.<p>
1029
1030
1031<li><tt>Function::aiterator</tt> - Typedef for the argument list iterator<br>
1032 <tt>Function::const_aiterator</tt> - Typedef for const_iterator.<br>
1033 <tt>abegin()</tt>, <tt>aend()</tt>, <tt>afront()</tt>, <tt>aback()</tt>,
1034 <tt>asize()</tt>, <tt>aempty()</tt>, <tt>arbegin()</tt>, <tt>arend()</tt><p>
1035
1036These are forwarding methods that make it easy to access the contents of a
1037<tt>Function</tt> object's <a href="#Argument"><tt>Argument</tt></a> list.<p>
1038
1039<li><tt>Function::ArgumentListType &amp;getArgumentList()</tt><p>
1040
1041Returns the list of <a href="#Argument"><tt>Argument</tt></a>s. This is
1042neccesary to use when you need to update the list or perform a complex action
1043that doesn't have a forwarding method.<p>
1044
1045
1046
1047<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryNode()</tt><p>
1048
1049Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
1050function. Because the entry block for the function is always the first block,
1051this returns the first block of the <tt>Function</tt>.<p>
1052
1053<li><tt><a href="#Type">Type</a> *getReturnType()</tt><br>
1054 <tt><a href="#FunctionType">FunctionType</a> *getFunctionType()</tt><p>
1055
1056This traverses the <a href="#Type"><tt>Type</tt></a> of the <tt>Function</tt>
1057and returns the return type of the function, or the <a
1058href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
1059
1060
1061<li><tt>bool hasSymbolTable() const</tt><p>
1062
1063Return true if the <tt>Function</tt> has a symbol table allocated to it and if
1064there is at least one entry in it.<p>
1065
1066<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
1067
1068Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
1069<tt>Function</tt> or a null pointer if one has not been allocated (because there
1070are no named values in the function).<p>
1071
1072<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
1073
1074Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
1075<tt>Function</tt> or allocate a new <a
1076href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around. This
1077should only be used when adding elements to the <a
1078href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
1079not left laying around.<p>
1080
1081
1082
1083<!-- ======================================================================= -->
1084</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1085<tr><td>&nbsp;</td><td width="100%">&nbsp;
1086<font color="#EEEEFF" face="Georgia,Palatino"><b>
1087<a name="GlobalVariable">The <tt>GlobalVariable</tt> class</a>
1088</b></font></td></tr></table><ul>
1089
1090<tt>#include "<a
1091href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt></b><br>
1092doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable Class</a><br>
1093Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
1094href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
1095
Chris Lattner0377de42002-09-06 14:50:55 +00001096Global variables are represented with the (suprise suprise)
1097<tt>GlobalVariable</tt> class. Like functions, <tt>GlobalVariable</tt>s are
1098also subclasses of <a href="#GlobalValue"><tt>GlobalValue</tt></a>, and as such
1099are always referenced by their address (global values must live in memory, so
1100their "name" refers to their address). Global variables may have an initial
1101value (which must be a <a href="#Constant"><tt>Constant</tt></a>), and if they
1102have an initializer, they may be marked as "constant" themselves (indicating
1103that their contents never change at runtime).<p>
Chris Lattner9355b472002-09-06 02:50:58 +00001104
1105
1106<!-- _______________________________________________________________________ -->
Chris Lattner0377de42002-09-06 14:50:55 +00001107</ul><h4><a name="m_GlobalVariable"><hr size=0>Important Public Members of the
1108<tt>GlobalVariable</tt> class</h4><ul>
Chris Lattner9355b472002-09-06 02:50:58 +00001109
1110<li><tt>GlobalVariable(const <a href="#Type">Type</a> *Ty, bool isConstant, bool
1111isInternal, <a href="#Constant">Constant</a> *Initializer = 0, const std::string
1112&amp;Name = "")</tt><p>
1113
Chris Lattner0377de42002-09-06 14:50:55 +00001114Create a new global variable of the specified type. If <tt>isConstant</tt> is
1115true then the global variable will be marked as unchanging for the program, and
1116if <tt>isInternal</tt> is true the resultant global variable will have internal
1117linkage. Optionally an initializer and name may be specified for the global variable as well.<p>
1118
1119
Chris Lattner9355b472002-09-06 02:50:58 +00001120<li><tt>bool isConstant() const</tt><p>
1121
1122Returns true if this is a global variable is known not to be modified at
1123runtime.<p>
1124
Chris Lattner0377de42002-09-06 14:50:55 +00001125
Chris Lattner9355b472002-09-06 02:50:58 +00001126<li><tt>bool hasInitializer()</tt><p>
1127
1128Returns true if this <tt>GlobalVariable</tt> has an intializer.<p>
1129
Chris Lattner0377de42002-09-06 14:50:55 +00001130
Chris Lattner9355b472002-09-06 02:50:58 +00001131<li><tt><a href="#Constant">Constant</a> *getInitializer()</tt><p>
1132
Chris Lattner0377de42002-09-06 14:50:55 +00001133Returns the intial value for a <tt>GlobalVariable</tt>. It is not legal to call
1134this method if there is no initializer.<p>
1135
1136
1137<!-- ======================================================================= -->
1138</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1139<tr><td>&nbsp;</td><td width="100%">&nbsp;
1140<font color="#EEEEFF" face="Georgia,Palatino"><b>
1141<a name="Module">The <tt>Module</tt> class</a>
1142</b></font></td></tr></table><ul>
1143
1144<tt>#include "<a
1145href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt></b><br>
1146doxygen info: <a href="/doxygen/classModule.html">Module Class</a><p>
1147
1148The <tt>Module</tt> class represents the top level structure present in LLVM
1149programs. An LLVM module is effectively either a translation unit of the
1150original program or a combination of several translation units merged by the
1151linker. The <tt>Module</tt> class keeps track of a list of <a
1152href="#Function"><tt>Function</tt></a>s, a list of <a
1153href="#GlobalVariable"><tt>GlobalVariable</tt></a>s, and a <a
1154href="#SymbolTable"><tt>SymbolTable</tt></a>. Additionally, it contains a few
1155helpful member functions that try to make common operations easy.<p>
1156
1157
1158<!-- _______________________________________________________________________ -->
1159</ul><h4><a name="m_Module"><hr size=0>Important Public Members of the
1160<tt>Module</tt> class</h4><ul>
1161
1162<li><tt>Module::iterator</tt> - Typedef for function list iterator<br>
1163 <tt>Module::const_iterator</tt> - Typedef for const_iterator.<br>
1164 <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
1165 <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
1166
1167These are forwarding methods that make it easy to access the contents of a
1168<tt>Module</tt> object's <a href="#Function"><tt>Function</tt></a>
1169list.<p>
1170
1171<li><tt>Module::FunctionListType &amp;getFunctionList()</tt><p>
1172
1173Returns the list of <a href="#Function"><tt>Function</tt></a>s. This is
1174neccesary to use when you need to update the list or perform a complex action
1175that doesn't have a forwarding method.<p>
1176
1177<!-- Global Variable -->
1178<hr size=0>
1179
1180<li><tt>Module::giterator</tt> - Typedef for global variable list iterator<br>
1181 <tt>Module::const_giterator</tt> - Typedef for const_iterator.<br>
1182 <tt>gbegin()</tt>, <tt>gend()</tt>, <tt>gfront()</tt>, <tt>gback()</tt>,
1183 <tt>gsize()</tt>, <tt>gempty()</tt>, <tt>grbegin()</tt>, <tt>grend()</tt><p>
1184
1185These are forwarding methods that make it easy to access the contents of a
1186<tt>Module</tt> object's <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>
1187list.<p>
1188
1189<li><tt>Module::GlobalListType &amp;getGlobalList()</tt><p>
1190
1191Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
1192This is neccesary to use when you need to update the list or perform a complex
1193action that doesn't have a forwarding method.<p>
1194
1195
1196<!-- Symbol table stuff -->
1197<hr size=0>
1198
1199<li><tt>bool hasSymbolTable() const</tt><p>
1200
1201Return true if the <tt>Module</tt> has a symbol table allocated to it and if
1202there is at least one entry in it.<p>
1203
1204<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
1205
1206Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
1207<tt>Module</tt> or a null pointer if one has not been allocated (because there
1208are no named values in the function).<p>
1209
1210<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
1211
1212Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
1213<tt>Module</tt> or allocate a new <a
1214href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around. This
1215should only be used when adding elements to the <a
1216href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
1217not left laying around.<p>
1218
1219
1220<!-- Convenience methods -->
1221<hr size=0>
1222
1223<li><tt><a href="#Function">Function</a> *getFunction(const std::string &amp;Name, const <a href="#FunctionType">FunctionType</a> *Ty)</tt><p>
1224
1225Look up the specified function in the <tt>Module</tt> <a
1226href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, return
1227<tt>null</tt>.<p>
1228
1229
1230<li><tt><a href="#Function">Function</a> *getOrInsertFunction(const std::string
1231 &amp;Name, const <a href="#FunctionType">FunctionType</a> *T)</tt><p>
1232
1233Look up the specified function in the <tt>Module</tt> <a
1234href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, add an
1235external declaration for the function and return it.<p>
1236
1237
1238<li><tt>std::string getTypeName(const <a href="#Type">Type</a> *Ty)</tt><p>
1239
1240If there is at least one entry in the <a
1241href="#SymbolTable"><tt>SymbolTable</tt></a> for the specified <a
1242href="#Type"><tt>Type</tt></a>, return it. Otherwise return the empty
1243string.<p>
1244
1245
1246<li><tt>bool addTypeName(const std::string &Name, const <a href="#Type">Type</a>
1247*Ty)</tt><p>
1248
1249Insert an entry in the <a href="#SymbolTable"><tt>SymbolTable</tt></a> mapping
1250<tt>Name</tt> to <tt>Ty</tt>. If there is already an entry for this name, true
1251is returned and the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is not
1252modified.<p>
1253
Chris Lattner9355b472002-09-06 02:50:58 +00001254
1255<!-- ======================================================================= -->
1256</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1257<tr><td>&nbsp;</td><td width="100%">&nbsp;
1258<font color="#EEEEFF" face="Georgia,Palatino"><b>
1259<a name="Constant">The <tt>Constant</tt> class and subclasses</a>
1260</b></font></td></tr></table><ul>
1261
1262Constant represents a base class for different types of constants. It is
1263subclassed by ConstantBool, ConstantInt, ConstantSInt, ConstantUInt,
1264ConstantArray etc for representing the various types of Constants.<p>
1265
1266
1267<!-- _______________________________________________________________________ -->
1268</ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
1269
1270<li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
1271
1272
1273
1274
1275\subsection{Important Subclasses of Constant}
1276\begin{itemize}
1277<li>ConstantSInt : This subclass of Constant represents a signed integer constant.
1278 \begin{itemize}
1279 <li><tt>int64_t getValue () const</tt>: Returns the underlying value of this constant.
1280 \end{itemize}
1281<li>ConstantUInt : This class represents an unsigned integer.
1282 \begin{itemize}
1283 <li><tt>uint64_t getValue () const</tt>: Returns the underlying value of this constant.
1284 \end{itemize}
1285<li>ConstantFP : This class represents a floating point constant.
1286 \begin{itemize}
1287 <li><tt>double getValue () const</tt>: Returns the underlying value of this constant.
1288 \end{itemize}
1289<li>ConstantBool : This represents a boolean constant.
1290 \begin{itemize}
1291 <li><tt>bool getValue () const</tt>: Returns the underlying value of this constant.
1292 \end{itemize}
1293<li>ConstantArray : This represents a constant array.
1294 \begin{itemize}
1295 <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
1296 \end{itemize}
1297<li>ConstantStruct : This represents a constant struct.
1298 \begin{itemize}
1299 <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
1300 \end{itemize}
1301<li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
1302 \begin{itemize}
1303<li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
1304 \end{itemize}
1305\end{itemize}
1306
1307
1308<!-- ======================================================================= -->
1309</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1310<tr><td>&nbsp;</td><td width="100%">&nbsp;
1311<font color="#EEEEFF" face="Georgia,Palatino"><b>
1312<a name="Type">The <tt>Type</tt> class and Derived Types</a>
1313</b></font></td></tr></table><ul>
1314
1315Type as noted earlier is also a subclass of a Value class. Any primitive
1316type (like int, short etc) in LLVM is an instance of Type Class. All
1317other types are instances of subclasses of type like FunctionType,
1318ArrayType etc. DerivedType is the interface for all such dervied types
1319including FunctionType, ArrayType, PointerType, StructType. Types can have
1320names. They can be recursive (StructType). There exists exactly one instance
1321of any type structure at a time. This allows using pointer equality of Type *s for comparing types.
1322
1323<!-- _______________________________________________________________________ -->
1324</ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
1325
1326<li><tt>PrimitiveID getPrimitiveID () const</tt>: Returns the base type of the type.
1327<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.
1328<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.
1329<li><tt> bool isInteger () const</tt>: Equilivent to isSigned() || isUnsigned(), but with only a single virtual function invocation.
1330<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.
1331
1332<li><tt>bool isFloatingPoint ()</tt>: Return true if this is one of the two floating point types.
1333<li><tt>bool isRecursive () const</tt>: Returns rue if the type graph contains a cycle.
1334<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.
1335<li><tt>bool isPrimitiveType () const</tt>: Returns true if it is a primitive type.
1336<li><tt>bool isDerivedType () const</tt>: Returns true if it is a derived type.
1337<li><tt>const Type * getContainedType (unsigned i) const</tt>:
1338This 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.
1339<li><tt>unsigned getNumContainedTypes () const</tt>: Return the number of types in the derived type.
1340
1341
1342
1343\subsection{Derived Types}
1344\begin{itemize}
1345<li>SequentialType : This is subclassed by ArrayType and PointerType
1346 \begin{itemize}
1347 <li><tt>const Type * getElementType () const</tt>: Returns the type of each of the elements in the sequential type.
1348 \end{itemize}
1349<li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
1350 \begin{itemize}
1351 <li><tt>unsigned getNumElements () const</tt>: Returns the number of elements in the array.
1352 \end{itemize}
1353<li>PointerType : Subclass of SequentialType for pointer types.
1354<li>StructType : subclass of DerivedTypes for struct types
1355<li>FunctionType : subclass of DerivedTypes for function types.
1356 \begin{itemize}
1357
1358 <li><tt>bool isVarArg () const</tt>: Returns true if its a vararg function
1359 <li><tt> const Type * getReturnType () const</tt>: Returns the return type of the function.
1360 <li><tt> const ParamTypes &amp;getParamTypes () const</tt>: Returns a vector of parameter types.
1361 <li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
1362 <li><tt> const unsigned getNumParams () const</tt>: Returns the number of formal parameters.
1363 \end{itemize}
1364\end{itemize}
1365
1366
1367
1368
1369<!-- ======================================================================= -->
1370</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
1371<tr><td>&nbsp;</td><td width="100%">&nbsp;
1372<font color="#EEEEFF" face="Georgia,Palatino"><b>
1373<a name="Argument">The <tt>Argument</tt> class</a>
1374</b></font></td></tr></table><ul>
1375
1376This subclass of Value defines the interface for incoming formal arguments to a
1377function. A Function maitanis a list of its formal arguments. An argument has a
1378pointer to the parent Function.
1379
1380
1381
1382
1383<!-- *********************************************************************** -->
1384</ul>
1385<!-- *********************************************************************** -->
1386
1387<hr><font size-1>
1388<address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
1389<a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
1390<!-- Created: Tue Aug 6 15:00:33 CDT 2002 -->
1391<!-- hhmts start -->
Chris Lattner6b121f12002-09-10 15:20:46 +00001392Last modified: Tue Sep 10 10:19:56 CDT 2002
Chris Lattner9355b472002-09-06 02:50:58 +00001393<!-- hhmts end -->
1394</font></body></html>