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

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