Blame - docs/ProgrammersManual.html - fp2-dev/platform/external/llvm

blob: 8aeec6ea2ba26e51c829d31e3b76ec445b0daaae [file] [log] [blame]

Chris Lattner	9355b47	2002-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 Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	6	<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
				7	<tr><td>  <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 Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	15	<!--
				16	<li>The <tt>-time-passes</tt> option
				17	<li>How to use the LLVM Makefile system
				18	<li>How to write a regression test
				19	-->
				20	</ul>
				21	<li><a href="#apis">Important and useful LLVM APIs</a>
				22	<ul>
Chris Lattner	1d43fd4	2002-09-09 05:53:21 +0000	[diff] [blame]	23	<li><a href="#isa">The <tt>isa<></tt>, <tt>cast<></tt> and
				24	<tt>dyn_cast<></tt> templates</a>
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	25	<li><a href="#DEBUG">The <tt>DEBUG()</tt> macro &
				26	<tt>-debug</tt> option</a>
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	27	<ul>
				28	<li><a href="#DEBUG_TYPE">Fine grained debug info with
				29	<tt>DEBUG_TYPE</tt> and the <tt>-debug-only</tt> option</a/>
				30	</ul>
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	31	<li><a href="#Statistic">The <tt>Statistic</tt> template &
				32	<tt>-stats</tt> option</a>
				33	<!--
				34	<li>The <tt>InstVisitor</tt> template
				35	<li>The general graph API
				36	-->
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	37	</ul>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	38	<li><a href="#common">Helpful Hints for Common Operations</a>
				39	<ul>
				40	<li><a href="#inspection">Basic Inspection and Traversal Routines</a>
				41	<ul>
				42	<li><a href="#iterate_function">Iterating over the <tt>BasicBlock</tt>s
				43	in a <tt>Function</tt></a>
				44	<li><a href="#iterate_basicblock">Iterating over the <tt>Instruction</tt>s
				45	in a <tt>BasicBlock</tt></a>
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	46	<li><a href="#iterate_institer">Iterating over the <tt>Instruction</tt>s
				47	in a <tt>Function</tt></a>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	48	<li><a href="#iterate_convert">Turning an iterator into a class
				49	pointer</a>
Chris Lattner	f1ebdc3	2002-09-06 22:09:21 +0000	[diff] [blame]	50	<li><a href="#iterate_complex">Finding call sites: a more complex
				51	example</a>
Brian Gaeke	f1972c6	2003-11-07 19:25:45 +0000	[diff] [blame^]	52	<li><a href="#calls_and_invokes">Treating calls and invokes the
				53	same way</a>
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	54	<li><a href="#iterate_chains">Iterating over def-use & use-def
				55	chains</a>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	56	</ul>
				57	<li><a href="#simplechanges">Making simple changes</a>
				58	<ul>
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	59	<li><a href="#schanges_creating">Creating and inserting new
				60	<tt>Instruction</tt>s</a>
				61	<li><a href="#schanges_deleting">Deleting
				62	<tt>Instruction</tt>s</a>
				63	<li><a href="#schanges_replacing">Replacing an
				64	<tt>Instruction</tt> with another <tt>Value</tt></a>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	65	</ul>
				66	<!--
				67	<li>Working with the Control Flow Graph
				68	<ul>
				69	<li>Accessing predecessors and successors of a <tt>BasicBlock</tt>
				70	<li>
				71	<li>
				72	</ul>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	73	-->
				74	</ul>
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	75	<li><a href="#coreclasses">The Core LLVM Class Hierarchy Reference</a>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	76	<ul>
				77	<li><a href="#Value">The <tt>Value</tt> class</a>
				78	<ul>
				79	<li><a href="#User">The <tt>User</tt> class</a>
				80	<ul>
				81	<li><a href="#Instruction">The <tt>Instruction</tt> class</a>
				82	<ul>
				83	<li>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	84	</ul>
				85	<li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
				86	<ul>
				87	<li><a href="#BasicBlock">The <tt>BasicBlock</tt> class</a>
				88	<li><a href="#Function">The <tt>Function</tt> class</a>
				89	<li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class</a>
				90	</ul>
				91	<li><a href="#Module">The <tt>Module</tt> class</a>
				92	<li><a href="#Constant">The <tt>Constant</tt> class</a>
				93	<ul>
				94	<li>
				95	<li>
				96	</ul>
				97	</ul>
				98	<li><a href="#Type">The <tt>Type</tt> class</a>
				99	<li><a href="#Argument">The <tt>Argument</tt> class</a>
				100	</ul>
				101	<li>The <tt>SymbolTable</tt> class
				102	<li>The <tt>ilist</tt> and <tt>iplist</tt> classes
				103	<ul>
				104	<li>Creating, inserting, moving and deleting from LLVM lists
				105	</ul>
				106	<li>Important iterator invalidation semantics to be aware of
				107	</ul>
				108
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	109	<p><b>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a>,
				110	<a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>, and
Chris Lattner	f1ebdc3	2002-09-06 22:09:21 +0000	[diff] [blame]	111	<a href="mailto:jstanley@cs.uiuc.edu">Joel Stanley</a></b><p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	112	</ol>
				113
				114
				115	<!-- *********************************************************************** -->
				116	<table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
				117	<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
				118	<a name="introduction">Introduction
				119	</b></font></td></tr></table><ul>
				120	<!-- *********************************************************************** -->
				121
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	122	This document is meant to highlight some of the important classes and interfaces
				123	available in the LLVM source-base. This manual is not intended to explain what
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	124	LLVM is, how it works, and what LLVM code looks like. It assumes that you know
				125	the basics of LLVM and are interested in writing transformations or otherwise
				126	analyzing or manipulating the code.<p>
				127
				128	This document should get you oriented so that you can find your way in the
				129	continuously growing source code that makes up the LLVM infrastructure. Note
				130	that this manual is not intended to serve as a replacement for reading the
				131	source code, so if you think there should be a method in one of these classes to
				132	do something, but it's not listed, check the source. Links to the <a
				133	href="/doxygen/">doxygen</a> sources are provided to make this as easy as
				134	possible.<p>
				135
				136	The first section of this document describes general information that is useful
				137	to know when working in the LLVM infrastructure, and the second describes the
				138	Core LLVM classes. In the future this manual will be extended with information
				139	describing how to use extension libraries, such as dominator information, CFG
				140	traversal routines, and useful utilities like the <tt><a
				141	href="/doxygen/InstVisitor_8h-source.html">InstVisitor</a></tt> template.<p>
				142
				143
				144	<!-- *********************************************************************** -->
				145	</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
				146	<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
				147	<a name="general">General Information
				148	</b></font></td></tr></table><ul>
				149	<!-- *********************************************************************** -->
				150
				151	This section contains general information that is useful if you are working in
				152	the LLVM source-base, but that isn't specific to any particular API.<p>
				153
				154
				155	<!-- ======================================================================= -->
				156	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				157	<tr><td> </td><td width="100%">
				158	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				159	<a name="stl">The C++ Standard Template Library</a>
				160	</b></font></td></tr></table><ul>
				161
				162	LLVM makes heavy use of the C++ Standard Template Library (STL), perhaps much
				163	more than you are used to, or have seen before. Because of this, you might want
				164	to do a little background reading in the techniques used and capabilities of the
				165	library. There are many good pages that discuss the STL, and several books on
				166	the subject that you can get, so it will not be discussed in this document.<p>
				167
				168	Here are some useful links:<p>
				169	<ol>
Chris Lattner	ab0577b	2002-09-22 21:25:12 +0000	[diff] [blame]	170	<li><a href="http://www.dinkumware.com/refxcpp.html">Dinkumware C++
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	171	Library reference</a> - an excellent reference for the STL and other parts of
Chris Lattner	e9ddc7f	2002-10-21 02:38:02 +0000	[diff] [blame]	172	the standard C++ library.
				173
				174	<li><a href="http://www.tempest-sw.com/cpp/">C++ In a Nutshell</a> - This is an
				175	O'Reilly book in the making. It has a decent <a
				176	href="http://www.tempest-sw.com/cpp/ch13-libref.html">Standard Library
				177	Reference</a> that rivals Dinkumware's, and is actually free until the book is
				178	published.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	179
				180	<li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
				181	Questions</a>
				182
				183	<li><a href="http://www.sgi.com/tech/stl/">SGI's STL Programmer's Guide</a> -
				184	Contains a useful <a
				185	href="http://www.sgi.com/tech/stl/stl_introduction.html">Introduction to the
				186	STL</a>.
				187
				188	<li><a href="http://www.research.att.com/~bs/C++.html">Bjarne Stroustrup's C++
				189	Page</a>
				190
				191	</ol><p>
				192
				193	You are also encouraged to take a look at the <a
				194	href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
				195	to write maintainable code more than where to put your curly braces.<p>
				196
				197
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	198	<!-- *********************************************************************** -->
				199	</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
				200	<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
				201	<a name="apis">Important and useful LLVM APIs
				202	</b></font></td></tr></table><ul>
				203	<!-- *********************************************************************** -->
				204
				205	Here we highlight some LLVM APIs that are generally useful and good to know
				206	about when writing transformations.<p>
				207
Chris Lattner	1d43fd4	2002-09-09 05:53:21 +0000	[diff] [blame]	208	<!-- ======================================================================= -->
				209	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				210	<tr><td> </td><td width="100%">
				211	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				212	<a name="isa">The isa<>, cast<> and dyn_cast<> templates</a>
				213	</b></font></td></tr></table><ul>
				214
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	215	The LLVM source-base makes extensive use of a custom form of RTTI. These
				216	templates have many similarities to the C++ <tt>dynamic_cast<></tt>
				217	operator, but they don't have some drawbacks (primarily stemming from the fact
				218	that <tt>dynamic_cast<></tt> only works on classes that have a v-table).
				219	Because they are used so often, you must know what they do and how they work.
				220	All of these templates are defined in the <a
				221	href="/doxygen/Casting_8h-source.html"><tt>Support/Casting.h</tt></a> file (note
				222	that you very rarely have to include this file directly).<p>
Chris Lattner	1d43fd4	2002-09-09 05:53:21 +0000	[diff] [blame]	223
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	224	<dl>
				225
				226	<dt><tt>isa<></tt>:
				227
				228	<dd>The <tt>isa<></tt> operator works exactly like the Java
				229	"<tt>instanceof</tt>" operator. It returns true or false depending on whether a
				230	reference or pointer points to an instance of the specified class. This can be
				231	very useful for constraint checking of various sorts (example below).<p>
				232
				233
				234	<dt><tt>cast<></tt>:
				235
				236	<dd>The <tt>cast<></tt> operator is a "checked cast" operation. It
				237	converts a pointer or reference from a base class to a derived cast, causing an
				238	assertion failure if it is not really an instance of the right type. This
				239	should be used in cases where you have some information that makes you believe
				240	that something is of the right type. An example of the <tt>isa<></tt> and
				241	<tt>cast<></tt> template is:<p>
				242
				243	<pre>
				244	static bool isLoopInvariant(const <a href="#Value">Value</a> V, const Loop L) {
				245	if (isa<<a href="#Constant">Constant</a>>(V) \|\| isa<<a href="#Argument">Argument</a>>(V) \|\| isa<<a href="#GlobalValue">GlobalValue</a>>(V))
				246	return true;
				247
				248	<i>// Otherwise, it must be an instruction...</i>
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	249	return !L->contains(cast<<a href="#Instruction">Instruction</a>>(V)->getParent());
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	250	</pre><p>
				251
				252	Note that you should <b>not</b> use an <tt>isa<></tt> test followed by a
				253	<tt>cast<></tt>, for that use the <tt>dyn_cast<></tt> operator.<p>
				254
				255
				256	<dt><tt>dyn_cast<></tt>:
				257
				258	<dd>The <tt>dyn_cast<></tt> operator is a "checking cast" operation. It
				259	checks to see if the operand is of the specified type, and if so, returns a
				260	pointer to it (this operator does not work with references). If the operand is
				261	not of the correct type, a null pointer is returned. Thus, this works very much
				262	like the <tt>dynamic_cast</tt> operator in C++, and should be used in the same
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	263	circumstances. Typically, the <tt>dyn_cast<></tt> operator is used in an
				264	<tt>if</tt> statement or some other flow control statement like this:<p>
				265
				266	<pre>
				267	if (<a href="#AllocationInst">AllocationInst</a> *AI = dyn_cast<<a href="#AllocationInst">AllocationInst</a>>(Val)) {
				268	...
				269	}
				270	</pre><p>
				271
				272	This form of the <tt>if</tt> statement effectively combines together a call to
				273	<tt>isa<></tt> and a call to <tt>cast<></tt> into one statement,
				274	which is very convenient.<p>
				275
				276	Another common example is:<p>
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	277
				278	<pre>
				279	<i>// Loop over all of the phi nodes in a basic block</i>
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	280	BasicBlock::iterator BBI = BB->begin();
Chris Lattner	6a54710	2003-04-23 16:26:15 +0000	[diff] [blame]	281	for (; <a href="#PhiNode">PHINode</a> *PN = dyn_cast<<a href="#PHINode">PHINode</a>>(BBI); ++BBI)
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	282	cerr << *PN;
				283	</pre><p>
				284
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	285	Note that the <tt>dyn_cast<></tt> operator, like C++'s
				286	<tt>dynamic_cast</tt> or Java's <tt>instanceof</tt> operator, can be abused. In
				287	particular you should not use big chained <tt>if/then/else</tt> blocks to check
				288	for lots of different variants of classes. If you find yourself wanting to do
				289	this, it is much cleaner and more efficient to use the InstVisitor class to
				290	dispatch over the instruction type directly.<p>
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	291
				292
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	293	<dt><tt>cast_or_null<></tt>:
				294
				295	<dd>The <tt>cast_or_null<></tt> operator works just like the
				296	<tt>cast<></tt> operator, except that it allows for a null pointer as an
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	297	argument (which it then propagates). This can sometimes be useful, allowing you
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	298	to combine several null checks into one.<p>
				299
				300
				301	<dt><tt>dyn_cast_or_null<></tt>:
				302
				303	<dd>The <tt>dyn_cast_or_null<></tt> operator works just like the
				304	<tt>dyn_cast<></tt> operator, except that it allows for a null pointer as
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	305	an argument (which it then propagates). This can sometimes be useful, allowing
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	306	you to combine several null checks into one.<p>
				307
Chris Lattner	979d9b7	2002-09-10 00:39:05 +0000	[diff] [blame]	308	</dl>
Chris Lattner	1d43fd4	2002-09-09 05:53:21 +0000	[diff] [blame]	309
Chris Lattner	6b121f1	2002-09-10 15:20:46 +0000	[diff] [blame]	310	These five templates can be used with any classes, whether they have a v-table
				311	or not. To add support for these templates, you simply need to add
				312	<tt>classof</tt> static methods to the class you are interested casting to.
				313	Describing this is currently outside the scope of this document, but there are
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	314	lots of examples in the LLVM source base.<p>
Chris Lattner	1d43fd4	2002-09-09 05:53:21 +0000	[diff] [blame]	315
				316
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	317	<!-- ======================================================================= -->
				318	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				319	<tr><td> </td><td width="100%">
				320	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				321	<a name="DEBUG">The <tt>DEBUG()</tt> macro & <tt>-debug</tt> option</a>
				322	</b></font></td></tr></table><ul>
				323
				324	Often when working on your pass you will put a bunch of debugging printouts and
				325	other code into your pass. After you get it working, you want to remove
				326	it... but you may need it again in the future (to work out new bugs that you run
				327	across).<p>
				328
				329	Naturally, because of this, you don't want to delete the debug printouts, but
				330	you don't want them to always be noisy. A standard compromise is to comment
				331	them out, allowing you to enable them if you need them in the future.<p>
				332
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	333	The "<tt><a href="/doxygen/Debug_8h-source.html">Support/Debug.h</a></tt>" file
				334	provides a macro named <tt>DEBUG()</tt> that is a much nicer solution to this
				335	problem. Basically, you can put arbitrary code into the argument of the
				336	<tt>DEBUG</tt> macro, and it is only executed if '<tt>opt</tt>' (or any other
				337	tool) is run with the '<tt>-debug</tt>' command line argument:
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	338
				339	<pre>
				340	...
				341	DEBUG(std::cerr << "I am here!\n");
				342	...
				343	</pre><p>
				344
				345	Then you can run your pass like this:<p>
				346
				347	<pre>
				348	$ opt < a.bc > /dev/null -mypass
				349	<no output>
				350	$ opt < a.bc > /dev/null -mypass -debug
				351	I am here!
				352	$
				353	</pre><p>
				354
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	355	Using the <tt>DEBUG()</tt> macro instead of a home-brewed solution allows you to
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	356	now have to create "yet another" command line option for the debug output for
Chris Lattner	a4e7c4e	2002-11-08 06:50:02 +0000	[diff] [blame]	357	your pass. Note that <tt>DEBUG()</tt> macros are disabled for optimized builds,
				358	so they do not cause a performance impact at all (for the same reason, they
				359	should also not contain side-effects!).<p>
				360
				361	One additional nice thing about the <tt>DEBUG()</tt> macro is that you can
				362	enable or disable it directly in gdb. Just use "<tt>set DebugFlag=0</tt>" or
				363	"<tt>set DebugFlag=1</tt>" from the gdb if the program is running. If the
				364	program hasn't been started yet, you can always just run it with
				365	<tt>-debug</tt>.<p>
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	366
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	367	<!-- _______________________________________________________________________ -->
				368	</ul><h4><a name="DEBUG_TYPE"><hr size=0>Fine grained debug info with
				369	<tt>DEBUG_TYPE()</tt> and the <tt>-debug-only</tt> option</a> </h4><ul>
				370
				371	Sometimes you may find yourself in a situation where enabling <tt>-debug</tt>
				372	just turns on <b>too much</b> information (such as when working on the code
				373	generator). If you want to enable debug information with more fine-grained
				374	control, you define the <tt>DEBUG_TYPE</tt> macro and the <tt>-debug</tt> only
				375	option as follows:<p>
				376
				377	<pre>
				378	...
				379	DEBUG(std::cerr << "No debug type\n");
				380	#undef DEBUG_TYPE
				381	#define DEBUG_TYPE "foo"
				382	DEBUG(std::cerr << "'foo' debug type\n");
				383	#undef DEBUG_TYPE
				384	#define DEBUG_TYPE "bar"
				385	DEBUG(std::cerr << "'bar' debug type\n");
				386	#undef DEBUG_TYPE
				387	#define DEBUG_TYPE ""
				388	DEBUG(std::cerr << "No debug type (2)\n");
				389	...
				390	</pre><p>
				391
				392	Then you can run your pass like this:<p>
				393
				394	<pre>
				395	$ opt < a.bc > /dev/null -mypass
				396	<no output>
				397	$ opt < a.bc > /dev/null -mypass -debug
				398	No debug type
				399	'foo' debug type
				400	'bar' debug type
				401	No debug type (2)
				402	$ opt < a.bc > /dev/null -mypass -debug-only=foo
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	403	'foo' debug type
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	404	$ opt < a.bc > /dev/null -mypass -debug-only=bar
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	405	'bar' debug type
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	406	$
				407	</pre><p>
				408
				409	Of course, in practice, you should only set <tt>DEBUG_TYPE</tt> at the top of a
				410	file, to specify the debug type for the entire module (if you do this before you
				411	<tt>#include "Support/Debug.h"</tt>, you don't have to insert the ugly
				412	<tt>#undef</tt>'s). Also, you should use names more meaningful that "foo" and
				413	"bar", because there is no system in place to ensure that names do not conflict:
				414	if two different modules use the same string, they will all be turned on when
Chris Lattner	806e186	2003-08-01 22:26:27 +0000	[diff] [blame]	415	the name is specified. This allows all, say, instruction scheduling, debug
Chris Lattner	84b7f8d	2003-08-01 22:20:59 +0000	[diff] [blame]	416	information to be enabled with <tt>-debug-type=InstrSched</tt>, even if the
				417	source lives in multiple files.<p>
				418
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	419
				420	<!-- ======================================================================= -->
				421	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				422	<tr><td> </td><td width="100%">
				423	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				424	<a name="Statistic">The <tt>Statistic</tt> template & <tt>-stats</tt>
				425	option</a>
				426	</b></font></td></tr></table><ul>
				427
				428	The "<tt><a
Chris Lattner	8328f1d	2002-10-01 22:39:41 +0000	[diff] [blame]	429	href="/doxygen/Statistic_8h-source.html">Support/Statistic.h</a></tt>"
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	430	file provides a template named <tt>Statistic</tt> that is used as a unified way
				431	to keeping track of what the LLVM compiler is doing and how effective various
				432	optimizations are. It is useful to see what optimizations are contributing to
				433	making a particular program run faster.<p>
				434
				435	Often you may run your pass on some big program, and you're interested to see
				436	how many times it makes a certain transformation. Although you can do this with
				437	hand inspection, or some ad-hoc method, this is a real pain and not very useful
				438	for big programs. Using the <tt>Statistic</tt> template makes it very easy to
				439	keep track of this information, and the calculated information is presented in a
				440	uniform manner with the rest of the passes being executed.<p>
				441
				442	There are many examples of <tt>Statistic</tt> users, but this basics of using it
				443	are as follows:<p>
				444
				445	<ol>
				446	<li>Define your statistic like this:<p>
				447
				448	<pre>
Chris Lattner	8328f1d	2002-10-01 22:39:41 +0000	[diff] [blame]	449	static Statistic<> NumXForms("mypassname", "The # of times I did stuff");
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	450	</pre><p>
				451
				452	The <tt>Statistic</tt> template can emulate just about any data-type, but if you
				453	do not specify a template argument, it defaults to acting like an unsigned int
				454	counter (this is usually what you want).<p>
				455
				456	<li>Whenever you make a transformation, bump the counter:<p>
				457
				458	<pre>
				459	++NumXForms; // I did stuff
				460	</pre><p>
				461
				462	</ol><p>
				463
				464	That's all you have to do. To get '<tt>opt</tt>' to print out the statistics
				465	gathered, use the '<tt>-stats</tt>' option:<p>
				466
				467	<pre>
				468	$ opt -stats -mypassname < program.bc > /dev/null
				469	... statistic output ...
				470	</pre><p>
				471
				472	When running <tt>gccas</tt> on a C file from the SPEC benchmark suite, it gives
				473	a report that looks like this:<p>
				474
				475	<pre>
				476	7646 bytecodewriter - Number of normal instructions
				477	725 bytecodewriter - Number of oversized instructions
				478	129996 bytecodewriter - Number of bytecode bytes written
				479	2817 raise - Number of insts DCEd or constprop'd
				480	3213 raise - Number of cast-of-self removed
				481	5046 raise - Number of expression trees converted
				482	75 raise - Number of other getelementptr's formed
				483	138 raise - Number of load/store peepholes
				484	42 deadtypeelim - Number of unused typenames removed from symtab
				485	392 funcresolve - Number of varargs functions resolved
				486	27 globaldce - Number of global variables removed
				487	2 adce - Number of basic blocks removed
				488	134 cee - Number of branches revectored
				489	49 cee - Number of setcc instruction eliminated
				490	532 gcse - Number of loads removed
				491	2919 gcse - Number of instructions removed
Chris Lattner	065a616	2003-09-10 05:29:43 +0000	[diff] [blame]	492	86 indvars - Number of canonical indvars added
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	493	87 indvars - Number of aux indvars removed
				494	25 instcombine - Number of dead inst eliminate
				495	434 instcombine - Number of insts combined
				496	248 licm - Number of load insts hoisted
				497	1298 licm - Number of insts hoisted to a loop pre-header
				498	3 licm - Number of insts hoisted to multiple loop preds (bad, no loop pre-header)
				499	75 mem2reg - Number of alloca's promoted
				500	1444 cfgsimplify - Number of blocks simplified
				501	</pre><p>
				502
				503	Obviously, with so many optimizations, having a unified framework for this stuff
				504	is very nice. Making your pass fit well into the framework makes it more
				505	maintainable and useful.<p>
				506
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	507
Chris Lattner	b99344f	2002-09-06 16:40:10 +0000	[diff] [blame]	508	<!-- *********************************************************************** -->
				509	</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
				510	<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
				511	<a name="common">Helpful Hints for Common Operations
Chris Lattner	986e0c9	2002-09-22 19:38:40 +0000	[diff] [blame]	512	</b></font></td></tr></table><ul> <!--
				513	*********************************************************************** -->
Chris Lattner	b99344f	2002-09-06 16:40:10 +0000	[diff] [blame]	514
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	515	This section describes how to perform some very simple transformations of LLVM
				516	code. This is meant to give examples of common idioms used, showing the
				517	practical side of LLVM transformations.<p>
				518
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	519	Because this is a "how-to" section, you should also read about the main classes
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	520	that you will be working with. The <a href="#coreclasses">Core LLVM Class
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	521	Hierarchy Reference</a> contains details and descriptions of the main classes
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	522	that you should know about.<p>
				523
				524	<!-- NOTE: this section should be heavy on example code -->
				525
				526
				527	<!-- ======================================================================= -->
				528	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				529	<tr><td> </td><td width="100%">
				530	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				531	<a name="inspection">Basic Inspection and Traversal Routines</a>
				532	</b></font></td></tr></table><ul>
				533
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	534	The LLVM compiler infrastructure have many different data structures that may be
				535	traversed. Following the example of the C++ standard template library, the
				536	techniques used to traverse these various data structures are all basically the
				537	same. For a enumerable sequence of values, the <tt>XXXbegin()</tt> function (or
				538	method) returns an iterator to the start of the sequence, the <tt>XXXend()</tt>
				539	function returns an iterator pointing to one past the last valid element of the
				540	sequence, and there is some <tt>XXXiterator</tt> data type that is common
				541	between the two operations.<p>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	542
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	543	Because the pattern for iteration is common across many different aspects of the
				544	program representation, the standard template library algorithms may be used on
				545	them, and it is easier to remember how to iterate. First we show a few common
				546	examples of the data structures that need to be traversed. Other data
				547	structures are traversed in very similar ways.<p>
				548
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	549
				550	<!-- _______________________________________________________________________ -->
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	551	</ul><h4><a name="iterate_function"><hr size=0>Iterating over the <a
				552	href="#BasicBlock"><tt>BasicBlock</tt></a>s in a <a
				553	href="#Function"><tt>Function</tt></a> </h4><ul>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	554
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	555	It's quite common to have a <tt>Function</tt> instance that you'd like
				556	to transform in some way; in particular, you'd like to manipulate its
				557	<tt>BasicBlock</tt>s. To facilitate this, you'll need to iterate over
				558	all of the <tt>BasicBlock</tt>s that constitute the <tt>Function</tt>.
				559	The following is an example that prints the name of a
				560	<tt>BasicBlock</tt> and the number of <tt>Instruction</tt>s it
				561	contains:
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	562
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	563	<pre>
				564	// func is a pointer to a Function instance
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	565	for (Function::iterator i = func->begin(), e = func->end(); i != e; ++i) {
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	566
				567	// print out the name of the basic block if it has one, and then the
				568	// number of instructions that it contains
				569
Joel Stanley	72ef35e	2002-09-06 23:05:12 +0000	[diff] [blame]	570	cerr <&lt "Basic block (name=" <&lt i->getName() << ") has "
				571	<&lt i->size() <&lt " instructions.\n";
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	572	}
				573	</pre>
				574
				575	Note that i can be used as if it were a pointer for the purposes of
				576	invoking member functions of the <tt>Instruction</tt> class. This is
				577	because the indirection operator is overloaded for the iterator
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	578	classes. In the above code, the expression <tt>i->size()</tt> is
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	579	exactly equivalent to <tt>(*i).size()</tt> just like you'd expect.
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	580
				581	<!-- _______________________________________________________________________ -->
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	582	</ul><h4><a name="iterate_basicblock"><hr size=0>Iterating over the <a
				583	href="#Instruction"><tt>Instruction</tt></a>s in a <a
				584	href="#BasicBlock"><tt>BasicBlock</tt></a> </h4><ul>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	585
Joel Stanley	aaeb1c1	2002-09-06 23:42:40 +0000	[diff] [blame]	586	Just like when dealing with <tt>BasicBlock</tt>s in
				587	<tt>Function</tt>s, it's easy to iterate over the individual
				588	instructions that make up <tt>BasicBlock</tt>s. Here's a code snippet
				589	that prints out each instruction in a <tt>BasicBlock</tt>:
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	590
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	591	<pre>
				592	// blk is a pointer to a BasicBlock instance
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	593	for (BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i)
Chris Lattner	2b76306	2002-09-06 22:51:10 +0000	[diff] [blame]	594	// the next statement works since operator<<(ostream&,...)
				595	// is overloaded for Instruction&
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	596	cerr << *i << "\n";
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	597	</pre>
				598
				599	However, this isn't really the best way to print out the contents of a
				600	<tt>BasicBlock</tt>! Since the ostream operators are overloaded for
				601	virtually anything you'll care about, you could have just invoked the
Chris Lattner	2b76306	2002-09-06 22:51:10 +0000	[diff] [blame]	602	print routine on the basic block itself: <tt>cerr << *blk <<
				603	"\n";</tt>.<p>
				604
				605	Note that currently operator<< is implemented for <tt>Value*</tt>, so it
				606	will print out the contents of the pointer, instead of
				607	the pointer value you might expect. This is a deprecated interface that will
				608	be removed in the future, so it's best not to depend on it. To print out the
				609	pointer value for now, you must cast to <tt>void*</tt>.<p>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	610
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	611
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	612	<!-- _______________________________________________________________________ -->
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	613	</ul><h4><a name="iterate_institer"><hr size=0>Iterating over the <a
				614	href="#Instruction"><tt>Instruction</tt></a>s in a <a
				615	href="#Function"><tt>Function</tt></a></h4><ul>
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	616
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	617	If you're finding that you commonly iterate over a <tt>Function</tt>'s
				618	<tt>BasicBlock</tt>s and then that <tt>BasicBlock</tt>'s
				619	<tt>Instruction</tt>s, <tt>InstIterator</tt> should be used instead.
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	620	You'll need to include <a href="/doxygen/InstIterator_8h-source.html"><tt>llvm/Support/InstIterator.h</tt></a>, and then
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	621	instantiate <tt>InstIterator</tt>s explicitly in your code. Here's a
				622	small example that shows how to dump all instructions in a function to
				623	stderr (<b>Note:</b> Dereferencing an <tt>InstIterator</tt> yields an
				624	<tt>Instruction*</tt>, <i>not</i> an <tt>Instruction&amp</tt>!):
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	625
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	626	<pre>
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	627	#include "<a href="/doxygen/InstIterator_8h-source.html">llvm/Support/InstIterator.h</a>"
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	628	...
				629	// Suppose F is a ptr to a function
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	630	for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i)
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	631	cerr <&lt **i <&lt "\n";
				632	</pre>
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	633
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	634	Easy, isn't it? You can also use <tt>InstIterator</tt>s to fill a
				635	worklist with its initial contents. For example, if you wanted to
				636	initialize a worklist to contain all instructions in a
				637	<tt>Function</tt> F, all you would need to do is something like:
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	638
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	639	<pre>
				640	std::set<Instruction*&gt worklist;
				641	worklist.insert(inst_begin(F), inst_end(F));
				642	</pre>
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	643
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	644	The STL set <tt>worklist</tt> would now contain all instructions in
				645	the <tt>Function</tt> pointed to by F.
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	646
				647	<!-- _______________________________________________________________________ -->
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	648	</ul><h4><a name="iterate_convert"><hr size=0>Turning an iterator into a class
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	649	pointer (and vice-versa) </h4><ul>
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	650
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	651	Sometimes, it'll be useful to grab a reference (or pointer) to a class
				652	instance when all you've got at hand is an iterator. Well, extracting
				653	a reference or a pointer from an iterator is very straightforward.
				654	Assuming that <tt>i</tt> is a <tt>BasicBlock::iterator</tt> and
				655	<tt>j</tt> is a <tt>BasicBlock::const_iterator</tt>:
				656
				657	<pre>
Chris Lattner	83b5ee0	2002-09-06 22:12:58 +0000	[diff] [blame]	658	Instruction& inst = *i; // grab reference to instruction reference
				659	Instruction* pinst = &*i; // grab pointer to instruction reference
				660	const Instruction& inst = *j;
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	661	</pre>
				662	However, the iterators you'll be working with in the LLVM framework
				663	are special: they will automatically convert to a ptr-to-instance type
				664	whenever they need to. Instead of dereferencing the iterator and then
				665	taking the address of the result, you can simply assign the iterator
				666	to the proper pointer type and you get the dereference and address-of
				667	operation as a result of the assignment (behind the scenes, this is a
				668	result of overloading casting mechanisms). Thus the last line of the
				669	last example,
				670
Chris Lattner	83b5ee0	2002-09-06 22:12:58 +0000	[diff] [blame]	671	<pre>Instruction* pinst = &*i;</pre>
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	672
				673	is semantically equivalent to
				674
				675	<pre>Instruction* pinst = i;</pre>
				676
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	677	It's also possible to turn a class pointer into the corresponding
				678	iterator. Usually, this conversion is quite inexpensive. The
				679	following code snippet illustrates use of the conversion constructors
				680	provided by LLVM iterators. By using these, you can explicitly grab
				681	the iterator of something without actually obtaining it via iteration
				682	over some structure:
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	683
				684	<pre>
				685	void printNextInstruction(Instruction* inst) {
				686	BasicBlock::iterator it(inst);
				687	++it; // after this line, it refers to the instruction after *inst.
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	688	if (it != inst->getParent()->end()) cerr << *it << "\n";
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	689	}
				690	</pre>
Joel Stanley	aaeb1c1	2002-09-06 23:42:40 +0000	[diff] [blame]	691	Of course, this example is strictly pedagogical, because it'd be much
				692	better to explicitly grab the next instruction directly from inst.
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	693
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	694
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	695	<!--_______________________________________________________________________-->
				696	</ul><h4><a name="iterate_complex"><hr size=0>Finding call sites: a slightly
				697	more complex example </h4><ul>
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	698
				699	Say that you're writing a FunctionPass and would like to count all the
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	700	locations in the entire module (that is, across every
Misha Brukman	79223ed	2003-07-28 19:21:20 +0000	[diff] [blame]	701	<tt>Function</tt>) where a certain function (i.e., some
				702	<tt>Function</tt>*) is already in scope. As you'll learn later, you may
Joel Stanley	d8aabb2	2002-09-09 16:29:58 +0000	[diff] [blame]	703	want to use an <tt>InstVisitor</tt> to accomplish this in a much more
				704	straightforward manner, but this example will allow us to explore how
				705	you'd do it if you didn't have <tt>InstVisitor</tt> around. In
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	706	pseudocode, this is what we want to do:
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	707
				708	<pre>
				709	initialize callCounter to zero
				710	for each Function f in the Module
				711	for each BasicBlock b in f
				712	for each Instruction i in b
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	713	if (i is a CallInst and calls the given function)
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	714	increment callCounter
				715	</pre>
				716
				717	And the actual code is (remember, since we're writing a
Joel Stanley	d8aabb2	2002-09-09 16:29:58 +0000	[diff] [blame]	718	<tt>FunctionPass</tt>, our <tt>FunctionPass</tt>-derived class simply
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	719	has to override the <tt>runOnFunction</tt> method...):
				720
				721	<pre>
Joel Stanley	d8aabb2	2002-09-09 16:29:58 +0000	[diff] [blame]	722	Function* targetFunc = ...;
				723
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	724	class OurFunctionPass : public FunctionPass {
				725	public:
Joel Stanley	d8aabb2	2002-09-09 16:29:58 +0000	[diff] [blame]	726	OurFunctionPass(): callCounter(0) { }
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	727
Chris Lattner	caa5d13	2002-09-09 19:58:18 +0000	[diff] [blame]	728	virtual runOnFunction(Function& F) {
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	729	for (Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
				730	for (BasicBlock::iterator i = b->begin(); ie = b->end(); i != ie; ++i) {
Chris Lattner	a9030cb	2002-09-16 22:08:07 +0000	[diff] [blame]	731	if (<a href="#CallInst">CallInst</a>* callInst = <a href="#isa">dyn_cast</a><<a href="#CallInst">CallInst</a>>(&*i)) {
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	732	// we know we've encountered a call instruction, so we
				733	// need to determine if it's a call to the
				734	// function pointed to by m_func or not.
				735
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	736	if (callInst->getCalledFunction() == targetFunc)
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	737	++callCounter;
				738	}
				739	}
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	740	}
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	741
				742	private:
Joel Stanley	d8aabb2	2002-09-09 16:29:58 +0000	[diff] [blame]	743	unsigned callCounter;
Joel Stanley	e7be650	2002-09-09 15:50:33 +0000	[diff] [blame]	744	};
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	745	</pre>
				746
Brian Gaeke	f1972c6	2003-11-07 19:25:45 +0000	[diff] [blame^]	747
				748	<!--_______________________________________________________________________-->
				749	</ul><h4><a name="calls_and_invokes"><hr size=0>Treating calls and
				750	invokes the same way</h4><ul>
				751
				752	<p>You may have noticed that the previous example was a bit
				753	oversimplified in that it did not deal with call sites generated by
				754	'invoke' instructions. In this, and in other situations, you may find
				755	that you want to treat <tt>CallInst</tt>s and <tt>InvokeInst</tt>s the
				756	same way, even though their most-specific common base class is
				757	<tt>Instruction</tt>, which includes lots of less closely-related
				758	things. For these cases, LLVM provides a handy wrapper class called <a
				759	href="http://llvm.cs.uiuc.edu/doxygen/classCallSite.html"><tt>CallSite
				760	</tt></a>. It is essentially a wrapper around an <tt>Instruction</tt>
				761	pointer, with some methods that provide functionality common to
				762	<tt>CallInst</tt>s and <tt>InvokeInst</tt>s.</p>
				763
				764	<p>This class is supposed to have "value semantics". So it should be
				765	passed by value, not by reference; it should not be dynamically
				766	allocated or deallocated using <tt>operator new</tt> or <tt>operator
				767	delete</tt>. It is efficiently copyable, assignable and constructable,
				768	with costs equivalents to that of a bare pointer. (You will notice, if
				769	you look at its definition, that it has only a single data member.)</p>
				770
				771
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	772	<!--_______________________________________________________________________-->
				773	</ul><h4><a name="iterate_chains"><hr size=0>Iterating over def-use &
				774	use-def chains</h4><ul>
				775
Joel Stanley	01040b2	2002-09-11 20:50:04 +0000	[diff] [blame]	776	Frequently, we might have an instance of the <a
				777	href="/doxygen/classValue.html">Value Class</a> and we want to
				778	determine which <tt>User</tt>s use the <tt>Value</tt>. The list of
				779	all <tt>User</tt>s of a particular <tt>Value</tt> is called a
				780	<i>def-use</i> chain. For example, let's say we have a
				781	<tt>Function*</tt> named <tt>F</tt> to a particular function
				782	<tt>foo</tt>. Finding all of the instructions that <i>use</i>
				783	<tt>foo</tt> is as simple as iterating over the <i>def-use</i> chain of
				784	<tt>F</tt>:
				785
				786	<pre>
				787	Function* F = ...;
				788
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	789	for (Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) {
				790	if (Instruction Inst = dyn_cast<Instruction>(i)) {
Chris Lattner	24b7092	2002-09-17 22:43:00 +0000	[diff] [blame]	791	cerr << "F is used in instruction:\n";
				792	cerr << *Inst << "\n";
Joel Stanley	01040b2	2002-09-11 20:50:04 +0000	[diff] [blame]	793	}
				794	}
				795	</pre>
				796
				797	Alternately, it's common to have an instance of the <a
				798	href="/doxygen/classUser.html">User Class</a> and need to know what
				799	<tt>Value</tt>s are used by it. The list of all <tt>Value</tt>s used
				800	by a <tt>User</tt> is known as a <i>use-def</i> chain. Instances of
				801	class <tt>Instruction</tt> are common <tt>User</tt>s, so we might want
				802	to iterate over all of the values that a particular instruction uses
				803	(that is, the operands of the particular <tt>Instruction</tt>):
				804
				805	<pre>
				806	Instruction* pi = ...;
				807
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	808	for (User::op_iterator i = pi->op_begin(), e = pi->op_end(); i != e; ++i) {
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	809	Value* v = *i;
Joel Stanley	01040b2	2002-09-11 20:50:04 +0000	[diff] [blame]	810	...
				811	}
				812	</pre>
				813
				814
Chris Lattner	1a3105b	2002-09-09 05:49:39 +0000	[diff] [blame]	815	<!--
				816	def-use chains ("finding all users of"): Value::use_begin/use_end
				817	use-def chains ("finding all values used"): User::op_begin/op_end [op=operand]
				818	-->
				819
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	820	<!-- ======================================================================= -->
				821	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				822	<tr><td> </td><td width="100%">
				823	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				824	<a name="simplechanges">Making simple changes</a>
				825	</b></font></td></tr></table><ul>
				826
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	827	There are some primitive transformation operations present in the LLVM
				828	infrastructure that are worth knowing about. When performing
				829	transformations, it's fairly common to manipulate the contents of
				830	basic blocks. This section describes some of the common methods for
				831	doing so and gives example code.
				832
				833	<!--_______________________________________________________________________-->
				834	</ul><h4><a name="schanges_creating"><hr size=0>Creating and inserting
				835	new <tt>Instruction</tt>s</h4><ul>
				836
				837	<i>Instantiating Instructions</i>
				838
				839	<p>Creation of <tt>Instruction</tt>s is straightforward: simply call the
				840	constructor for the kind of instruction to instantiate and provide the
				841	necessary parameters. For example, an <tt>AllocaInst</tt> only
				842	<i>requires</i> a (const-ptr-to) <tt>Type</tt>. Thus:
				843
				844	<pre>AllocaInst* ai = new AllocaInst(Type::IntTy);</pre>
				845
				846	will create an <tt>AllocaInst</tt> instance that represents the
				847	allocation of one integer in the current stack frame, at runtime.
				848	Each <tt>Instruction</tt> subclass is likely to have varying default
				849	parameters which change the semantics of the instruction, so refer to
Chris Lattner	4e1f96b	2002-09-12 19:06:51 +0000	[diff] [blame]	850	the <a href="/doxygen/classInstruction.html">doxygen documentation for
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	851	the subclass of Instruction</a> that you're interested in
				852	instantiating.</p>
				853
				854	<p><i>Naming values</i></p>
				855
				856	<p>
				857	It is very useful to name the values of instructions when you're able
				858	to, as this facilitates the debugging of your transformations. If you
				859	end up looking at generated LLVM machine code, you definitely want to
				860	have logical names associated with the results of instructions! By
				861	supplying a value for the <tt>Name</tt> (default) parameter of the
				862	<tt>Instruction</tt> constructor, you associate a logical name with
				863	the result of the instruction's execution at runtime. For example,
				864	say that I'm writing a transformation that dynamically allocates space
				865	for an integer on the stack, and that integer is going to be used as
				866	some kind of index by some other code. To accomplish this, I place an
				867	<tt>AllocaInst</tt> at the first point in the first
				868	<tt>BasicBlock</tt> of some <tt>Function</tt>, and I'm intending to
				869	use it within the same <tt>Function</tt>. I might do:
				870
				871	<pre>AllocaInst* pa = new AllocaInst(Type::IntTy, 0, "indexLoc");</pre>
				872
				873	where <tt>indexLoc</tt> is now the logical name of the instruction's
				874	execution value, which is a pointer to an integer on the runtime
				875	stack.
				876	</p>
				877
				878	<p><i>Inserting instructions</i></p>
				879
				880	<p>
				881	There are essentially two ways to insert an <tt>Instruction</tt> into
				882	an existing sequence of instructions that form a <tt>BasicBlock</tt>:
				883	<ul>
				884	<li>Insertion into an explicit instruction list
				885
				886	<p>Given a <tt>BasicBlock* pb</tt>, an <tt>Instruction* pi</tt> within
				887	that <tt>BasicBlock</tt>, and a newly-created instruction
				888	we wish to insert before <tt>*pi</tt>, we do the following:
				889
				890	<pre>
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	891	BasicBlock *pb = ...;
				892	Instruction *pi = ...;
				893	Instruction *newInst = new Instruction(...);
				894	pb->getInstList().insert(pi, newInst); // inserts newInst before pi in pb
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	895	</pre>
				896	</p>
				897
				898	<li>Insertion into an implicit instruction list
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	899	<p><tt>Instruction</tt> instances that are already in
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	900	<tt>BasicBlock</tt>s are implicitly associated with an existing
				901	instruction list: the instruction list of the enclosing basic block.
				902	Thus, we could have accomplished the same thing as the above code
				903	without being given a <tt>BasicBlock</tt> by doing:
				904	<pre>
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	905	Instruction *pi = ...;
				906	Instruction *newInst = new Instruction(...);
				907	pi->getParent()->getInstList().insert(pi, newInst);
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	908	</pre>
				909	In fact, this sequence of steps occurs so frequently that the
				910	<tt>Instruction</tt> class and <tt>Instruction</tt>-derived classes
				911	provide constructors which take (as a default parameter) a pointer to
				912	an <tt>Instruction</tt> which the newly-created <tt>Instruction</tt>
				913	should precede. That is, <tt>Instruction</tt> constructors are
				914	capable of inserting the newly-created instance into the
				915	<tt>BasicBlock</tt> of a provided instruction, immediately before that
				916	instruction. Using an <tt>Instruction</tt> constructor with a
				917	<tt>insertBefore</tt> (default) parameter, the above code becomes:
				918	<pre>
				919	Instruction* pi = ...;
				920	Instruction* newInst = new Instruction(..., pi);
				921	</pre>
				922	which is much cleaner, especially if you're creating a lot of
				923	instructions and adding them to <tt>BasicBlock</tt>s.
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	924	</p>
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	925	</p>
Chris Lattner	9ebf516	2002-09-12 19:08:16 +0000	[diff] [blame]	926	</ul>
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	927
				928	<!--_______________________________________________________________________-->
				929	</ul><h4><a name="schanges_deleting"><hr size=0>Deleting
Chris Lattner	4e1f96b	2002-09-12 19:06:51 +0000	[diff] [blame]	930	<tt>Instruction</tt>s</h4><ul>
				931
				932	Deleting an instruction from an existing sequence of instructions that form a <a
				933	href="#BasicBlock"><tt>BasicBlock</tt></a> is very straightforward. First, you
				934	must have a pointer to the instruction that you wish to delete. Second, you
				935	need to obtain the pointer to that instruction's basic block. You use the
				936	pointer to the basic block to get its list of instructions and then use the
				937	erase function to remove your instruction.<p>
				938
				939	For example:<p>
				940
				941	<pre>
				942	<a href="#Instruction">Instruction</a> *I = .. ;
Chris Lattner	7dbf683	2002-09-18 05:14:25 +0000	[diff] [blame]	943	<a href="#BasicBlock">BasicBlock</a> *BB = I->getParent();
				944	BB->getInstList().erase(I);
Chris Lattner	4e1f96b	2002-09-12 19:06:51 +0000	[diff] [blame]	945	</pre><p>
				946
Joel Stanley	753eb71	2002-09-11 22:32:24 +0000	[diff] [blame]	947	<!--_______________________________________________________________________-->
				948	</ul><h4><a name="schanges_replacing"><hr size=0>Replacing an
				949	<tt>Instruction</tt> with another <tt>Value</tt></h4><ul>
				950
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	951	<p><i>Replacing individual instructions</i></p>
				952	<p>
				953	Including "<a
Misha Brukman	79223ed	2003-07-28 19:21:20 +0000	[diff] [blame]	954	href="/doxygen/BasicBlockUtils_8h-source.html">llvm/Transforms/Utils/BasicBlockUtils.h</a>" permits use of two very useful replace functions:
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	955	<tt>ReplaceInstWithValue</tt> and <tt>ReplaceInstWithInst</tt>.
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	956
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	957	<ul>
				958
Chris Lattner	7dbf683	2002-09-18 05:14:25 +0000	[diff] [blame]	959	<li><tt>ReplaceInstWithValue</tt>
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	960
				961	<p>This function replaces all uses (within a basic block) of a given
				962	instruction with a value, and then removes the original instruction.
				963	The following example illustrates the replacement of the result of a
				964	particular <tt>AllocaInst</tt> that allocates memory for a single
				965	integer with an null pointer to an integer.</p>
				966
				967	<pre>
				968	AllocaInst* instToReplace = ...;
Joel Stanley	4b28793	2002-09-29 17:31:54 +0000	[diff] [blame]	969	BasicBlock::iterator ii(instToReplace);
				970	ReplaceInstWithValue(instToReplace->getParent()->getInstList(), ii,
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	971	Constant::getNullValue(PointerType::get(Type::IntTy)));
				972	</pre>
				973
Chris Lattner	7dbf683	2002-09-18 05:14:25 +0000	[diff] [blame]	974	<li><tt>ReplaceInstWithInst</tt>
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	975
				976	<p>This function replaces a particular instruction with another
				977	instruction. The following example illustrates the replacement of one
				978	<tt>AllocaInst</tt> with another.<p>
				979
				980	<pre>
				981	AllocaInst* instToReplace = ...;
Joel Stanley	4b28793	2002-09-29 17:31:54 +0000	[diff] [blame]	982	BasicBlock::iterator ii(instToReplace);
				983	ReplaceInstWithInst(instToReplace->getParent()->getInstList(), ii,
Misha Brukman	e7a7ab4	2003-05-07 21:47:39 +0000	[diff] [blame]	984	new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt"));
Joel Stanley	9dd1ad6	2002-09-18 03:17:23 +0000	[diff] [blame]	985	</pre>
				986
				987	</ul>
				988	<p><i>Replacing multiple uses of <tt>User</tt>s and
				989	<tt>Value</tt>s</i></p>
				990
				991	You can use <tt>Value::replaceAllUsesWith</tt> and
				992	<tt>User::replaceUsesOfWith</tt> to change more than one use at a
				993	time. See the doxygen documentation for the <a
				994	href="/doxygen/classValue.html">Value Class</a> and <a
				995	href="/doxygen/classUser.html">User Class</a>, respectively, for more
				996	information.
				997
				998	<!-- Value::replaceAllUsesWith User::replaceUsesOfWith Point out:
				999	include/llvm/Transforms/Utils/ especially BasicBlockUtils.h with:
				1000	ReplaceInstWithValue, ReplaceInstWithInst
Chris Lattner	ae7f759	2002-09-06 18:31:18 +0000	[diff] [blame]	1001	-->
Chris Lattner	b99344f	2002-09-06 16:40:10 +0000	[diff] [blame]	1002
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1003	<!-- *********************************************************************** -->
				1004	</ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
				1005	<tr><td align=center><font color="#EEEEFF" size=+2 face="Georgia,Palatino"><b>
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	1006	<a name="coreclasses">The Core LLVM Class Hierarchy Reference
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1007	</b></font></td></tr></table><ul>
				1008	<!-- *********************************************************************** -->
				1009
				1010	The Core LLVM classes are the primary means of representing the program being
				1011	inspected or transformed. The core LLVM classes are defined in header files in
				1012	the <tt>include/llvm/</tt> directory, and implemented in the <tt>lib/VMCore</tt>
				1013	directory.<p>
				1014
				1015
				1016	<!-- ======================================================================= -->
				1017	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1018	<tr><td> </td><td width="100%">
				1019	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1020	<a name="Value">The <tt>Value</tt> class</a>
				1021	</b></font></td></tr></table><ul>
				1022
				1023	<tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt></b><br>
				1024	doxygen info: <a href="/doxygen/classValue.html">Value Class</a><p>
				1025
				1026
				1027	The <tt>Value</tt> class is the most important class in LLVM Source base. It
				1028	represents a typed value that may be used (among other things) as an operand to
				1029	an instruction. There are many different types of <tt>Value</tt>s, such as <a
				1030	href="#Constant"><tt>Constant</tt></a>s, <a
				1031	href="#Argument"><tt>Argument</tt></a>s, and even <a
				1032	href="#Instruction"><tt>Instruction</tt></a>s and <a
				1033	href="#Function"><tt>Function</tt></a>s are <tt>Value</tt>s.<p>
				1034
				1035	A particular <tt>Value</tt> may be used many times in the LLVM representation
				1036	for a program. For example, an incoming argument to a function (represented
				1037	with an instance of the <a href="#Argument">Argument</a> class) is "used" by
				1038	every instruction in the function that references the argument. To keep track
				1039	of this relationship, the <tt>Value</tt> class keeps a list of all of the <a
				1040	href="#User"><tt>User</tt></a>s that is using it (the <a
				1041	href="#User"><tt>User</tt></a> class is a base class for all nodes in the LLVM
				1042	graph that can refer to <tt>Value</tt>s). This use list is how LLVM represents
Joel Stanley	9b96c44	2002-09-06 21:55:13 +0000	[diff] [blame]	1043	def-use information in the program, and is accessible through the <tt>use_</tt>*
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1044	methods, shown below.<p>
				1045
				1046	Because LLVM is a typed representation, every LLVM <tt>Value</tt> is typed, and
				1047	this <a href="#Type">Type</a> is available through the <tt>getType()</tt>
				1048	method. <a name="#nameWarning">In addition, all LLVM values can be named. The
				1049	"name" of the <tt>Value</tt> is symbolic string printed in the LLVM code:<p>
				1050
				1051	<pre>
				1052	%<b>foo</b> = add int 1, 2
				1053	</pre>
				1054
				1055	The name of this instruction is "foo". <b>NOTE</b> that the name of any value
				1056	may be missing (an empty string), so names should <b>ONLY</b> be used for
				1057	debugging (making the source code easier to read, debugging printouts), they
				1058	should not be used to keep track of values or map between them. For this
				1059	purpose, use a <tt>std::map</tt> of pointers to the <tt>Value</tt> itself
				1060	instead.<p>
				1061
				1062	One important aspect of LLVM is that there is no distinction between an SSA
				1063	variable and the operation that produces it. Because of this, any reference to
				1064	the value produced by an instruction (or the value available as an incoming
				1065	argument, for example) is represented as a direct pointer to the class that
				1066	represents this value. Although this may take some getting used to, it
				1067	simplifies the representation and makes it easier to manipulate.<p>
				1068
				1069
				1070	<!-- _______________________________________________________________________ -->
				1071	</ul><h4><a name="m_Value"><hr size=0>Important Public Members of
				1072	the <tt>Value</tt> class</h4><ul>
				1073
				1074	<li><tt>Value::use_iterator</tt> - Typedef for iterator over the use-list<br>
				1075	<tt>Value::use_const_iterator</tt>
				1076	- Typedef for const_iterator over the use-list<br>
				1077	<tt>unsigned use_size()</tt> - Returns the number of users of the value.<br>
				1078	<tt>bool use_empty()</tt> - Returns true if there are no users.<br>
				1079	<tt>use_iterator use_begin()</tt>
				1080	- Get an iterator to the start of the use-list.<br>
				1081	<tt>use_iterator use_end()</tt>
				1082	- Get an iterator to the end of the use-list.<br>
				1083	<tt><a href="#User">User</a> *use_back()</tt>
				1084	- Returns the last element in the list.<p>
				1085
				1086	These 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>
				1087
				1088	<li><tt><a href="#Type">Type</a> *getType() const</tt><p>
				1089	This method returns the Type of the Value.
				1090
				1091	<li><tt>bool hasName() const</tt><br>
				1092	<tt>std::string getName() const</tt><br>
				1093	<tt>void setName(const std::string &Name)</tt><p>
				1094
				1095	This family of methods is used to access and assign a name to a <tt>Value</tt>,
				1096	be aware of the <a href="#nameWarning">precaution above</a>.<p>
				1097
				1098
				1099	<li><tt>void replaceAllUsesWith(Value *V)</tt><p>
				1100
				1101	This method traverses the use list of a <tt>Value</tt> changing all <a
Misha Brukman	c4f5bb0	2002-09-18 02:21:57 +0000	[diff] [blame]	1102	href="#User"><tt>User</tt>s</a> of the current value to refer to "<tt>V</tt>"
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1103	instead. For example, if you detect that an instruction always produces a
				1104	constant value (for example through constant folding), you can replace all uses
				1105	of the instruction with the constant like this:<p>
				1106
				1107	<pre>
				1108	Inst->replaceAllUsesWith(ConstVal);
				1109	</pre><p>
				1110
				1111
				1112
				1113	<!-- ======================================================================= -->
				1114	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1115	<tr><td> </td><td width="100%">
				1116	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1117	<a name="User">The <tt>User</tt> class</a>
				1118	</b></font></td></tr></table><ul>
				1119
				1120	<tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt></b><br>
				1121	doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
				1122	Superclass: <a href="#Value"><tt>Value</tt></a><p>
				1123
				1124
				1125	The <tt>User</tt> class is the common base class of all LLVM nodes that may
				1126	refer to <a href="#Value"><tt>Value</tt></a>s. It exposes a list of "Operands"
				1127	that are all of the <a href="#Value"><tt>Value</tt></a>s that the User is
				1128	referring to. The <tt>User</tt> class itself is a subclass of
				1129	<tt>Value</tt>.<p>
				1130
				1131	The operands of a <tt>User</tt> point directly to the LLVM <a
				1132	href="#Value"><tt>Value</tt></a> that it refers to. Because LLVM uses Static
				1133	Single Assignment (SSA) form, there can only be one definition referred to,
				1134	allowing this direct connection. This connection provides the use-def
				1135	information in LLVM.<p>
				1136
				1137	<!-- _______________________________________________________________________ -->
				1138	</ul><h4><a name="m_User"><hr size=0>Important Public Members of
				1139	the <tt>User</tt> class</h4><ul>
				1140
				1141	The <tt>User</tt> class exposes the operand list in two ways: through an index
				1142	access interface and through an iterator based interface.<p>
				1143
				1144	<li><tt>Value *getOperand(unsigned i)</tt><br>
				1145	<tt>unsigned getNumOperands()</tt><p>
				1146
				1147	These two methods expose the operands of the <tt>User</tt> in a convenient form
				1148	for direct access.<p>
				1149
				1150	<li><tt>User::op_iterator</tt> - Typedef for iterator over the operand list<br>
				1151	<tt>User::op_const_iterator</tt>
				1152	<tt>use_iterator op_begin()</tt>
				1153	- Get an iterator to the start of the operand list.<br>
				1154	<tt>use_iterator op_end()</tt>
				1155	- Get an iterator to the end of the operand list.<p>
				1156
				1157	Together, these methods make up the iterator based interface to the operands of
				1158	a <tt>User</tt>.<p>
				1159
				1160
				1161
				1162	<!-- ======================================================================= -->
				1163	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1164	<tr><td> </td><td width="100%">
				1165	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1166	<a name="Instruction">The <tt>Instruction</tt> class</a>
				1167	</b></font></td></tr></table><ul>
				1168
				1169	<tt>#include "<a
				1170	href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt></b><br>
				1171	doxygen info: <a href="/doxygen/classInstruction.html">Instruction Class</a><br>
				1172	Superclasses: <a href="#User"><tt>User</tt></a>, <a
				1173	href="#Value"><tt>Value</tt></a><p>
				1174
				1175	The <tt>Instruction</tt> class is the common base class for all LLVM
				1176	instructions. It provides only a few methods, but is a very commonly used
				1177	class. The primary data tracked by the <tt>Instruction</tt> class itself is the
				1178	opcode (instruction type) and the parent <a
				1179	href="#BasicBlock"><tt>BasicBlock</tt></a> the <tt>Instruction</tt> is embedded
				1180	into. To represent a specific type of instruction, one of many subclasses of
				1181	<tt>Instruction</tt> are used.<p>
				1182
				1183	Because the <tt>Instruction</tt> class subclasses the <a
				1184	href="#User"><tt>User</tt></a> class, its operands can be accessed in the same
				1185	way as for other <a href="#User"><tt>User</tt></a>s (with the
				1186	<tt>getOperand()</tt>/<tt>getNumOperands()</tt> and
				1187	<tt>op_begin()</tt>/<tt>op_end()</tt> methods).<p>
				1188
Chris Lattner	1763525	2002-09-12 17:18:46 +0000	[diff] [blame]	1189	An important file for the <tt>Instruction</tt> class is the
				1190	<tt>llvm/Instruction.def</tt> file. This file contains some meta-data about the
				1191	various different types of instructions in LLVM. It describes the enum values
				1192	that are used as opcodes (for example <tt>Instruction::Add</tt> and
				1193	<tt>Instruction::SetLE</tt>), as well as the concrete sub-classes of
				1194	<tt>Instruction</tt> that implement the instruction (for example <tt><a
				1195	href="#BinaryOperator">BinaryOperator</a></tt> and <tt><a
				1196	href="#SetCondInst">SetCondInst</a></tt>). Unfortunately, the use of macros in
				1197	this file confused doxygen, so these enum values don't show up correctly in the
				1198	<a href="/doxygen/classInstruction.html">doxygen output</a>.<p>
				1199
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1200
				1201	<!-- _______________________________________________________________________ -->
				1202	</ul><h4><a name="m_Instruction"><hr size=0>Important Public Members of
				1203	the <tt>Instruction</tt> class</h4><ul>
				1204
				1205	<li><tt><a href="#BasicBlock">BasicBlock</a> *getParent()</tt><p>
				1206
				1207	Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
				1208	<tt>Instruction</tt> is embedded into.<p>
				1209
Chris Lattner	c3dc212	2003-02-26 16:38:15 +0000	[diff] [blame]	1210	<li><tt>bool mayWriteToMemory()</tt><p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1211
Chris Lattner	c3dc212	2003-02-26 16:38:15 +0000	[diff] [blame]	1212	Returns true if the instruction writes to memory, i.e. it is a <tt>call</tt>,
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1213	<tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
				1214
				1215	<li><tt>unsigned getOpcode()</tt><p>
				1216
				1217	Returns the opcode for the <tt>Instruction</tt>.<p>
				1218
Chris Lattner	1763525	2002-09-12 17:18:46 +0000	[diff] [blame]	1219	<li><tt><a href="#Instruction">Instruction</a> *clone() const</tt><p>
				1220
				1221	Returns another instance of the specified instruction, identical in all ways to
				1222	the original except that the instruction has no parent (ie it's not embedded
				1223	into a <a href="#BasicBlock"><tt>BasicBlock</tt></a>), and it has no name.<p>
				1224
				1225
				1226
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1227	<!--
				1228
				1229	\subsection{Subclasses of Instruction :}
				1230	\begin{itemize}
				1231	<li>BinaryOperator : This subclass of Instruction defines a general interface to the all the instructions involvong binary operators in LLVM.
				1232	\begin{itemize}
				1233	<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.
				1234	\end{itemize}
				1235	<li>TerminatorInst : This subclass of Instructions defines an interface for all instructions that can terminate a BasicBlock.
				1236	\begin{itemize}
				1237	<li> <tt>unsigned getNumSuccessors()</tt>: Returns the number of successors for this terminator instruction.
				1238	<li><tt>BasicBlock *getSuccessor(unsigned i)</tt>: As the name suggests returns the ith successor BasicBlock.
				1239	<li><tt>void setSuccessor(unsigned i, BasicBlock *B)</tt>: sets BasicBlock B as the ith succesor to this terminator instruction.
				1240	\end{itemize}
				1241
				1242	<li>PHINode : This represents the PHI instructions in the SSA form.
				1243	\begin{itemize}
				1244	<li><tt> unsigned getNumIncomingValues()</tt>: Returns the number of incoming edges to this PHI node.
				1245	<li><tt> Value *getIncomingValue(unsigned i)</tt>: Returns the ith incoming Value.
				1246	<li><tt>void setIncomingValue(unsigned i, Value *V)</tt>: Sets the ith incoming Value as V
				1247	<li><tt>BasicBlock *getIncomingBlock(unsigned i)</tt>: Returns the Basic Block corresponding to the ith incoming Value.
				1248	<li><tt> void addIncoming(Value D, BasicBlock BB)</tt>:
				1249	Add an incoming value to the end of the PHI list
				1250	<li><tt> int getBasicBlockIndex(const BasicBlock *BB) const</tt>:
				1251	Returns the first index of the specified basic block in the value list for this PHI. Returns -1 if no instance.
				1252	\end{itemize}
				1253	<li>CastInst : In LLVM all casts have to be done through explicit cast instructions. CastInst defines the interface to the cast instructions.
				1254	<li>CallInst : This defines an interface to the call instruction in LLVM. ARguments to the function are nothing but operands of the instruction.
				1255	\begin{itemize}
				1256	<li>: <tt>Function *getCalledFunction()</tt>: Returns a handle to the function that is being called by this Function.
				1257	\end{itemize}
				1258	<li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
				1259	\begin{itemize}
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1260	<li><tt>Value * getPointerOperand()</tt>: Returns the Pointer Operand which is typically the 0th operand.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1261	\end{itemize}
				1262	<li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
				1263	\begin{itemize}
				1264	<li><tt>bool isConditional()</tt>: Returns true if the branch is a conditional branch else returns false
				1265	<li> <tt>Value *getCondition()</tt>: Returns the condition if it is a conditional branch else returns null.
				1266	<li> <tt>void setUnconditionalDest(BasicBlock *Dest)</tt>: Changes the current branch to an unconditional one targetting the specified block.
				1267	\end{itemize}
				1268
				1269	\end{itemize}
				1270
				1271	-->
				1272
				1273
				1274	<!-- ======================================================================= -->
				1275	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1276	<tr><td> </td><td width="100%">
				1277	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1278	<a name="BasicBlock">The <tt>BasicBlock</tt> class</a>
				1279	</b></font></td></tr></table><ul>
				1280
				1281	<tt>#include "<a
				1282	href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt></b><br>
				1283	doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
				1284	Superclass: <a href="#Value"><tt>Value</tt></a><p>
				1285
				1286
				1287	This class represents a single entry multiple exit section of the code, commonly
				1288	known as a basic block by the compiler community. The <tt>BasicBlock</tt> class
				1289	maintains a list of <a href="#Instruction"><tt>Instruction</tt></a>s, which form
				1290	the body of the block. Matching the language definition, the last element of
				1291	this list of instructions is always a terminator instruction (a subclass of the
				1292	<a href="#TerminatorInst"><tt>TerminatorInst</tt></a> class).<p>
				1293
				1294	In addition to tracking the list of instructions that make up the block, the
				1295	<tt>BasicBlock</tt> class also keeps track of the <a
				1296	href="#Function"><tt>Function</tt></a> that it is embedded into.<p>
				1297
				1298	Note that <tt>BasicBlock</tt>s themselves are <a
				1299	href="#Value"><tt>Value</tt></a>s, because they are referenced by instructions
				1300	like branches and can go in the switch tables. <tt>BasicBlock</tt>s have type
				1301	<tt>label</tt>.<p>
				1302
				1303
				1304	<!-- _______________________________________________________________________ -->
				1305	</ul><h4><a name="m_BasicBlock"><hr size=0>Important Public Members of
				1306	the <tt>BasicBlock</tt> class</h4><ul>
				1307
				1308	<li><tt>BasicBlock(const std::string &Name = "", <a
				1309	href="#Function">Function</a> *Parent = 0)</tt><p>
				1310
				1311	The <tt>BasicBlock</tt> constructor is used to create new basic blocks for
				1312	insertion into a function. The constructor simply takes a name for the new
				1313	block, and optionally a <a href="#Function"><tt>Function</tt></a> to insert it
				1314	into. If the <tt>Parent</tt> parameter is specified, the new
				1315	<tt>BasicBlock</tt> is automatically inserted at the end of the specified <a
				1316	href="#Function"><tt>Function</tt></a>, if not specified, the BasicBlock must be
				1317	manually inserted into the <a href="#Function"><tt>Function</tt></a>.<p>
				1318
				1319	<li><tt>BasicBlock::iterator</tt> - Typedef for instruction list iterator<br>
				1320	<tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
				1321	<tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
				1322	<tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
				1323
				1324	These methods and typedefs are forwarding functions that have the same semantics
				1325	as the standard library methods of the same names. These methods expose the
				1326	underlying instruction list of a basic block in a way that is easy to
				1327	manipulate. To get the full complement of container operations (including
				1328	operations to update the list), you must use the <tt>getInstList()</tt>
				1329	method.<p>
				1330
				1331	<li><tt>BasicBlock::InstListType &getInstList()</tt><p>
				1332
				1333	This method is used to get access to the underlying container that actually
				1334	holds the Instructions. This method must be used when there isn't a forwarding
				1335	function in the <tt>BasicBlock</tt> class for the operation that you would like
				1336	to perform. Because there are no forwarding functions for "updating"
				1337	operations, you need to use this if you want to update the contents of a
				1338	<tt>BasicBlock</tt>.<p>
				1339
				1340	<li><tt><A href="#Function">Function</a> *getParent()</tt><p>
				1341
				1342	Returns a pointer to <a href="#Function"><tt>Function</tt></a> the block is
				1343	embedded into, or a null pointer if it is homeless.<p>
				1344
				1345	<li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt><p>
				1346
				1347	Returns a pointer to the terminator instruction that appears at the end of the
				1348	<tt>BasicBlock</tt>. If there is no terminator instruction, or if the last
				1349	instruction in the block is not a terminator, then a null pointer is
				1350	returned.<p>
				1351
				1352
				1353	<!-- ======================================================================= -->
				1354	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1355	<tr><td> </td><td width="100%">
				1356	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1357	<a name="GlobalValue">The <tt>GlobalValue</tt> class</a>
				1358	</b></font></td></tr></table><ul>
				1359
				1360	<tt>#include "<a
				1361	href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt></b><br>
				1362	doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue Class</a><br>
				1363	Superclasses: <a href="#User"><tt>User</tt></a>, <a
				1364	href="#Value"><tt>Value</tt></a><p>
				1365
				1366	Global values (<A href="#GlobalVariable"><tt>GlobalVariable</tt></a>s or <a
				1367	href="#Function"><tt>Function</tt></a>s) are the only LLVM values that are
				1368	visible in the bodies of all <a href="#Function"><tt>Function</tt></a>s.
				1369	Because they are visible at global scope, they are also subject to linking with
				1370	other globals defined in different translation units. To control the linking
				1371	process, <tt>GlobalValue</tt>s know their linkage rules. Specifically,
				1372	<tt>GlobalValue</tt>s know whether they have internal or external linkage.<p>
				1373
				1374	If a <tt>GlobalValue</tt> has internal linkage (equivalent to being
				1375	<tt>static</tt> in C), it is not visible to code outside the current translation
				1376	unit, and does not participate in linking. If it has external linkage, it is
				1377	visible to external code, and does participate in linking. In addition to
				1378	linkage information, <tt>GlobalValue</tt>s keep track of which <a
				1379	href="#Module"><tt>Module</tt></a> they are currently part of.<p>
				1380
				1381	Because <tt>GlobalValue</tt>s are memory objects, they are always referred to by
				1382	their address. As such, the <a href="#Type"><tt>Type</tt></a> of a global is
				1383	always a pointer to its contents. This is explained in the LLVM Language
				1384	Reference Manual.<p>
				1385
				1386
				1387	<!-- _______________________________________________________________________ -->
				1388	</ul><h4><a name="m_GlobalValue"><hr size=0>Important Public Members of
				1389	the <tt>GlobalValue</tt> class</h4><ul>
				1390
				1391	<li><tt>bool hasInternalLinkage() const</tt><br>
				1392	<tt>bool hasExternalLinkage() const</tt><br>
				1393	<tt>void setInternalLinkage(bool HasInternalLinkage)</tt><p>
				1394
				1395	These methods manipulate the linkage characteristics of the
				1396	<tt>GlobalValue</tt>.<p>
				1397
				1398	<li><tt><a href="#Module">Module</a> *getParent()</tt><p>
				1399
				1400	This returns the <a href="#Module"><tt>Module</tt></a> that the GlobalValue is
				1401	currently embedded into.<p>
				1402
				1403
				1404
				1405	<!-- ======================================================================= -->
				1406	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1407	<tr><td> </td><td width="100%">
				1408	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1409	<a name="Function">The <tt>Function</tt> class</a>
				1410	</b></font></td></tr></table><ul>
				1411
				1412	<tt>#include "<a
				1413	href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt></b><br>
				1414	doxygen info: <a href="/doxygen/classFunction.html">Function Class</a><br>
				1415	Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
				1416	href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
				1417
				1418	The <tt>Function</tt> class represents a single procedure in LLVM. It is
				1419	actually one of the more complex classes in the LLVM heirarchy because it must
				1420	keep track of a large amount of data. The <tt>Function</tt> class keeps track
				1421	of a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, a list of formal <a
				1422	href="#Argument"><tt>Argument</tt></a>s, and a <a
				1423	href="#SymbolTable"><tt>SymbolTable</tt></a>.<p>
				1424
				1425	The list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s is the most commonly
				1426	used part of <tt>Function</tt> objects. The list imposes an implicit ordering
				1427	of the blocks in the function, which indicate how the code will be layed out by
				1428	the backend. Additionally, the first <a
				1429	href="#BasicBlock"><tt>BasicBlock</tt></a> is the implicit entry node for the
				1430	<tt>Function</tt>. It is not legal in LLVM explicitly branch to this initial
				1431	block. There are no implicit exit nodes, and in fact there may be multiple exit
				1432	nodes from a single <tt>Function</tt>. If the <a
				1433	href="#BasicBlock"><tt>BasicBlock</tt></a> list is empty, this indicates that
				1434	the <tt>Function</tt> is actually a function declaration: the actual body of the
				1435	function hasn't been linked in yet.<p>
				1436
				1437	In addition to a list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s, the
				1438	<tt>Function</tt> class also keeps track of the list of formal <a
				1439	href="#Argument"><tt>Argument</tt></a>s that the function receives. This
				1440	container manages the lifetime of the <a href="#Argument"><tt>Argument</tt></a>
				1441	nodes, just like the <a href="#BasicBlock"><tt>BasicBlock</tt></a> list does for
				1442	the <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.<p>
				1443
				1444	The <a href="#SymbolTable"><tt>SymbolTable</tt></a> is a very rarely used LLVM
				1445	feature that is only used when you have to look up a value by name. Aside from
				1446	that, the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is used internally to
				1447	make sure that there are not conflicts between the names of <a
				1448	href="#Instruction"><tt>Instruction</tt></a>s, <a
				1449	href="#BasicBlock"><tt>BasicBlock</tt></a>s, or <a
				1450	href="#Argument"><tt>Argument</tt></a>s in the function body.<p>
				1451
				1452
				1453	<!-- _______________________________________________________________________ -->
				1454	</ul><h4><a name="m_Function"><hr size=0>Important Public Members of
				1455	the <tt>Function</tt> class</h4><ul>
				1456
				1457	<li><tt>Function(const <a href="#FunctionType">FunctionType</a> *Ty, bool isInternal, const std::string &N = "")</tt><p>
				1458
				1459	Constructor used when you need to create new <tt>Function</tt>s to add the the
				1460	program. The constructor must specify the type of the function to create and
				1461	whether or not it should start out with internal or external linkage.<p>
				1462
				1463	<li><tt>bool isExternal()</tt><p>
				1464
				1465	Return whether or not the <tt>Function</tt> has a body defined. If the function
				1466	is "external", it does not have a body, and thus must be resolved by linking
				1467	with a function defined in a different translation unit.<p>
				1468
				1469
				1470	<li><tt>Function::iterator</tt> - Typedef for basic block list iterator<br>
				1471	<tt>Function::const_iterator</tt> - Typedef for const_iterator.<br>
				1472	<tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
				1473	<tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
				1474
				1475	These are forwarding methods that make it easy to access the contents of a
				1476	<tt>Function</tt> object's <a href="#BasicBlock"><tt>BasicBlock</tt></a>
				1477	list.<p>
				1478
				1479	<li><tt>Function::BasicBlockListType &getBasicBlockList()</tt><p>
				1480
				1481	Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s. This is
Misha Brukman	5560c9d	2003-08-18 14:43:39 +0000	[diff] [blame]	1482	necessary to use when you need to update the list or perform a complex action
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1483	that doesn't have a forwarding method.<p>
				1484
				1485
				1486	<li><tt>Function::aiterator</tt> - Typedef for the argument list iterator<br>
				1487	<tt>Function::const_aiterator</tt> - Typedef for const_iterator.<br>
				1488	<tt>abegin()</tt>, <tt>aend()</tt>, <tt>afront()</tt>, <tt>aback()</tt>,
				1489	<tt>asize()</tt>, <tt>aempty()</tt>, <tt>arbegin()</tt>, <tt>arend()</tt><p>
				1490
				1491	These are forwarding methods that make it easy to access the contents of a
				1492	<tt>Function</tt> object's <a href="#Argument"><tt>Argument</tt></a> list.<p>
				1493
				1494	<li><tt>Function::ArgumentListType &getArgumentList()</tt><p>
				1495
				1496	Returns the list of <a href="#Argument"><tt>Argument</tt></a>s. This is
Misha Brukman	5560c9d	2003-08-18 14:43:39 +0000	[diff] [blame]	1497	necessary to use when you need to update the list or perform a complex action
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1498	that doesn't have a forwarding method.<p>
				1499
				1500
				1501
Chris Lattner	4c6d4d3	2003-09-20 14:43:16 +0000	[diff] [blame]	1502	<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryBlock()</tt><p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1503
				1504	Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
				1505	function. Because the entry block for the function is always the first block,
				1506	this returns the first block of the <tt>Function</tt>.<p>
				1507
				1508	<li><tt><a href="#Type">Type</a> *getReturnType()</tt><br>
				1509	<tt><a href="#FunctionType">FunctionType</a> *getFunctionType()</tt><p>
				1510
				1511	This traverses the <a href="#Type"><tt>Type</tt></a> of the <tt>Function</tt>
				1512	and returns the return type of the function, or the <a
				1513	href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
				1514
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1515	<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
				1516
				1517	Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
Chris Lattner	6e6026b	2002-11-20 18:36:02 +0000	[diff] [blame]	1518	<tt>Function</tt>.<p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1519
				1520
				1521
				1522	<!-- ======================================================================= -->
				1523	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1524	<tr><td> </td><td width="100%">
				1525	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1526	<a name="GlobalVariable">The <tt>GlobalVariable</tt> class</a>
				1527	</b></font></td></tr></table><ul>
				1528
				1529	<tt>#include "<a
				1530	href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt></b><br>
				1531	doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable Class</a><br>
				1532	Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
				1533	href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a><p>
				1534
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1535	Global variables are represented with the (suprise suprise)
				1536	<tt>GlobalVariable</tt> class. Like functions, <tt>GlobalVariable</tt>s are
				1537	also subclasses of <a href="#GlobalValue"><tt>GlobalValue</tt></a>, and as such
				1538	are always referenced by their address (global values must live in memory, so
				1539	their "name" refers to their address). Global variables may have an initial
				1540	value (which must be a <a href="#Constant"><tt>Constant</tt></a>), and if they
				1541	have an initializer, they may be marked as "constant" themselves (indicating
				1542	that their contents never change at runtime).<p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1543
				1544
				1545	<!-- _______________________________________________________________________ -->
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1546	</ul><h4><a name="m_GlobalVariable"><hr size=0>Important Public Members of the
				1547	<tt>GlobalVariable</tt> class</h4><ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1548
				1549	<li><tt>GlobalVariable(const <a href="#Type">Type</a> *Ty, bool isConstant, bool
				1550	isInternal, <a href="#Constant">Constant</a> *Initializer = 0, const std::string
				1551	&Name = "")</tt><p>
				1552
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1553	Create a new global variable of the specified type. If <tt>isConstant</tt> is
				1554	true then the global variable will be marked as unchanging for the program, and
				1555	if <tt>isInternal</tt> is true the resultant global variable will have internal
				1556	linkage. Optionally an initializer and name may be specified for the global variable as well.<p>
				1557
				1558
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1559	<li><tt>bool isConstant() const</tt><p>
				1560
				1561	Returns true if this is a global variable is known not to be modified at
				1562	runtime.<p>
				1563
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1564
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1565	<li><tt>bool hasInitializer()</tt><p>
				1566
				1567	Returns true if this <tt>GlobalVariable</tt> has an intializer.<p>
				1568
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1569
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1570	<li><tt><a href="#Constant">Constant</a> *getInitializer()</tt><p>
				1571
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1572	Returns the intial value for a <tt>GlobalVariable</tt>. It is not legal to call
				1573	this method if there is no initializer.<p>
				1574
				1575
				1576	<!-- ======================================================================= -->
				1577	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1578	<tr><td> </td><td width="100%">
				1579	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1580	<a name="Module">The <tt>Module</tt> class</a>
				1581	</b></font></td></tr></table><ul>
				1582
				1583	<tt>#include "<a
				1584	href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt></b><br>
				1585	doxygen info: <a href="/doxygen/classModule.html">Module Class</a><p>
				1586
				1587	The <tt>Module</tt> class represents the top level structure present in LLVM
				1588	programs. An LLVM module is effectively either a translation unit of the
				1589	original program or a combination of several translation units merged by the
				1590	linker. The <tt>Module</tt> class keeps track of a list of <a
				1591	href="#Function"><tt>Function</tt></a>s, a list of <a
				1592	href="#GlobalVariable"><tt>GlobalVariable</tt></a>s, and a <a
				1593	href="#SymbolTable"><tt>SymbolTable</tt></a>. Additionally, it contains a few
				1594	helpful member functions that try to make common operations easy.<p>
				1595
				1596
				1597	<!-- _______________________________________________________________________ -->
				1598	</ul><h4><a name="m_Module"><hr size=0>Important Public Members of the
				1599	<tt>Module</tt> class</h4><ul>
				1600
				1601	<li><tt>Module::iterator</tt> - Typedef for function list iterator<br>
				1602	<tt>Module::const_iterator</tt> - Typedef for const_iterator.<br>
				1603	<tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
				1604	<tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt><p>
				1605
				1606	These are forwarding methods that make it easy to access the contents of a
				1607	<tt>Module</tt> object's <a href="#Function"><tt>Function</tt></a>
				1608	list.<p>
				1609
				1610	<li><tt>Module::FunctionListType &getFunctionList()</tt><p>
				1611
				1612	Returns the list of <a href="#Function"><tt>Function</tt></a>s. This is
Misha Brukman	5560c9d	2003-08-18 14:43:39 +0000	[diff] [blame]	1613	necessary to use when you need to update the list or perform a complex action
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1614	that doesn't have a forwarding method.<p>
				1615
				1616	<!-- Global Variable -->
				1617	<hr size=0>
				1618
				1619	<li><tt>Module::giterator</tt> - Typedef for global variable list iterator<br>
				1620	<tt>Module::const_giterator</tt> - Typedef for const_iterator.<br>
				1621	<tt>gbegin()</tt>, <tt>gend()</tt>, <tt>gfront()</tt>, <tt>gback()</tt>,
				1622	<tt>gsize()</tt>, <tt>gempty()</tt>, <tt>grbegin()</tt>, <tt>grend()</tt><p>
				1623
				1624	These are forwarding methods that make it easy to access the contents of a
				1625	<tt>Module</tt> object's <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>
				1626	list.<p>
				1627
				1628	<li><tt>Module::GlobalListType &getGlobalList()</tt><p>
				1629
				1630	Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
Misha Brukman	5560c9d	2003-08-18 14:43:39 +0000	[diff] [blame]	1631	This is necessary to use when you need to update the list or perform a complex
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1632	action that doesn't have a forwarding method.<p>
				1633
				1634
				1635	<!-- Symbol table stuff -->
				1636	<hr size=0>
				1637
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1638	<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
				1639
Chris Lattner	6e6026b	2002-11-20 18:36:02 +0000	[diff] [blame]	1640	Return a reference to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for
				1641	this <tt>Module</tt>.<p>
Chris Lattner	0377de4	2002-09-06 14:50:55 +0000	[diff] [blame]	1642
				1643
				1644	<!-- Convenience methods -->
				1645	<hr size=0>
				1646
				1647	<li><tt><a href="#Function">Function</a> getFunction(const std::string &Name, const <a href="#FunctionType">FunctionType</a> Ty)</tt><p>
				1648
				1649	Look up the specified function in the <tt>Module</tt> <a
				1650	href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, return
				1651	<tt>null</tt>.<p>
				1652
				1653
				1654	<li><tt><a href="#Function">Function</a> *getOrInsertFunction(const std::string
				1655	&Name, const <a href="#FunctionType">FunctionType</a> *T)</tt><p>
				1656
				1657	Look up the specified function in the <tt>Module</tt> <a
				1658	href="#SymbolTable"><tt>SymbolTable</tt></a>. If it does not exist, add an
				1659	external declaration for the function and return it.<p>
				1660
				1661
				1662	<li><tt>std::string getTypeName(const <a href="#Type">Type</a> *Ty)</tt><p>
				1663
				1664	If there is at least one entry in the <a
				1665	href="#SymbolTable"><tt>SymbolTable</tt></a> for the specified <a
				1666	href="#Type"><tt>Type</tt></a>, return it. Otherwise return the empty
				1667	string.<p>
				1668
				1669
				1670	<li><tt>bool addTypeName(const std::string &Name, const <a href="#Type">Type</a>
				1671	*Ty)</tt><p>
				1672
				1673	Insert an entry in the <a href="#SymbolTable"><tt>SymbolTable</tt></a> mapping
				1674	<tt>Name</tt> to <tt>Ty</tt>. If there is already an entry for this name, true
				1675	is returned and the <a href="#SymbolTable"><tt>SymbolTable</tt></a> is not
				1676	modified.<p>
				1677
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1678
				1679	<!-- ======================================================================= -->
				1680	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1681	<tr><td> </td><td width="100%">
				1682	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1683	<a name="Constant">The <tt>Constant</tt> class and subclasses</a>
				1684	</b></font></td></tr></table><ul>
				1685
				1686	Constant represents a base class for different types of constants. It is
				1687	subclassed by ConstantBool, ConstantInt, ConstantSInt, ConstantUInt,
				1688	ConstantArray etc for representing the various types of Constants.<p>
				1689
				1690
				1691	<!-- _______________________________________________________________________ -->
				1692	</ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
				1693
				1694	<li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
				1695
				1696
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1697	<hr>
				1698	Important Subclasses of Constant<p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1699
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1700	<ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1701	<li>ConstantSInt : This subclass of Constant represents a signed integer constant.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1702	<ul>
				1703	<li><tt>int64_t getValue() const</tt>: Returns the underlying value of this constant.
				1704	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1705	<li>ConstantUInt : This class represents an unsigned integer.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1706	<ul>
				1707	<li><tt>uint64_t getValue() const</tt>: Returns the underlying value of this constant.
				1708	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1709	<li>ConstantFP : This class represents a floating point constant.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1710	<ul>
				1711	<li><tt>double getValue() const</tt>: Returns the underlying value of this constant.
				1712	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1713	<li>ConstantBool : This represents a boolean constant.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1714	<ul>
				1715	<li><tt>bool getValue() const</tt>: Returns the underlying value of this constant.
				1716	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1717	<li>ConstantArray : This represents a constant array.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1718	<ul>
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	1719	<li><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1720	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1721	<li>ConstantStruct : This represents a constant struct.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1722	<ul>
Chris Lattner	7496ec5	2003-08-05 22:54:23 +0000	[diff] [blame]	1723	<li><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1724	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1725	<li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1726	<ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1727	<li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1728	</ul>
				1729	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1730
				1731
				1732	<!-- ======================================================================= -->
				1733	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1734	<tr><td> </td><td width="100%">
				1735	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1736	<a name="Type">The <tt>Type</tt> class and Derived Types</a>
				1737	</b></font></td></tr></table><ul>
				1738
				1739	Type as noted earlier is also a subclass of a Value class. Any primitive
				1740	type (like int, short etc) in LLVM is an instance of Type Class. All
				1741	other types are instances of subclasses of type like FunctionType,
				1742	ArrayType etc. DerivedType is the interface for all such dervied types
				1743	including FunctionType, ArrayType, PointerType, StructType. Types can have
				1744	names. They can be recursive (StructType). There exists exactly one instance
				1745	of any type structure at a time. This allows using pointer equality of Type *s for comparing types.
				1746
				1747	<!-- _______________________________________________________________________ -->
				1748	</ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
				1749
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1750	<li><tt>PrimitiveID getPrimitiveID() const</tt>: Returns the base type of the type.
				1751	<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.
				1752	<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.
				1753	<li><tt> bool isInteger() const</tt>: Equilivent to isSigned() \|\| isUnsigned(), but with only a single virtual function invocation.
				1754	<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.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1755
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1756	<li><tt>bool isFloatingPoint()</tt>: Return true if this is one of the two floating point types.
				1757	<li><tt>bool isRecursive() const</tt>: Returns rue if the type graph contains a cycle.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1758	<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.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1759	<li><tt>bool isPrimitiveType() const</tt>: Returns true if it is a primitive type.
				1760	<li><tt>bool isDerivedType() const</tt>: Returns true if it is a derived type.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1761	<li><tt>const Type * getContainedType (unsigned i) const</tt>:
				1762	This 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.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1763	<li><tt>unsigned getNumContainedTypes() const</tt>: Return the number of types in the derived type.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1764
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1765	<p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1766
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1767	<hr>
				1768	Derived Types<p>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1769
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1770	<ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1771	<li>SequentialType : This is subclassed by ArrayType and PointerType
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1772	<ul>
				1773	<li><tt>const Type * getElementType() const</tt>: Returns the type of each of the elements in the sequential type.
				1774	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1775	<li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1776	<ul>
				1777	<li><tt>unsigned getNumElements() const</tt>: Returns the number of elements in the array.
				1778	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1779	<li>PointerType : Subclass of SequentialType for pointer types.
				1780	<li>StructType : subclass of DerivedTypes for struct types
				1781	<li>FunctionType : subclass of DerivedTypes for function types.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1782
				1783	<ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1784
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1785	<li><tt>bool isVarArg() const</tt>: Returns true if its a vararg function
				1786	<li><tt> const Type * getReturnType() const</tt>: Returns the return type of the function.
				1787	<li><tt> const ParamTypes &getParamTypes() const</tt>: Returns a vector of parameter types.
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1788	<li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
Chris Lattner	c75ff9a	2002-10-01 23:17:09 +0000	[diff] [blame]	1789	<li><tt> const unsigned getNumParams() const</tt>: Returns the number of formal parameters.
				1790	</ul>
				1791	</ul>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1792
				1793
				1794
				1795
				1796	<!-- ======================================================================= -->
				1797	</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
				1798	<tr><td> </td><td width="100%">
				1799	<font color="#EEEEFF" face="Georgia,Palatino"><b>
				1800	<a name="Argument">The <tt>Argument</tt> class</a>
				1801	</b></font></td></tr></table><ul>
				1802
				1803	This subclass of Value defines the interface for incoming formal arguments to a
				1804	function. A Function maitanis a list of its formal arguments. An argument has a
				1805	pointer to the parent Function.
				1806
				1807
				1808
				1809
				1810	<!-- *********************************************************************** -->
				1811	</ul>
				1812	<!-- *********************************************************************** -->
				1813
				1814	<hr><font size-1>
				1815	<address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
				1816	<a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
John Criswell	0f6d7c0	2003-10-27 18:18:16 +0000	[diff] [blame]	1817	<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a>
				1818	<br>
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1819	<!-- Created: Tue Aug 6 15:00:33 CDT 2002 -->
				1820	<!-- hhmts start -->
Brian Gaeke	f1972c6	2003-11-07 19:25:45 +0000	[diff] [blame^]	1821	Last modified: Fri Nov 7 13:24:22 CST 2003
Chris Lattner	9355b47	2002-09-06 02:50:58 +0000	[diff] [blame]	1822	<!-- hhmts end -->
				1823	</font></body></html>