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

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