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

blob: 89098c21e6004d4faf75ce115af516a449c69825 [file] [log] [blame]

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