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

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