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

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