If only have function profile, don't print out "not executed" for all of the blocks :)

[oota-llvm.git] / docs / ProgrammersManual.html

diff --git a/docs/ProgrammersManual.html b/docs/ProgrammersManual.html
index d07fc4cd3e1a998f88051665360c93b46cb2d106..61fc213190b912d66393cb92a7a2815ae7accb3f 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>
 <!--


@@ -240,7 +244,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


@@ -271,8 +275,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>
 


@@ -324,12 +328,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/Statistic_8h-source.html">Support/Statistic.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>
      ... 


@@ -347,10 +350,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>

 
 
 <!-- ======================================================================= -->
 
 
 <!-- ======================================================================= -->


@@ -425,7 +487,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


@@ -498,7 +560,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


@@ -511,7 +573,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.
 
 <!-- _______________________________________________________________________ -->


@@ -526,7 +588,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";


@@ -563,7 +625,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>
 


@@ -610,16 +672,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


@@ -631,7 +683,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


@@ -644,8 +696,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


@@ -656,7 +708,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>
 


@@ -672,14 +724,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;
            }
        }


@@ -707,8 +759,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";
     }


@@ -726,7 +778,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;
     ...
 }


@@ -809,10 +861,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>
 


@@ -823,9 +875,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


@@ -872,8 +924,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>


@@ -903,7 +954,7 @@ instruction.  The following example illustrates the replacement of one
 AllocaInst* instToReplace = ...;
 BasicBlock::iterator ii(instToReplace);
 ReplaceInstWithInst(instToReplace-&gt;getParent()-&gt;getInstList(), ii,
 AllocaInst* instToReplace = ...;
 BasicBlock::iterator ii(instToReplace);
 ReplaceInstWithInst(instToReplace-&gt;getParent()-&gt;getInstList(), ii,

-                    new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt");
+                    new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt"));

 </pre>
 
 </ul>
 </pre>
 
 </ul>


@@ -1129,9 +1180,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>


@@ -1401,7 +1452,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>
 
 


@@ -1416,12 +1467,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,


@@ -1434,26 +1485,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>

 
 
 
 
 
 


@@ -1548,7 +1583,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 -->


@@ -1566,32 +1601,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 -->


@@ -1669,11 +1689,11 @@ Important Subclasses of Constant<p>
 </ul>
 <li>ConstantArray : This represents a constant array.
 <ul>
 </ul>
 <li>ConstantArray : This represents a constant array.
 <ul>

-       <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
+       <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.
 <ul>
 </ul>
 <li>ConstantStruct : This represents a constant struct.
 <ul>

-       <li><tt>const std::vector<Use> &amp;getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
+       <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.
 <ul>
 </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.
 <ul>


@@ -1767,8 +1787,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 Oct 20 21:37:06 CDT 2002
+Last modified: Mon Oct 27 12:00:00 CDT 2003

 <!-- hhmts end -->
 </font></body></html>
 <!-- hhmts end -->
 </font></body></html>