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

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