projects / oota-llvm.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
index.html: Add link to llvm vs. the world
[oota-llvm.git] / docs / ProgrammersManual.html
diff --git a/docs/ProgrammersManual.html b/docs/ProgrammersManual.html
index 58ad5a1bce5f1cee41da7c42eef5618e4657e3ac..bacb0d6b81bf0946016ae4ac59c1f4ea2b4abb4d 100644 (file)
--- a/docs/ProgrammersManual.html
+++ b/docs/ProgrammersManual.html
@@ -24,6 +24,10 @@
                        <tt>dyn_cast&lt;&gt;</tt> templates</a>
     <li><a href="#DEBUG">The <tt>DEBUG()</tt> macro &amp;
                        <tt>-debug</tt> option</a>
                        <tt>dyn_cast&lt;&gt;</tt> templates</a>
     <li><a href="#DEBUG">The <tt>DEBUG()</tt> macro &amp;
                        <tt>-debug</tt> option</a>
+    <ul>
+      <li><a href="#DEBUG_TYPE">Fine grained debug info with 
+          <tt>DEBUG_TYPE</tt> and the <tt>-debug-only</tt> option</a/>
+    </ul>
     <li><a href="#Statistic">The <tt>Statistic</tt> template &amp;
                        <tt>-stats</tt> option</a>
 <!--
     <li><a href="#Statistic">The <tt>Statistic</tt> template &amp;
                        <tt>-stats</tt> option</a>
 <!--
@@ -45,6 +49,8 @@
                                         pointer</a>
       <li><a href="#iterate_complex">Finding call sites: a more complex
                                         example</a>
                                         pointer</a>
       <li><a href="#iterate_complex">Finding call sites: a more complex
                                         example</a>
+      <li><a href="#calls_and_invokes">Treating calls and invokes the
+                                        same way</a>
       <li><a href="#iterate_chains">Iterating over def-use &amp; use-def
                                     chains</a>
     </ul>
       <li><a href="#iterate_chains">Iterating over def-use &amp; use-def
                                     chains</a>
     </ul>
@@ -160,10 +166,17 @@ library.  There are many good pages that discuss the STL, and several books on
 the subject that you can get, so it will not be discussed in this document.<p>
 
 Here are some useful links:<p>
 the subject that you can get, so it will not be discussed in this document.<p>
 
 Here are some useful links:<p>
+
 <ol>
 <ol>
-<li><a href="http://www.dinkumware.com/htm_cpl/index.html">Dinkumware C++
+<li><a href="http://www.dinkumware.com/refxcpp.html">Dinkumware C++
 Library reference</a> - an excellent reference for the STL and other parts of
 Library reference</a> - an excellent reference for the STL and other parts of
-the standard C++ library.<br>
+the standard C++ library.
+
+<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
+published.
 
 <li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
 Questions</a>
 
 <li><a href="http://www.parashift.com/c++-faq-lite/">C++ Frequently Asked
 Questions</a>
@@ -182,6 +195,20 @@ You are also encouraged to take a look at the <a
 href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
 to write maintainable code more than where to put your curly braces.<p>
 
 href="CodingStandards.html">LLVM Coding Standards</a> guide which focuses on how
 to write maintainable code more than where to put your curly braces.<p>
 
+<!-- ======================================================================= -->
+</ul><table width="100%" bgcolor="#441188" border=0 cellpadding=4 cellspacing=0>
+<tr><td>&nbsp;</td><td width="100%">&nbsp; 
+<font color="#EEEEFF" face="Georgia,Palatino"><b>
+<a name="stl">Other useful references</a>
+</b></font></td></tr></table><ul>
+
+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/~semke/cvs_branches.html">CVS Branch and Tag
+Primer</a></li>
+</ol><p>
 
 <!-- *********************************************************************** -->
 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
 
 <!-- *********************************************************************** -->
 </ul><table width="100%" bgcolor="#330077" border=0 cellpadding=4 cellspacing=0>
@@ -234,7 +261,7 @@ static bool isLoopInvariant(const <a href="#Value">Value</a> *V, const Loop *L)
     return true;
 
   <i>// Otherwise, it must be an instruction...</i>
     return true;
 
   <i>// Otherwise, it must be an instruction...</i>
-  return !L->contains(cast&lt;<a href="#Instruction">Instruction</a>&gt;(V)->getParent());
+  return !L-&gt;contains(cast&lt;<a href="#Instruction">Instruction</a>&gt;(V)-&gt;getParent());
 </pre><p>
 
 Note that you should <b>not</b> use an <tt>isa&lt;&gt;</tt> test followed by a
 </pre><p>
 
 Note that you should <b>not</b> use an <tt>isa&lt;&gt;</tt> test followed by a
@@ -265,8 +292,8 @@ Another common example is:<p>
 
 <pre>
   <i>// Loop over all of the phi nodes in a basic block</i>
 
 <pre>
   <i>// Loop over all of the phi nodes in a basic block</i>
-  BasicBlock::iterator BBI = BB->begin();
-  for (; <a href="#PhiNode">PHINode</a> *PN = dyn_cast&lt;<a href="#PHINode">PHINode</a>&gt;(&amp;*BBI); ++BBI)
+  BasicBlock::iterator BBI = BB-&gt;begin();
+  for (; <a href="#PhiNode">PHINode</a> *PN = dyn_cast&lt;<a href="#PHINode">PHINode</a>&gt;(BBI); ++BBI)
     cerr &lt;&lt; *PN;
 </pre><p>
 
     cerr &lt;&lt; *PN;
 </pre><p>
 
@@ -318,12 +345,11 @@ Naturally, because of this, you don't want to delete the debug printouts, but
 you don't want them to always be noisy.  A standard compromise is to comment
 them out, allowing you to enable them if you need them in the future.<p>
 
 you don't want them to always be noisy.  A standard compromise is to comment
 them out, allowing you to enable them if you need them in the future.<p>
 
-The "<tt><a
-href="/doxygen/StatisticReporter_8h-source.html">StatisticReporter.h</a></tt>"
-file provides a macro named <tt>DEBUG()</tt> that is a much nicer solution to
-this problem.  Basically, you can put arbitrary code into the argument of the
-<tt>DEBUG</tt> macro, and it is only executed if '<tt>opt</tt>' is run with the
-'<tt>-debug</tt>' command line argument:
+The "<tt><a href="/doxygen/Debug_8h-source.html">Support/Debug.h</a></tt>" file
+provides a macro named <tt>DEBUG()</tt> that is a much nicer solution to this
+problem.  Basically, you can put arbitrary code into the argument of the
+<tt>DEBUG</tt> macro, and it is only executed if '<tt>opt</tt>' (or any other
+tool) is run with the '<tt>-debug</tt>' command line argument:
 
 <pre>
      ... 
 
 <pre>
      ... 
@@ -341,10 +367,69 @@ Then you can run your pass like this:<p>
   $
 </pre><p>
 
   $
 </pre><p>
 
-Using the <tt>DEBUG()</tt> macro instead of a home brewed solution allows you to
+Using the <tt>DEBUG()</tt> macro instead of a home-brewed solution allows you to
 now have to create "yet another" command line option for the debug output for
 now have to create "yet another" command line option for the debug output for
-your pass.  Note that <tt>DEBUG()</tt> macros are disabled for optimized
-builds, so they do not cause a performance impact at all.<p>
+your pass.  Note that <tt>DEBUG()</tt> macros are disabled for optimized builds,
+so they do not cause a performance impact at all (for the same reason, they
+should also not contain side-effects!).<p>
+
+One additional nice thing about the <tt>DEBUG()</tt> macro is that you can
+enable or disable it directly in gdb.  Just use "<tt>set DebugFlag=0</tt>" or
+"<tt>set DebugFlag=1</tt>" from the gdb if the program is running.  If the
+program hasn't been started yet, you can always just run it with
+<tt>-debug</tt>.<p>
+
+<!-- _______________________________________________________________________ -->
+</ul><h4><a name="DEBUG_TYPE"><hr size=0>Fine grained debug info with 
+          <tt>DEBUG_TYPE()</tt> and the <tt>-debug-only</tt> option</a> </h4><ul>
+
+Sometimes you may find yourself in a situation where enabling <tt>-debug</tt>
+just turns on <b>too much</b> information (such as when working on the code
+generator).  If you want to enable debug information with more fine-grained
+control, you define the <tt>DEBUG_TYPE</tt> macro and the <tt>-debug</tt> only
+option as follows:<p>
+
+<pre>
+     ...
+     DEBUG(std::cerr &lt;&lt; "No debug type\n");
+     #undef  DEBUG_TYPE
+     #define DEBUG_TYPE "foo"
+     DEBUG(std::cerr &lt;&lt; "'foo' debug type\n");
+     #undef  DEBUG_TYPE
+     #define DEBUG_TYPE "bar"
+     DEBUG(std::cerr &lt;&lt; "'bar' debug type\n");
+     #undef  DEBUG_TYPE
+     #define DEBUG_TYPE ""
+     DEBUG(std::cerr &lt;&lt; "No debug type (2)\n");
+     ...
+</pre><p>
+
+Then you can run your pass like this:<p>
+
+<pre>
+  $ opt &lt; a.bc &gt; /dev/null -mypass
+    &lt;no output&gt;
+  $ opt &lt; a.bc &gt; /dev/null -mypass -debug
+    No debug type
+    'foo' debug type
+    'bar' debug type
+    No debug type (2)
+  $ opt &lt; a.bc &gt; /dev/null -mypass -debug-only=foo
+    'foo' debug type
+  $ opt &lt; a.bc &gt; /dev/null -mypass -debug-only=bar
+    'bar' debug type
+  $
+</pre><p>
+
+Of course, in practice, you should only set <tt>DEBUG_TYPE</tt> at the top of a
+file, to specify the debug type for the entire module (if you do this before you
+<tt>#include "Support/Debug.h"</tt>, you don't have to insert the ugly
+<tt>#undef</tt>'s).  Also, you should use names more meaningful that "foo" and
+"bar", because there is no system in place to ensure that names do not conflict:
+if two different modules use the same string, they will all be turned on when
+the name is specified.  This allows all, say, instruction scheduling, debug
+information to be enabled with <tt>-debug-type=InstrSched</tt>, even if the
+source lives in multiple files.<p>
 
 
 <!-- ======================================================================= -->
 
 
 <!-- ======================================================================= -->
@@ -356,7 +441,7 @@ option</a>
 </b></font></td></tr></table><ul>
 
 The "<tt><a
 </b></font></td></tr></table><ul>
 
 The "<tt><a
-href="/doxygen/StatisticReporter_8h-source.html">StatisticReporter.h</a></tt>"
+href="/doxygen/Statistic_8h-source.html">Support/Statistic.h</a></tt>"
 file provides a template named <tt>Statistic</tt> that is used as a unified way
 to keeping track of what the LLVM compiler is doing and how effective various
 optimizations are.  It is useful to see what optimizations are contributing to
 file provides a template named <tt>Statistic</tt> that is used as a unified way
 to keeping track of what the LLVM compiler is doing and how effective various
 optimizations are.  It is useful to see what optimizations are contributing to
@@ -376,7 +461,7 @@ are as follows:<p>
 <li>Define your statistic like this:<p>
 
 <pre>
 <li>Define your statistic like this:<p>
 
 <pre>
-static Statistic&lt;&gt; NumXForms("mypassname\t- The # of times I did stuff");
+static Statistic&lt;&gt; NumXForms("mypassname", "The # of times I did stuff");
 </pre><p>
 
 The <tt>Statistic</tt> template can emulate just about any data-type, but if you
 </pre><p>
 
 The <tt>Statistic</tt> template can emulate just about any data-type, but if you
@@ -419,7 +504,7 @@ a report that looks like this:<p>
      49 cee             - Number of setcc instruction eliminated
     532 gcse            - Number of loads removed
    2919 gcse            - Number of instructions removed
      49 cee             - Number of setcc instruction eliminated
     532 gcse            - Number of loads removed
    2919 gcse            - Number of instructions removed
-     86 indvars         - Number of cannonical indvars added
+     86 indvars         - Number of canonical indvars added
      87 indvars         - Number of aux indvars removed
      25 instcombine     - Number of dead inst eliminate
     434 instcombine     - Number of insts combined
      87 indvars         - Number of aux indvars removed
      25 instcombine     - Number of dead inst eliminate
     434 instcombine     - Number of insts combined
@@ -492,7 +577,7 @@ contains:
 
 <pre>
   // func is a pointer to a Function instance
 
 <pre>
   // func is a pointer to a Function instance
-  for(Function::iterator i = func->begin(), e = func->end(); i != e; ++i) {
+  for (Function::iterator i = func-&gt;begin(), e = func-&gt;end(); i != e; ++i) {
 
       // print out the name of the basic block if it has one, and then the
       // number of instructions that it contains
 
       // print out the name of the basic block if it has one, and then the
       // number of instructions that it contains
@@ -505,7 +590,7 @@ contains:
 Note that i can be used as if it were a pointer for the purposes of
 invoking member functions of the <tt>Instruction</tt> class.  This is
 because the indirection operator is overloaded for the iterator
 Note that i can be used as if it were a pointer for the purposes of
 invoking member functions of the <tt>Instruction</tt> class.  This is
 because the indirection operator is overloaded for the iterator
-classes.  In the above code, the expression <tt>i->size()</tt> is
+classes.  In the above code, the expression <tt>i-&gt;size()</tt> is
 exactly equivalent to <tt>(*i).size()</tt> just like you'd expect.
 
 <!-- _______________________________________________________________________ -->
 exactly equivalent to <tt>(*i).size()</tt> just like you'd expect.
 
 <!-- _______________________________________________________________________ -->
@@ -520,7 +605,7 @@ that prints out each instruction in a <tt>BasicBlock</tt>:
 
 <pre>
   // blk is a pointer to a BasicBlock instance
 
 <pre>
   // blk is a pointer to a BasicBlock instance
-  for(BasicBlock::iterator i = blk-&gt;begin(), e = blk-&gt;end(); i != e; ++i)
+  for (BasicBlock::iterator i = blk-&gt;begin(), e = blk-&gt;end(); i != e; ++i)
      // the next statement works since operator&lt;&lt;(ostream&amp;,...) 
      // is overloaded for Instruction&amp;
      cerr &lt;&lt; *i &lt;&lt; "\n";
      // the next statement works since operator&lt;&lt;(ostream&amp;,...) 
      // is overloaded for Instruction&amp;
      cerr &lt;&lt; *i &lt;&lt; "\n";
@@ -557,7 +642,7 @@ stderr (<b>Note:</b> Dereferencing an <tt>InstIterator</tt> yields an
 #include "<a href="/doxygen/InstIterator_8h-source.html">llvm/Support/InstIterator.h</a>"
 ...
 // Suppose F is a ptr to a function
 #include "<a href="/doxygen/InstIterator_8h-source.html">llvm/Support/InstIterator.h</a>"
 ...
 // Suppose F is a ptr to a function
-for(inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i)
+for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i)
   cerr &lt;&lt **i &lt;&lt "\n";
 </pre>
 
   cerr &lt;&lt **i &lt;&lt "\n";
 </pre>
 
@@ -604,16 +689,6 @@ is semantically equivalent to
 
 <pre>Instruction* pinst = i;</pre>
 
 
 <pre>Instruction* pinst = i;</pre>
 
-<b>Caveat emptor</b>: The above syntax works <i>only</i> when you're <i>not</i>
-working with <tt>dyn_cast</tt>.  The template definition of <tt><a
-href="#isa">dyn_cast</a></tt> isn't implemented to handle this yet, so you'll
-still need the following in order for things to work properly:
-
-<pre>
-BasicBlock::iterator bbi = ...;
-<a href="#BranchInst">BranchInst</a>* b = <a href="#isa">dyn_cast</a>&lt;<a href="#BranchInst">BranchInst</a>&gt;(&amp;*bbi);
-</pre>
-
 It's also possible to turn a class pointer into the corresponding
 iterator.  Usually, this conversion is quite inexpensive.  The
 following code snippet illustrates use of the conversion constructors
 It's also possible to turn a class pointer into the corresponding
 iterator.  Usually, this conversion is quite inexpensive.  The
 following code snippet illustrates use of the conversion constructors
@@ -625,7 +700,7 @@ over some structure:
 void printNextInstruction(Instruction* inst) {
     BasicBlock::iterator it(inst);
     ++it; // after this line, it refers to the instruction after *inst.
 void printNextInstruction(Instruction* inst) {
     BasicBlock::iterator it(inst);
     ++it; // after this line, it refers to the instruction after *inst.
-    if(it != inst-&gt;getParent()->end()) cerr &lt;&lt; *it &lt;&lt; "\n";
+    if (it != inst-&gt;getParent()-&gt;end()) cerr &lt;&lt; *it &lt;&lt; "\n";
 }
 </pre>
 Of course, this example is strictly pedagogical, because it'd be much
 }
 </pre>
 Of course, this example is strictly pedagogical, because it'd be much
@@ -638,8 +713,8 @@ more complex example </h4><ul>
 
 Say that you're writing a FunctionPass and would like to count all the
 locations in the entire module (that is, across every
 
 Say that you're writing a FunctionPass and would like to count all the
 locations in the entire module (that is, across every
-<tt>Function</tt>) where a certain function (i.e. some
-<tt>Function</tt>*) already in scope.  As you'll learn later, you may
+<tt>Function</tt>) where a certain function (i.e., some
+<tt>Function</tt>*) is already in scope.  As you'll learn later, you may
 want to use an <tt>InstVisitor</tt> to accomplish this in a much more
 straightforward manner, but this example will allow us to explore how
 you'd do it if you didn't have <tt>InstVisitor</tt> around.  In
 want to use an <tt>InstVisitor</tt> to accomplish this in a much more
 straightforward manner, but this example will allow us to explore how
 you'd do it if you didn't have <tt>InstVisitor</tt> around.  In
@@ -650,7 +725,7 @@ initialize callCounter to zero
 for each Function f in the Module
     for each BasicBlock b in f
       for each Instruction i in b
 for each Function f in the Module
     for each BasicBlock b in f
       for each Instruction i in b
-        if(i is a CallInst and calls the given function)
+        if (i is a CallInst and calls the given function)
           increment callCounter
 </pre>
 
           increment callCounter
 </pre>
 
@@ -666,14 +741,14 @@ class OurFunctionPass : public FunctionPass {
     OurFunctionPass(): callCounter(0) { }
 
     virtual runOnFunction(Function&amp; F) {
     OurFunctionPass(): callCounter(0) { }
 
     virtual runOnFunction(Function&amp; F) {
-       for(Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
-           for(BasicBlock::iterator i = b-&gt;begin(); ie = b-&gt;end(); i != ie; ++i) {
+       for (Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
+           for (BasicBlock::iterator i = b-&gt;begin(); ie = b-&gt;end(); i != ie; ++i) {
                if (<a href="#CallInst">CallInst</a>* callInst = <a href="#isa">dyn_cast</a>&lt;<a href="#CallInst">CallInst</a>&gt;(&amp;*i)) {
                    // we know we've encountered a call instruction, so we
                    // need to determine if it's a call to the
                    // function pointed to by m_func or not.
   
                if (<a href="#CallInst">CallInst</a>* callInst = <a href="#isa">dyn_cast</a>&lt;<a href="#CallInst">CallInst</a>&gt;(&amp;*i)) {
                    // we know we've encountered a call instruction, so we
                    // need to determine if it's a call to the
                    // function pointed to by m_func or not.
   
-                   if(callInst-&gt;getCalledFunction() == targetFunc)
+                   if (callInst-&gt;getCalledFunction() == targetFunc)
                        ++callCounter;
            }
        }
                        ++callCounter;
            }
        }
@@ -684,6 +759,31 @@ class OurFunctionPass : public FunctionPass {
 };
 </pre>
 
 };
 </pre>
 
+
+<!--_______________________________________________________________________-->
+</ul><h4><a name="calls_and_invokes"><hr size=0>Treating calls and
+invokes the same way</h4><ul>
+
+<p>You may have noticed that the previous example was a bit
+oversimplified in that it did not deal with call sites generated by
+'invoke' instructions. In this, and in other situations, you may find
+that you want to treat <tt>CallInst</tt>s and <tt>InvokeInst</tt>s the
+same way, even though their 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>.  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>
+
+<p>This class is supposed to have "value semantics". So it should be
+passed by value, not by reference; it should not be dynamically
+allocated or deallocated using <tt>operator new</tt> or <tt>operator
+delete</tt>. It is efficiently copyable, assignable and constructable,
+with costs equivalents to that of a bare pointer. (You will notice, if
+you look at its definition, that it has only a single data member.)</p>
+
+
 <!--_______________________________________________________________________-->
 </ul><h4><a name="iterate_chains"><hr size=0>Iterating over def-use &amp;
 use-def chains</h4><ul>
 <!--_______________________________________________________________________-->
 </ul><h4><a name="iterate_chains"><hr size=0>Iterating over def-use &amp;
 use-def chains</h4><ul>
@@ -701,8 +801,8 @@ all <tt>User</tt>s of a particular <tt>Value</tt> is called a
 <pre>
 Function* F = ...;
 
 <pre>
 Function* F = ...;
 
-for(Value::use_iterator i = F-&gt;use_begin(), e = F-&gt;use_end(); i != e; ++i) {
-    if(Instruction* Inst = dyn_cast&lt;Instruction&gt;(*i)) {
+for (Value::use_iterator i = F-&gt;use_begin(), e = F-&gt;use_end(); i != e; ++i) {
+    if (Instruction *Inst = dyn_cast&lt;Instruction&gt;(*i)) {
         cerr &lt;&lt; "F is used in instruction:\n";
         cerr &lt;&lt; *Inst &lt;&lt; "\n";
     }
         cerr &lt;&lt; "F is used in instruction:\n";
         cerr &lt;&lt; *Inst &lt;&lt; "\n";
     }
@@ -720,7 +820,7 @@ to iterate over all of the values that a particular instruction uses
 <pre>
 Instruction* pi = ...;
 
 <pre>
 Instruction* pi = ...;
 
-for(User::op_iterator i = pi-&gt;op_begin(), e = pi-&gt;op_end(); i != e; ++i) {
+for (User::op_iterator i = pi-&gt;op_begin(), e = pi-&gt;op_end(); i != e; ++i) {
     Value* v = *i;
     ...
 }
     Value* v = *i;
     ...
 }
@@ -803,10 +903,10 @@ that <tt>BasicBlock</tt>, and a newly-created instruction
 we wish to insert before <tt>*pi</tt>, we do the following:
 
 <pre>
 we wish to insert before <tt>*pi</tt>, we do the following:
 
 <pre>
-BasicBlock* pb = ...;
-Instruction* pi = ...;
-Instruction* newInst = new Instruction(...);
-pb->getInstList().insert(pi, newInst); // inserts newInst before pi in pb
+  BasicBlock *pb = ...;
+  Instruction *pi = ...;
+  Instruction *newInst = new Instruction(...);
+  pb-&gt;getInstList().insert(pi, newInst); // inserts newInst before pi in pb
 </pre>
 </p>
 
 </pre>
 </p>
 
@@ -817,9 +917,9 @@ instruction list: the instruction list of the enclosing basic block.
 Thus, we could have accomplished the same thing as the above code
 without being given a <tt>BasicBlock</tt> by doing:
 <pre>
 Thus, we could have accomplished the same thing as the above code
 without being given a <tt>BasicBlock</tt> by doing:
 <pre>
-Instruction* pi = ...;
-Instruction* newInst = new Instruction(...);
-pi->getParent()->getInstList().insert(pi, newInst);
+  Instruction *pi = ...;
+  Instruction *newInst = new Instruction(...);
+  pi-&gt;getParent()-&gt;getInstList().insert(pi, newInst);
 </pre>
 In fact, this sequence of steps occurs so frequently that the
 <tt>Instruction</tt> class and <tt>Instruction</tt>-derived classes
 </pre>
 In fact, this sequence of steps occurs so frequently that the
 <tt>Instruction</tt> class and <tt>Instruction</tt>-derived classes
@@ -866,8 +966,7 @@ For example:<p>
 <p><i>Replacing individual instructions</i></p>
 <p>
 Including "<a
 <p><i>Replacing individual instructions</i></p>
 <p>
 Including "<a
-href="/doxygen/BasicBlockUtils_8h-source.html">llvm/Transforms/Utils/BasicBlockUtils.h
-</a>" permits use of two very useful replace functions:
+href="/doxygen/BasicBlockUtils_8h-source.html">llvm/Transforms/Utils/BasicBlockUtils.h</a>" permits use of two very useful replace functions:
 <tt>ReplaceInstWithValue</tt> and <tt>ReplaceInstWithInst</tt>.  
 
 <ul>
 <tt>ReplaceInstWithValue</tt> and <tt>ReplaceInstWithInst</tt>.  
 
 <ul>
@@ -882,7 +981,8 @@ integer with an null pointer to an integer.</p>
 
 <pre>
 AllocaInst* instToReplace = ...;
 
 <pre>
 AllocaInst* instToReplace = ...;
-ReplaceInstWithValue(*instToReplace-&gt;getParent(), instToReplace,
+BasicBlock::iterator ii(instToReplace);
+ReplaceInstWithValue(instToReplace-&gt;getParent()-&gt;getInstList(), ii,
                      Constant::getNullValue(PointerType::get(Type::IntTy)));
 </pre>
 
                      Constant::getNullValue(PointerType::get(Type::IntTy)));
 </pre>
 
@@ -894,8 +994,9 @@ instruction.  The following example illustrates the replacement of one
 
 <pre>
 AllocaInst* instToReplace = ...;
 
 <pre>
 AllocaInst* instToReplace = ...;
-ReplaceInstWithInst(*instToReplace-&gt;getParent(), instToReplace,
-                    new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt");
+BasicBlock::iterator ii(instToReplace);
+ReplaceInstWithInst(instToReplace-&gt;getParent()-&gt;getInstList(), ii,
+                    new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt"));
 </pre>
 
 </ul>
 </pre>
 
 </ul>
@@ -1121,9 +1222,9 @@ the <tt>Instruction</tt> class</h4><ul>
 Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
 <tt>Instruction</tt> is embedded into.<p>
 
 Returns the <a href="#BasicBlock"><tt>BasicBlock</tt></a> that this
 <tt>Instruction</tt> is embedded into.<p>
 
-<li><tt>bool hasSideEffects()</tt><p>
+<li><tt>bool mayWriteToMemory()</tt><p>
 
 
-Returns true if the instruction has side effects, i.e. it is a <tt>call</tt>,
+Returns true if the instruction writes to memory, i.e. it is a <tt>call</tt>,
 <tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
 
 <li><tt>unsigned getOpcode()</tt><p>
 <tt>free</tt>, <tt>invoke</tt>, or <tt>store</tt>.<p>
 
 <li><tt>unsigned getOpcode()</tt><p>
@@ -1171,7 +1272,7 @@ into a <a href="#BasicBlock"><tt>BasicBlock</tt></a>), and it has no name.<p>
        \end{itemize}
 <li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
        \begin{itemize}
        \end{itemize}
 <li>LoadInst, StoreInst, GetElemPtrInst : These subclasses represent load, store and getelementptr instructions in LLVM.
        \begin{itemize}
-       <li><tt>Value * getPointerOperand ()</tt>: Returns the Pointer Operand which is typically the 0th operand.
+       <li><tt>Value * getPointerOperand()</tt>: Returns the Pointer Operand which is typically the 0th operand.
        \end{itemize}
 <li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
        \begin{itemize}
        \end{itemize}
 <li>BranchInst : This is a subclass of TerminatorInst and defines the interface for conditional and unconditional branches in LLVM.
        \begin{itemize}
@@ -1393,7 +1494,7 @@ list.<p>
 <li><tt>Function::BasicBlockListType &amp;getBasicBlockList()</tt><p>
 
 Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.  This is
 <li><tt>Function::BasicBlockListType &amp;getBasicBlockList()</tt><p>
 
 Returns the list of <a href="#BasicBlock"><tt>BasicBlock</tt></a>s.  This is
-neccesary to use when you need to update the list or perform a complex action
+necessary to use when you need to update the list or perform a complex action
 that doesn't have a forwarding method.<p>
 
 
 that doesn't have a forwarding method.<p>
 
 
@@ -1408,12 +1509,12 @@ These are forwarding methods that make it easy to access the contents of a
 <li><tt>Function::ArgumentListType &amp;getArgumentList()</tt><p>
 
 Returns the list of <a href="#Argument"><tt>Argument</tt></a>s.  This is
 <li><tt>Function::ArgumentListType &amp;getArgumentList()</tt><p>
 
 Returns the list of <a href="#Argument"><tt>Argument</tt></a>s.  This is
-neccesary to use when you need to update the list or perform a complex action
+necessary to use when you need to update the list or perform a complex action
 that doesn't have a forwarding method.<p>
 
 
 
 that doesn't have a forwarding method.<p>
 
 
 
-<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryNode()</tt><p>
+<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntryBlock()</tt><p>
 
 Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
 function.  Because the entry block for the function is always the first block,
 
 Returns the entry <a href="#BasicBlock"><tt>BasicBlock</tt></a> for the
 function.  Because the entry block for the function is always the first block,
@@ -1426,26 +1527,10 @@ This traverses the <a href="#Type"><tt>Type</tt></a> of the <tt>Function</tt>
 and returns the return type of the function, or the <a
 href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
 
 and returns the return type of the function, or the <a
 href="#FunctionType"><tt>FunctionType</tt></a> of the actual function.<p>
 
-
-<li><tt>bool hasSymbolTable() const</tt><p>
-
-Return true if the <tt>Function</tt> has a symbol table allocated to it and if
-there is at least one entry in it.<p>
-
 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 
 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 
 Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
-<tt>Function</tt> or a null pointer if one has not been allocated (because there
-are no named values in the function).<p>
-
-<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
-
-Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
-<tt>Function</tt> or allocate a new <a
-href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around.  This
-should only be used when adding elements to the <a
-href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
-not left laying around.<p>
+<tt>Function</tt>.<p>
 
 
 
 
 
 
@@ -1540,7 +1625,7 @@ list.<p>
 <li><tt>Module::FunctionListType &amp;getFunctionList()</tt><p>
 
 Returns the list of <a href="#Function"><tt>Function</tt></a>s.  This is
 <li><tt>Module::FunctionListType &amp;getFunctionList()</tt><p>
 
 Returns the list of <a href="#Function"><tt>Function</tt></a>s.  This is
-neccesary to use when you need to update the list or perform a complex action
+necessary to use when you need to update the list or perform a complex action
 that doesn't have a forwarding method.<p>
 
 <!--  Global Variable -->
 that doesn't have a forwarding method.<p>
 
 <!--  Global Variable -->
@@ -1558,32 +1643,17 @@ list.<p>
 <li><tt>Module::GlobalListType &amp;getGlobalList()</tt><p>
 
 Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
 <li><tt>Module::GlobalListType &amp;getGlobalList()</tt><p>
 
 Returns the list of <a href="#GlobalVariable"><tt>GlobalVariable</tt></a>s.
-This is neccesary to use when you need to update the list or perform a complex
+This is necessary to use when you need to update the list or perform a complex
 action that doesn't have a forwarding method.<p>
 
 
 <!--  Symbol table stuff -->
 <hr size=0>
 
 action that doesn't have a forwarding method.<p>
 
 
 <!--  Symbol table stuff -->
 <hr size=0>
 
-<li><tt>bool hasSymbolTable() const</tt><p>
-
-Return true if the <tt>Module</tt> has a symbol table allocated to it and if
-there is at least one entry in it.<p>
-
 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 
 <li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTable()</tt><p>
 
-Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
-<tt>Module</tt> or a null pointer if one has not been allocated (because there
-are no named values in the function).<p>
-
-<li><tt><a href="#SymbolTable">SymbolTable</a> *getSymbolTableSure()</tt><p>
-
-Return a pointer to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for this
-<tt>Module</tt> or allocate a new <a
-href="#SymbolTable"><tt>SymbolTable</tt></a> if one is not already around.  This
-should only be used when adding elements to the <a
-href="#SymbolTable"><tt>SymbolTable</tt></a>, so that empty symbol tables are
-not left laying around.<p>
+Return a reference to the <a href="#SymbolTable"><tt>SymbolTable</tt></a> for
+this <tt>Module</tt>.<p>
 
 
 <!--  Convenience methods -->
 
 
 <!--  Convenience methods -->
@@ -1639,39 +1709,39 @@ ConstantArray etc for representing the various types of Constants.<p>
 <li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
 
 
 <li><tt>bool isConstantExpr()</tt>: Returns true if it is a ConstantExpr
 
 
+<hr>
+Important Subclasses of Constant<p>
 
 
-
-\subsection{Important Subclasses of Constant}
-\begin{itemize}
+<ul>
 <li>ConstantSInt : This subclass of Constant represents a signed integer constant.
 <li>ConstantSInt : This subclass of Constant represents a signed integer constant.
-       \begin{itemize}
-       <li><tt>int64_t getValue () const</tt>: Returns the underlying value of this constant.
-       \end{itemize}
+<ul>
+       <li><tt>int64_t getValue() const</tt>: Returns the underlying value of this constant.
+</ul>
 <li>ConstantUInt : This class represents an unsigned integer.
 <li>ConstantUInt : This class represents an unsigned integer.
-       \begin{itemize}
-       <li><tt>uint64_t getValue () const</tt>: Returns the underlying value of this constant.
-       \end{itemize}
+<ul>
+       <li><tt>uint64_t getValue() const</tt>: Returns the underlying value of this constant.
+</ul>
 <li>ConstantFP : This class represents a floating point constant.
 <li>ConstantFP : This class represents a floating point constant.
-       \begin{itemize}
-       <li><tt>double getValue () const</tt>: Returns the underlying value of this constant.
-       \end{itemize}
+<ul>
+       <li><tt>double getValue() const</tt>: Returns the underlying value of this constant.
+</ul>
 <li>ConstantBool : This represents a boolean constant.
 <li>ConstantBool : This represents a boolean constant.
-       \begin{itemize}
-       <li><tt>bool getValue () const</tt>: Returns the underlying value of this constant.
-       \end{itemize}
+<ul>
+       <li><tt>bool getValue() const</tt>: Returns the underlying value of this constant.
+</ul>
 <li>ConstantArray : This represents a constant array.
 <li>ConstantArray : This represents a constant array.
-       \begin{itemize}
-       <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
-       \end{itemize}
+<ul>
+       <li><tt>const std::vector&lt;Use&gt; &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
+</ul>
 <li>ConstantStruct : This represents a constant struct.
 <li>ConstantStruct : This represents a constant struct.
-       \begin{itemize}
-       <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
-       \end{itemize}
+<ul>
+       <li><tt>const std::vector&lt;Use&gt; &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
+</ul>
 <li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
 <li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
-       \begin{itemize}
+<ul>
 <li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
 <li><tt>GlobalValue *getValue()</tt>: Returns the global value to which this pointer is pointing to.
-       \end{itemize}
-\end{itemize}
+</ul>
+</ul>
 
 
 <!-- ======================================================================= -->
 
 
 <!-- ======================================================================= -->
@@ -1692,45 +1762,48 @@ of any type structure at a time. This allows using pointer equality of Type *s f
 <!-- _______________________________________________________________________ -->
 </ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
 
 <!-- _______________________________________________________________________ -->
 </ul><h4><a name="m_Value"><hr size=0>Important Public Methods</h4><ul>
 
-<li><tt>PrimitiveID getPrimitiveID () const</tt>: Returns the base type of the type.
-<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.
-<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. 
-<li><tt> bool isInteger () const</tt>: Equilivent to isSigned() || isUnsigned(), but with only a single virtual function invocation. 
-<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><tt>PrimitiveID getPrimitiveID() const</tt>: Returns the base type of the type.
+<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.
+<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. 
+<li><tt> bool isInteger() const</tt>: Equilivent to isSigned() || isUnsigned(), but with only a single virtual function invocation. 
+<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><tt>bool isFloatingPoint ()</tt>: Return true if this is one of the two floating point types.
-<li><tt>bool isRecursive () const</tt>: Returns rue if the type graph contains a cycle.
+<li><tt>bool isFloatingPoint()</tt>: Return true if this is one of the two floating point types.
+<li><tt>bool isRecursive() const</tt>: Returns rue if the type graph contains a cycle.
 <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.
 <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.
-<li><tt>bool isPrimitiveType () const</tt>: Returns true if it is a primitive type.
-<li><tt>bool isDerivedType () const</tt>: Returns true if it is a derived type.
+<li><tt>bool isPrimitiveType() const</tt>: Returns true if it is a primitive type.
+<li><tt>bool isDerivedType() const</tt>: Returns true if it is a derived type.
 <li><tt>const Type * getContainedType (unsigned i) const</tt>: 
 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.
 <li><tt>const Type * getContainedType (unsigned i) const</tt>: 
 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.
-<li><tt>unsigned getNumContainedTypes () const</tt>: Return the number of types in the derived type. 
+<li><tt>unsigned getNumContainedTypes() const</tt>: Return the number of types in the derived type. 
 
 
+<p>
 
 
+<hr>
+Derived Types<p>
 
 
-\subsection{Derived Types} 
-\begin{itemize}
+<ul>
 <li>SequentialType : This is subclassed by ArrayType and PointerType 
 <li>SequentialType : This is subclassed by ArrayType and PointerType 
-       \begin{itemize}
-       <li><tt>const Type * getElementType () const</tt>: Returns the type of each of the elements in the sequential type.
-       \end{itemize}
+<ul>
+       <li><tt>const Type * getElementType() const</tt>: Returns the type of each of the elements in the sequential type.
+</ul>
 <li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
 <li>ArrayType : This is a subclass of SequentialType and defines interface for array types.
-       \begin{itemize}
-       <li><tt>unsigned getNumElements () const</tt>: Returns the number of elements in the array.
-       \end{itemize}
+<ul>
+       <li><tt>unsigned getNumElements() const</tt>: Returns the number of elements in the array.
+</ul>
 <li>PointerType : Subclass of SequentialType for  pointer types.
 <li>StructType : subclass of DerivedTypes for struct types
 <li>FunctionType : subclass of DerivedTypes for function types.
 <li>PointerType : Subclass of SequentialType for  pointer types.
 <li>StructType : subclass of DerivedTypes for struct types
 <li>FunctionType : subclass of DerivedTypes for function types.
-       \begin{itemize}
+
+<ul>
        
        
-       <li><tt>bool isVarArg () const</tt>: Returns true if its a vararg function
-       <li><tt> const Type * getReturnType () const</tt>: Returns the return type of the function.
-       <li><tt> const ParamTypes &amp;getParamTypes () const</tt>: Returns a vector of parameter types.
+       <li><tt>bool isVarArg() const</tt>: Returns true if its a vararg function
+       <li><tt> const Type * getReturnType() const</tt>: Returns the return type of the function.
+       <li><tt> const ParamTypes &amp;getParamTypes() const</tt>: Returns a vector of parameter types.
        <li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
        <li><tt>const Type * getParamType (unsigned i)</tt>: Returns the type of the ith parameter.
-       <li><tt> const unsigned getNumParams () const</tt>: Returns the number of formal parameters.
-       \end{itemize}
-\end{itemize}
+       <li><tt> const unsigned getNumParams() const</tt>: Returns the number of formal parameters.
+</ul>
+</ul>
 
 
 
 
 
 
@@ -1756,8 +1829,10 @@ pointer to the parent Function.
 <hr><font size-1>
 <address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
 <a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
 <hr><font size-1>
 <address>By: <a href="mailto:dhurjati@cs.uiuc.edu">Dinakar Dhurjati</a> and
 <a href="mailto:sabre@nondot.org">Chris Lattner</a></address>
+<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a>
+<br>
 <!-- Created: Tue Aug  6 15:00:33 CDT 2002 -->
 <!-- hhmts start -->
 <!-- Created: Tue Aug  6 15:00:33 CDT 2002 -->
 <!-- hhmts start -->
-Last modified: Sun Sep 22 14:38:05 CDT 2002
+Last modified: Fri Nov  7 13:24:22 CST 2003
 <!-- hhmts end -->
 </font></body></html>
 <!-- hhmts end -->
 </font></body></html>
C/C++ LLVM-based compilers that forbids OOTA behaviors