<li><a href="#introduction">Introduction</a></li>
<li><a href="#general">General Information</a>
<ul>
- <li><a href="#stl">The C++ Standard Template Library</a><!--
- <li>The <tt>-time-passes</tt> option
- <li>How to use the LLVM Makefile system
- <li>How to write a regression test
---> </li>
+ <li><a href="#stl">The C++ Standard Template Library</a></li>
+<!--
+ <li>The <tt>-time-passes</tt> option</li>
+ <li>How to use the LLVM Makefile system</li>
+ <li>How to write a regression test</li>
+
+-->
</ul>
</li>
<li><a href="#apis">Important and useful LLVM APIs</a>
</ul>
</li>
<li><a href="#Statistic">The <tt>Statistic</tt> template & <tt>-stats</tt>
-option</a><!--
- <li>The <tt>InstVisitor</tt> template
- <li>The general graph API
---> </li>
+option</a></li>
+<!--
+ <li>The <tt>InstVisitor</tt> template
+ <li>The general graph API
+-->
</ul>
</li>
<li><a href="#common">Helpful Hints for Common Operations</a>
<li><a href="#schanges_replacing">Replacing an <tt>Instruction</tt>
with another <tt>Value</tt></a> </li>
</ul>
+ </li>
<!--
<li>Working with the Control Flow Graph
<ul>
<li>
<li>
</ul>
---> </li>
+-->
</ul>
</li>
<li><a href="#coreclasses">The Core LLVM Class Hierarchy Reference</a>
<ul>
- <li><a href="#Value">The <tt>Value</tt> class</a>
- <ul>
- <li><a href="#User">The <tt>User</tt> class</a>
+ <li><a href="#Value">The <tt>Value</tt> class</a>
<ul>
- <li><a href="#Instruction">The <tt>Instruction</tt> class</a>
+ <li><a href="#User">The <tt>User</tt> class</a>
<ul>
- <li><a href="#GetElementPtrInst">The <tt>GetElementPtrInst</tt>
- class</a></li>
- </ul></li>
- <li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
- <ul>
- <li><a href="#BasicBlock">The <tt>BasicBlock</tt>class</a></li>
- <li><a href="#Function">The <tt>Function</tt> class</a></li>
- <li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class
- </a></li>
- </ul></li>
- <li><a href="#Module">The <tt>Module</tt> class</a></li>
- <li><a href="#Constant">The <tt>Constant</tt> class</a></li>
+ <li><a href="#Instruction">The <tt>Instruction</tt> class</a>
+ <ul>
+ <li><a href="#GetElementPtrInst">The <tt>GetElementPtrInst</tt> class</a></li>
+ </ul>
+ </li>
+ <li><a href="#Module">The <tt>Module</tt> class</a></li>
+ <li><a href="#Constant">The <tt>Constant</tt> class</a>
+ <ul>
+ <li><a href="#GlobalValue">The <tt>GlobalValue</tt> class</a>
+ <ul>
+ <li><a href="#BasicBlock">The <tt>BasicBlock</tt>class</a></li>
+ <li><a href="#Function">The <tt>Function</tt> class</a></li>
+ <li><a href="#GlobalVariable">The <tt>GlobalVariable</tt> class</a></li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+ </ul>
+ </li>
<li><a href="#Type">The <tt>Type</tt> class</a> </li>
<li><a href="#Argument">The <tt>Argument</tt> class</a></li>
- </ul></li>
- </ul></li>
- <li><a href="#SymbolTable">The <tt>SymbolTable</tt> class </a></li>
- <li>The <tt>ilist</tt> and <tt>iplist</tt> classes
- <ul>
- <li>Creating, inserting, moving and deleting from LLVM lists </li>
- </ul>
- </li>
- <li>Important iterator invalidation semantics to be aware of.</li>
+ </ul>
+ </li>
+ </ul>
</li>
+ <li><a href="#SymbolTable">The <tt>SymbolTable</tt> class </a></li>
+ <li>The <tt>ilist</tt> and <tt>iplist</tt> classes
+ <ul>
+ <li>Creating, inserting, moving and deleting from LLVM lists </li>
+ </ul>
+ </li>
+ <li>Important iterator invalidation semantics to be aware of.</li>
</ol>
<div class="doc_author">
<p>Written by <a href="mailto:sabre@nondot.org">Chris Lattner</a>,
- <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>, and
- <a href="mailto:jstanley@cs.uiuc.edu">Joel Stanley</a></p>
+ <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a>,
+ <a href="mailto:jstanley@cs.uiuc.edu">Joel Stanley</a>, and
+ <a href="mailto:rspencer@x10sys.com">Reid Spencer</a></p>
</div>
<!-- *********************************************************************** -->
standard C++ library.</li>
<li><a href="http://www.tempest-sw.com/cpp/">C++ In a Nutshell</a> - This is an
-O'Reilly book in the making. It has a decent <a
-href="http://www.tempest-sw.com/cpp/ch13-libref.html">Standard Library
-Reference</a> that rivals Dinkumware's, and is actually free until the book is
+O'Reilly book in the making. It has a decent
+Standard Library
+Reference that rivals Dinkumware's, and is unfortunately no longer free since the book has been
published.</li>
<li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
<li><a href="http://www.research.att.com/%7Ebs/C++.html">Bjarne Stroustrup's C++
Page</a></li>
-<li><a href="http://www.linux.com.cn/Bruce_Eckel/TICPPv2/Contents.htm">
+<li><a href="http://64.78.49.204/">
Bruce Eckel's Thinking in C++, 2nd ed. Volume 2 Revision 4.0 (even better, get
the book).</a></li>
<div class="doc_text">
-<p>LLVM is currently using CVS as its source versioning system. You may find
-this reference handy:</p>
-
<ol>
<li><a href="http://www.psc.edu/%7Esemke/cvs_branches.html">CVS
Branch and Tag Primer</a></li>
+<li><a href="http://www.fortran-2000.com/ArnaudRecipes/sharedlib.html">Using
+static and shared libraries across platforms</a></li>
</ol>
</div>
<tt>BasicBlock</tt>s. Here's a code snippet that prints out each instruction in
a <tt>BasicBlock</tt>:</p>
- <pre> // blk is a pointer to a BasicBlock instance<br> for (BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i)<br> // the next statement works since operator<<(ostream&,...) <br> // is overloaded for Instruction&<br> cerr << *i << "\n";<br></pre>
+<pre>
+ // blk is a pointer to a BasicBlock instance
+ for (BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i)
+ // the next statement works since operator<<(ostream&,...)
+ // is overloaded for Instruction&
+ std::cerr << *i << "\n";
+</pre>
<p>However, this isn't really the best way to print out the contents of a
<tt>BasicBlock</tt>! Since the ostream operators are overloaded for virtually
anything you'll care about, you could have just invoked the print routine on the
-basic block itself: <tt>cerr << *blk << "\n";</tt>.</p>
-
-<p>Note that currently operator<< is implemented for <tt>Value*</tt>, so
-it will print out the contents of the pointer, instead of the pointer value you
-might expect. This is a deprecated interface that will be removed in the
-future, so it's best not to depend on it. To print out the pointer value for
-now, you must cast to <tt>void*</tt>.</p>
+basic block itself: <tt>std::cerr << *blk << "\n";</tt>.</p>
</div>
most-specific common base class is <tt>Instruction</tt>, which includes lots of
less closely-related things. For these cases, LLVM provides a handy wrapper
class called <a
-href="http://llvm.cs.uiuc.edu/doxygen/classCallSite.html"><tt>CallSite</tt></a>.
+href="http://llvm.cs.uiuc.edu/doxygen/classllvm_1_1CallSite.html"><tt>CallSite</tt></a>.
It is essentially a wrapper around an <tt>Instruction</tt> pointer, with some
methods that provide functionality common to <tt>CallInst</tt>s and
<tt>InvokeInst</tt>s.</p>
<div class="doc_text">
<p>Frequently, we might have an instance of the <a
-href="/doxygen/classValue.html">Value Class</a> and we want to determine which
-<tt>User</tt>s use the <tt>Value</tt>. The list of all <tt>User</tt>s of a
-particular <tt>Value</tt> is called a <i>def-use</i> chain. For example, let's
-say we have a <tt>Function*</tt> named <tt>F</tt> to a particular function
-<tt>foo</tt>. Finding all of the instructions that <i>use</i> <tt>foo</tt> is as
-simple as iterating over the <i>def-use</i> chain of <tt>F</tt>:</p>
+href="/doxygen/structllvm_1_1Value.html">Value Class</a> and we want to
+determine which <tt>User</tt>s use the <tt>Value</tt>. The list of all
+<tt>User</tt>s of a particular <tt>Value</tt> is called a <i>def-use</i> chain.
+For example, let's say we have a <tt>Function*</tt> named <tt>F</tt> to a
+particular function <tt>foo</tt>. Finding all of the instructions that
+<i>use</i> <tt>foo</tt> is as simple as iterating over the <i>def-use</i> chain
+of <tt>F</tt>:</p>
<pre>Function* F = ...;<br><br>for (Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) {<br> if (Instruction *Inst = dyn_cast<Instruction>(*i)) {<br> cerr << "F is used in instruction:\n";<br> cerr << *Inst << "\n";<br> }<br>}<br></pre>
<p>Alternately, it's common to have an instance of the <a
-href="/doxygen/classUser.html">User Class</a> and need to know what
+href="/doxygen/classllvm_1_1User.html">User Class</a> and need to know what
<tt>Value</tt>s are used by it. The list of all <tt>Value</tt>s used by a
<tt>User</tt> is known as a <i>use-def</i> chain. Instances of class
<tt>Instruction</tt> are common <tt>User</tt>s, so we might want to iterate over
one integer in the current stack frame, at runtime. Each <tt>Instruction</tt>
subclass is likely to have varying default parameters which change the semantics
of the instruction, so refer to the <a
-href="/doxygen/classInstruction.html">doxygen documentation for the subclass of
+href="/doxygen/classllvm_1_1Instruction.html">doxygen documentation for the subclass of
Instruction</a> that you're interested in instantiating.</p>
<p><i>Naming values</i></p>
<tt>BasicBlock</tt>, and a newly-created instruction we wish to insert
before <tt>*pi</tt>, we do the following: </p>
- <pre> BasicBlock *pb = ...;<br> Instruction *pi = ...;<br> Instruction *newInst = new Instruction(...);<br> pb->getInstList().insert(pi, newInst); // inserts newInst before pi in pb<br></pre></li>
+ <pre> BasicBlock *pb = ...;<br> Instruction *pi = ...;<br> Instruction *newInst = new Instruction(...);<br> pb->getInstList().insert(pi, newInst); // inserts newInst before pi in pb<br></pre>
+
+ <p>Appending to the end of a <tt>BasicBlock</tt> is so common that
+ the <tt>Instruction</tt> class and <tt>Instruction</tt>-derived
+ classes provide constructors which take a pointer to a
+ <tt>BasicBlock</tt> to be appended to. For example code that
+ looked like: </p>
+
+ <pre> BasicBlock *pb = ...;<br> Instruction *newInst = new Instruction(...);<br> pb->getInstList().push_back(newInst); // appends newInst to pb<br></pre>
+
+ <p>becomes: </p>
+
+ <pre> BasicBlock *pb = ...;<br> Instruction *newInst = new Instruction(..., pb);<br></pre>
+
+ <p>which is much cleaner, especially if you are creating
+ long instruction streams.</p></li>
<li>Insertion into an implicit instruction list
<p>This function replaces all uses (within a basic block) of a given
instruction with a value, and then removes the original instruction. The
following example illustrates the replacement of the result of a particular
- <tt>AllocaInst</tt> that allocates memory for a single integer with an null
+ <tt>AllocaInst</tt> that allocates memory for a single integer with a null
pointer to an integer.</p>
<pre>AllocaInst* instToReplace = ...;<br>BasicBlock::iterator ii(instToReplace);<br>ReplaceInstWithValue(instToReplace->getParent()->getInstList(), ii,<br> Constant::getNullValue(PointerType::get(Type::IntTy)));<br></pre></li>
<p>You can use <tt>Value::replaceAllUsesWith</tt> and
<tt>User::replaceUsesOfWith</tt> to change more than one use at a time. See the
-doxygen documentation for the <a href="/doxygen/classValue.html">Value Class</a>
-and <a href="/doxygen/classUser.html">User Class</a>, respectively, for more
+doxygen documentation for the <a href="/doxygen/structllvm_1_1Value.html">Value Class</a>
+and <a href="/doxygen/classllvm_1_1User.html">User Class</a>, respectively, for more
information.</p>
<!-- Value::replaceAllUsesWith User::replaceUsesOfWith Point out:
<p><tt>#include "<a href="/doxygen/Value_8h-source.html">llvm/Value.h</a>"</tt>
<br>
-doxygen info: <a href="/doxygen/classValue.html">Value Class</a></p>
+doxygen info: <a href="/doxygen/structllvm_1_1Value.html">Value Class</a></p>
<p>The <tt>Value</tt> class is the most important class in the LLVM Source
base. It represents a typed value that may be used (among other things) as an
<p>
<tt>#include "<a href="/doxygen/User_8h-source.html">llvm/User.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classUser.html">User Class</a><br>
+doxygen info: <a href="/doxygen/classllvm_1_1User.html">User Class</a><br>
Superclass: <a href="#Value"><tt>Value</tt></a></p>
<p>The <tt>User</tt> class is the common base class of all LLVM nodes that may
<li><tt>User::op_iterator</tt> - Typedef for iterator over the operand
list<br>
- <tt>User::op_const_iterator</tt> <tt>use_iterator op_begin()</tt> -
-Get an iterator to the start of the operand list.<br>
- <tt>use_iterator op_end()</tt> - Get an iterator to the end of the
+ <tt>op_iterator op_begin()</tt> - Get an iterator to the start of
+the operand list.<br>
+ <tt>op_iterator op_end()</tt> - Get an iterator to the end of the
operand list.
<p> Together, these methods make up the iterator based interface to
the operands of a <tt>User</tt>.</p></li>
<p><tt>#include "</tt><tt><a
href="/doxygen/Instruction_8h-source.html">llvm/Instruction.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classInstruction.html">Instruction Class</a><br>
+doxygen info: <a href="/doxygen/classllvm_1_1Instruction.html">Instruction Class</a><br>
Superclasses: <a href="#User"><tt>User</tt></a>, <a
href="#Value"><tt>Value</tt></a></p>
example <tt><a href="#BinaryOperator">BinaryOperator</a></tt> and <tt><a
href="#SetCondInst">SetCondInst</a></tt>). Unfortunately, the use of macros in
this file confuses doxygen, so these enum values don't show up correctly in the
-<a href="/doxygen/classInstruction.html">doxygen output</a>.</p>
+<a href="/doxygen/classllvm_1_1Instruction.html">doxygen output</a>.</p>
</div>
<div class="doc_text">
-<p><tt>#include "<a href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classBasicBlock.html">BasicBlock Class</a><br>
+<p><tt>#include "<a
+href="/doxygen/BasicBlock_8h-source.html">llvm/BasicBlock.h</a>"</tt><br>
+doxygen info: <a href="/doxygen/structllvm_1_1BasicBlock.html">BasicBlock
+Class</a><br>
Superclass: <a href="#Value"><tt>Value</tt></a></p>
<p>This class represents a single entry multiple exit section of the code,
<div class="doc_text">
<ul>
- <li><tt>BasicBlock(const std::string &Name = "", </tt><tt><a
+
+<li><tt>BasicBlock(const std::string &Name = "", </tt><tt><a
href="#Function">Function</a> *Parent = 0)</tt>
- <p>The <tt>BasicBlock</tt> constructor is used to create new basic
-blocks for insertion into a function. The constructor optionally takes
-a name for the new block, and a <a href="#Function"><tt>Function</tt></a>
-to insert it into. If the <tt>Parent</tt> parameter is specified, the
-new <tt>BasicBlock</tt> is automatically inserted at the end of the
-specified <a href="#Function"><tt>Function</tt></a>, if not specified,
-the BasicBlock must be manually inserted into the <a href="#Function"><tt>Function</tt></a>.</p>
- </li>
- <li><tt>BasicBlock::iterator</tt> - Typedef for instruction list
-iterator<br>
- <tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
- <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,<tt>size()</tt>,<tt>empty()</tt>,<tt>rbegin()</tt>,<tt>rend()
-- </tt>STL style functions for accessing the instruction list.
- <p> These methods and typedefs are forwarding functions that have
-the same semantics as the standard library methods of the same names.
-These methods expose the underlying instruction list of a basic block in
-a way that is easy to manipulate. To get the full complement of
-container operations (including operations to update the list), you must
-use the <tt>getInstList()</tt> method.</p></li>
- <li><tt>BasicBlock::InstListType &getInstList()</tt>
- <p> This method is used to get access to the underlying container
-that actually holds the Instructions. This method must be used when
-there isn't a forwarding function in the <tt>BasicBlock</tt> class for
-the operation that you would like to perform. Because there are no
-forwarding functions for "updating" operations, you need to use this if
-you want to update the contents of a <tt>BasicBlock</tt>.</p></li>
- <li><tt><a href="#Function">Function</a> *getParent()</tt>
- <p> Returns a pointer to <a href="#Function"><tt>Function</tt></a>
-the block is embedded into, or a null pointer if it is homeless.</p></li>
- <li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt>
- <p> Returns a pointer to the terminator instruction that appears at
-the end of the <tt>BasicBlock</tt>. If there is no terminator
-instruction, or if the last instruction in the block is not a
-terminator, then a null pointer is returned.</p></li>
+
+<p>The <tt>BasicBlock</tt> constructor is used to create new basic blocks for
+insertion into a function. The constructor optionally takes a name for the new
+block, and a <a href="#Function"><tt>Function</tt></a> to insert it into. If
+the <tt>Parent</tt> parameter is specified, the new <tt>BasicBlock</tt> is
+automatically inserted at the end of the specified <a
+href="#Function"><tt>Function</tt></a>, if not specified, the BasicBlock must be
+manually inserted into the <a href="#Function"><tt>Function</tt></a>.</p></li>
+
+<li><tt>BasicBlock::iterator</tt> - Typedef for instruction list iterator<br>
+<tt>BasicBlock::const_iterator</tt> - Typedef for const_iterator.<br>
+<tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
+<tt>size()</tt>, <tt>empty()</tt>
+STL-style functions for accessing the instruction list.
+
+<p>These methods and typedefs are forwarding functions that have the same
+semantics as the standard library methods of the same names. These methods
+expose the underlying instruction list of a basic block in a way that is easy to
+manipulate. To get the full complement of container operations (including
+operations to update the list), you must use the <tt>getInstList()</tt>
+method.</p></li>
+
+<li><tt>BasicBlock::InstListType &getInstList()</tt>
+
+<p>This method is used to get access to the underlying container that actually
+holds the Instructions. This method must be used when there isn't a forwarding
+function in the <tt>BasicBlock</tt> class for the operation that you would like
+to perform. Because there are no forwarding functions for "updating"
+operations, you need to use this if you want to update the contents of a
+<tt>BasicBlock</tt>.</p></li>
+
+<li><tt><a href="#Function">Function</a> *getParent()</tt>
+
+<p> Returns a pointer to <a href="#Function"><tt>Function</tt></a> the block is
+embedded into, or a null pointer if it is homeless.</p></li>
+
+<li><tt><a href="#TerminatorInst">TerminatorInst</a> *getTerminator()</tt>
+
+<p> Returns a pointer to the terminator instruction that appears at the end of
+the <tt>BasicBlock</tt>. If there is no terminator instruction, or if the last
+instruction in the block is not a terminator, then a null pointer is
+returned.</p></li>
+
</ul>
</div>
<p><tt>#include "<a
href="/doxygen/GlobalValue_8h-source.html">llvm/GlobalValue.h</a>"</tt><br>
-doxygen info: <a href="/doxygen/classGlobalValue.html">GlobalValue Class</a><br>
+doxygen info: <a href="/doxygen/classllvm_1_1GlobalValue.html">GlobalValue
+Class</a><br>
Superclasses: <a href="#User"><tt>User</tt></a>, <a
href="#Value"><tt>Value</tt></a></p>
other globals defined in different translation units. To control the linking
process, <tt>GlobalValue</tt>s know their linkage rules. Specifically,
<tt>GlobalValue</tt>s know whether they have internal or external linkage, as
-defined by the <tt>LinkageTypes</tt> enumerator.</p>
+defined by the <tt>LinkageTypes</tt> enumeration.</p>
<p>If a <tt>GlobalValue</tt> has internal linkage (equivalent to being
<tt>static</tt> in C), it is not visible to code outside the current translation
<p><tt>#include "<a
href="/doxygen/Function_8h-source.html">llvm/Function.h</a>"</tt><br> doxygen
-info: <a href="/doxygen/classFunction.html">Function Class</a><br> Superclasses:
-<a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
+info: <a href="/doxygen/classllvm_1_1Function.html">Function Class</a><br>
+
Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a></p>
<p>The <tt>Function</tt> class represents a single procedure in LLVM. It is
href="#BasicBlock"><tt>BasicBlock</tt></a>s, or <a
href="#Argument"><tt>Argument</tt></a>s in the function body.</p>
+<p>Note that <tt>Function</tt> is a <a href="#GlobalValue">GlobalValue</a>
+and therefore also a <a href="#Constant">Constant</a>. The value of the function
+is its address (after linking) which is guaranteed to be constant.</p>
</div>
<!-- _______________________________________________________________________ -->
<ul>
<li><tt>Function(const </tt><tt><a href="#FunctionType">FunctionType</a>
- *Ty, bool isInternal, const std::string &N = "", Module* Parent = 0)</tt>
+ *Ty, LinkageTypes Linkage, const std::string &N = "", Module* Parent = 0)</tt>
<p>Constructor used when you need to create new <tt>Function</tt>s to add
the the program. The constructor must specify the type of the function to
- create and whether or not it should start out with internal or external
- linkage. The <a href="#FunctionType"><tt>FunctionType</tt></a> argument
+ create and what type of linkage the function should have. The <a
+ href="#FunctionType"><tt>FunctionType</tt></a> argument
specifies the formal arguments and return value for the function. The same
<a href="#FunctionTypel"><tt>FunctionType</tt></a> value can be used to
create multiple functions. The <tt>Parent</tt> argument specifies the Module
<li><tt>Function::iterator</tt> - Typedef for basic block list iterator<br>
<tt>Function::const_iterator</tt> - Typedef for const_iterator.<br>
- <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
- <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt>
+ <tt>begin()</tt>, <tt>end()</tt>
+ <tt>size()</tt>, <tt>empty()</tt>
<p>These are forwarding methods that make it easy to access the contents of
a <tt>Function</tt> object's <a href="#BasicBlock"><tt>BasicBlock</tt></a>
is necessary to use when you need to update the list or perform a complex
action that doesn't have a forwarding method.</p></li>
- <li><tt>Function::aiterator</tt> - Typedef for the argument list
+ <li><tt>Function::arg_iterator</tt> - Typedef for the argument list
iterator<br>
- <tt>Function::const_aiterator</tt> - Typedef for const_iterator.<br>
+ <tt>Function::const_arg_iterator</tt> - Typedef for const_iterator.<br>
- <tt>abegin()</tt>, <tt>aend()</tt>, <tt>afront()</tt>, <tt>aback()</tt>,
- <tt>asize()</tt>, <tt>aempty()</tt>, <tt>arbegin()</tt>, <tt>arend()</tt>
+ <tt>arg_begin()</tt>, <tt>arg_end()</tt>
+ <tt>arg_size()</tt>, <tt>arg_empty()</tt>
<p>These are forwarding methods that make it easy to access the contents of
a <tt>Function</tt> object's <a href="#Argument"><tt>Argument</tt></a>
<p><tt>#include "<a
href="/doxygen/GlobalVariable_8h-source.html">llvm/GlobalVariable.h</a>"</tt>
<br>
-doxygen info: <a href="/doxygen/classGlobalVariable.html">GlobalVariable
+doxygen info: <a href="/doxygen/classllvm_1_1GlobalVariable.html">GlobalVariable
Class</a><br> Superclasses: <a href="#GlobalValue"><tt>GlobalValue</tt></a>, <a
href="#User"><tt>User</tt></a>, <a href="#Value"><tt>Value</tt></a></p>
<p><tt>#include "<a
href="/doxygen/Module_8h-source.html">llvm/Module.h</a>"</tt><br> doxygen info:
-<a href="/doxygen/classModule.html">Module Class</a></p>
+<a href="/doxygen/classllvm_1_1Module.html">Module Class</a></p>
<p>The <tt>Module</tt> class represents the top level structure present in LLVM
programs. An LLVM module is effectively either a translation unit of the
<li><tt>Module::iterator</tt> - Typedef for function list iterator<br>
<tt>Module::const_iterator</tt> - Typedef for const_iterator.<br>
- <tt>begin()</tt>, <tt>end()</tt>, <tt>front()</tt>, <tt>back()</tt>,
- <tt>size()</tt>, <tt>empty()</tt>, <tt>rbegin()</tt>, <tt>rend()</tt>
+ <tt>begin()</tt>, <tt>end()</tt>
+ <tt>size()</tt>, <tt>empty()</tt>
<p>These are forwarding methods that make it easy to access the contents of
a <tt>Module</tt> object's <a href="#Function"><tt>Function</tt></a>
<hr>
<ul>
- <li><tt>Module::giterator</tt> - Typedef for global variable list iterator<br>
+ <li><tt>Module::global_iterator</tt> - Typedef for global variable list iterator<br>
- <tt>Module::const_giterator</tt> - Typedef for const_iterator.<br>
+ <tt>Module::const_global_iterator</tt> - Typedef for const_iterator.<br>
- <tt>gbegin()</tt>, <tt>gend()</tt>, <tt>gfront()</tt>, <tt>gback()</tt>,
- <tt>gsize()</tt>, <tt>gempty()</tt>, <tt>grbegin()</tt>, <tt>grend()</tt>
+ <tt>global_begin()</tt>, <tt>global_end()</tt>
+ <tt>global_size()</tt>, <tt>global_empty()</tt>
<p> These are forwarding methods that make it easy to access the contents of
a <tt>Module</tt> object's <a
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="m_Value">Important Public Methods</a>
+ <a name="m_Constant">Important Public Methods</a>
</div>
-
<div class="doc_text">
+</div>
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">Important Subclasses of Constant </div>
+<div class="doc_text">
<ul>
- <li><tt>bool isConstantExpr()</tt>: Returns true if it is a
-ConstantExpr
- <hr> Important Subclasses of Constant
- <p> </p>
+ <li>ConstantSInt : This subclass of Constant represents a signed integer
+ constant.
<ul>
- <li>ConstantSInt : This subclass of Constant represents a signed
-integer constant.
- <ul>
- <li><tt>int64_t getValue() const</tt>: Returns the underlying value of
-this constant. </li>
- </ul>
- </li>
- <li>ConstantUInt : This class represents an unsigned integer.
- <ul>
- <li><tt>uint64_t getValue() const</tt>: Returns the underlying value
-of this constant. </li>
- </ul>
- </li>
- <li>ConstantFP : This class represents a floating point constant.
- <ul>
- <li><tt>double getValue() const</tt>: Returns the underlying value of
-this constant. </li>
- </ul>
- </li>
- <li>ConstantBool : This represents a boolean constant.
- <ul>
- <li><tt>bool getValue() const</tt>: Returns the underlying value of
-this constant. </li>
- </ul>
- </li>
- <li>ConstantArray : This represents a constant array.
- <ul>
- <li><tt>const std::vector<Use> &getValues() const</tt>:
-Returns a Vecotr of component constants that makeup this array. </li>
- </ul>
- </li>
- <li>ConstantStruct : This represents a constant struct.
- <ul>
- <li><tt>const std::vector<Use> &getValues() const</tt>:
-Returns a Vecotr of component constants that makeup this array. </li>
- </ul>
- </li>
- <li>ConstantPointerRef : This represents a constant pointer value
-that is initialized to point to a global value, which lies at a
-constant fixed address.
- <ul>
- <li><tt>GlobalValue *getValue()</tt>: Returns the global
-value to which this pointer is pointing to. </li>
- </ul>
- </li>
+ <li><tt>int64_t getValue() const</tt>: Returns the underlying value of
+ this constant. </li>
+ </ul>
+ </li>
+ <li>ConstantUInt : This class represents an unsigned integer.
+ <ul>
+ <li><tt>uint64_t getValue() const</tt>: Returns the underlying value of
+ this constant. </li>
+ </ul>
+ </li>
+ <li>ConstantFP : This class represents a floating point constant.
+ <ul>
+ <li><tt>double getValue() const</tt>: Returns the underlying value of
+ this constant. </li>
</ul>
</li>
+ <li>ConstantBool : This represents a boolean constant.
+ <ul>
+ <li><tt>bool getValue() const</tt>: Returns the underlying value of this
+ constant. </li>
+ </ul>
+ </li>
+ <li>ConstantArray : This represents a constant array.
+ <ul>
+ <li><tt>const std::vector<Use> &getValues() const</tt>: Returns
+ a vector of component constants that makeup this array. </li>
+ </ul>
+ </li>
+ <li>ConstantStruct : This represents a constant struct.
+ <ul>
+ <li><tt>const std::vector<Use> &getValues() const</tt>: Returns
+ a vector of component constants that makeup this array. </li>
+ </ul>
+ </li>
+ <li>GlobalValue : This represents either a global variable or a function. In
+ either case, the value is a constant fixed address (after linking).
+ </li>
</ul>
-
</div>
<!-- ======================================================================= -->
return false as they do with isSigned. This returns true for UByteTy,
UShortTy, UIntTy, and ULongTy. </li>
- <li><tt>bool isInteger() const</tt>: Equilivent to isSigned() || isUnsigned(),
- but with only a single virtual function invocation.</li>
+ <li><tt>bool isInteger() const</tt>: Equivalent to isSigned() || isUnsigned().</li>
<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.</li>
<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 or one pointer type to another.</li>
+</ul>
+</div>
-<br>
- <p>Derived Types</p>
-
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="m_Value">Important Derived Types</a>
+</div>
+<div class="doc_text">
+<ul>
+ <li>SequentialType : This is subclassed by ArrayType and PointerType
<ul>
- <li>SequentialType : This is subclassed by ArrayType and PointerType
- <ul>
- <li><tt>const Type * getElementType() const</tt>: Returns the type of
-each of the elements in the sequential type. </li>
- </ul>
- </li>
- <li>ArrayType : This is a subclass of SequentialType and defines
-interface for array types.
- <ul>
- <li><tt>unsigned getNumElements() const</tt>: Returns the number of
-elements in the array. </li>
- </ul>
- </li>
- <li>PointerType : Subclass of SequentialType for pointer types. </li>
- <li>StructType : subclass of DerivedTypes for struct types </li>
- <li>FunctionType : subclass of DerivedTypes for function types.
- <ul>
- <li><tt>bool isVarArg() const</tt>: Returns true if its a vararg
- function</li>
- <li><tt> const Type * getReturnType() const</tt>: Returns the
- return type of the function.</li>
- <li><tt>const Type * getParamType (unsigned i)</tt>: Returns
- the type of the ith parameter.</li>
- <li><tt> const unsigned getNumParams() const</tt>: Returns the
- number of formal parameters.</li>
- </ul>
- </li>
+ <li><tt>const Type * getElementType() const</tt>: Returns the type of each
+ of the elements in the sequential type. </li>
+ </ul>
+ </li>
+ <li>ArrayType : This is a subclass of SequentialType and defines interface for
+ array types.
+ <ul>
+ <li><tt>unsigned getNumElements() const</tt>: Returns the number of
+ elements in the array. </li>
+ </ul>
+ </li>
+ <li>PointerType : Subclass of SequentialType for pointer types. </li>
+ <li>StructType : subclass of DerivedTypes for struct types </li>
+ <li>FunctionType : subclass of DerivedTypes for function types.
+ <ul>
+ <li><tt>bool isVarArg() const</tt>: Returns true if its a vararg
+ function</li>
+ <li><tt> const Type * getReturnType() const</tt>: Returns the
+ return type of the function.</li>
+ <li><tt>const Type * getParamType (unsigned i)</tt>: Returns
+ the type of the ith parameter.</li>
+ <li><tt> const unsigned getNumParams() const</tt>: Returns the
+ number of formal parameters.</li>
</ul>
</li>
</ul>
-
</div>
<!-- ======================================================================= -->
<div class="doc_text">
<p>This subclass of Value defines the interface for incoming formal
-arguments to a function. A Function maitanis a list of its formal
+arguments to a function. A Function maintains a list of its formal
arguments. An argument has a pointer to the parent Function.</p>
</div>
<dt><tt>bool isEmpty() const</tt>:</dt>
<dd>This function returns true if both the value and types maps are
empty</dd>
-
- <dt><tt>std::string get_name(const Value*) const</tt>:</dt>
- <dd>This function returns the name of the Value provided or the empty
- string if the Value is not in the symbol table.</dd>
-
- <dt><tt>std::string get_name(const Type*) const</tt>:</dt>
- <dd>This function returns the name of the Type provided or the empty
- string if the Type is not in the symbol table.</dd>
</dl>
<h3>Mutators</h3>
the beginning or end of the sequence for both const and non-const. It is
important to keep track of the different kinds of iterators. There are
three idioms worth pointing out:</p>
-<table class="doc_table">
+<table>
<tr><th>Units</th><th>Iterator</th><th>Idiom</th></tr>
<tr>
- <td>Planes Of name/Value maps</td><td>PI</td>
- <td><tt><pre>
+ <td align="left">Planes Of name/Value maps</td><td>PI</td>
+ <td align="left"><pre><tt>
for (SymbolTable::plane_const_iterator PI = ST.plane_begin(),
-PE = ST.plane_end(); PI != PE; ++PI ) {
+ PE = ST.plane_end(); PI != PE; ++PI ) {
PI->first // This is the Type* of the plane
PI->second // This is the SymbolTable::ValueMap of name/Value pairs
- </pre></tt></td>
+ </tt></pre></td>
</tr>
<tr>
- <td>All name/Type Pairs</td><td>TI</td>
- <td><tt><pre>
+ <td align="left">All name/Type Pairs</td><td>TI</td>
+ <td align="left"><pre><tt>
for (SymbolTable::type_const_iterator TI = ST.type_begin(),
TE = ST.type_end(); TI != TE; ++TI )
TI->first // This is the name of the type
TI->second // This is the Type* value associated with the name
- </pre></tt></td>
+ </tt></pre></td>
</tr>
<tr>
- <td>name/Value pairs in a plane</td><td>VI</td>
- <td><tt><pre>
+ <td align="left">name/Value pairs in a plane</td><td>VI</td>
+ <td align="left"><pre><tt>
for (SymbolTable::value_const_iterator VI = ST.value_begin(SomeType),
VE = ST.value_end(SomeType); VI != VE; ++VI )
VI->first // This is the name of the Value
VI->second // This is the Value* value associated with the name
- </pre></tt></td>
+ </tt></pre></td>
</tr>
</table>
+
<p>Using the recommended iterator names and idioms will help you avoid
making mistakes. Of particular note, make sure that whenever you use
value_begin(SomeType) that you always compare the resulting iterator
<dd>This method returns a plane_iterator for iteration over the
type planes starting at a specific plane, given by \p Ty.</dd>
- <dt><tt>const ValueMap* findPlane( const Type* Typ ) cons</tt>:</dt>
- <dd>This method returns a ValueMap* for a specific type plane. This
- interface is deprecated and may go away in the future.</dd>
</dl>
</div>
projects / oota-llvm.git / blobdiff