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

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