<tt>dyn_cast<></tt> templates</a>
<li><a href="#DEBUG">The <tt>DEBUG()</tt> macro &
<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 &
<tt>-stats</tt> option</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 & use-def
chains</a>
</ul>
the subject that you can get, so it will not be discussed in this document.<p>
Here are some useful links:<p>
+
<ol>
<li><a href="http://www.dinkumware.com/refxcpp.html">Dinkumware C++
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>
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> </td><td width="100%">
+<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>
return true;
<i>// Otherwise, it must be an instruction...</i>
- return !L->contains(cast<<a href="#Instruction">Instruction</a>>(V)->getParent());
+ return !L->contains(cast<<a href="#Instruction">Instruction</a>>(V)->getParent());
</pre><p>
Note that you should <b>not</b> use an <tt>isa<></tt> test followed by a
<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<<a href="#PHINode">PHINode</a>>(&*BBI); ++BBI)
+ BasicBlock::iterator BBI = BB->begin();
+ for (; <a href="#PhiNode">PHINode</a> *PN = dyn_cast<<a href="#PHINode">PHINode</a>>(BBI); ++BBI)
cerr << *PN;
</pre><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><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
-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 << "No debug type\n");
+ #undef DEBUG_TYPE
+ #define DEBUG_TYPE "foo"
+ DEBUG(std::cerr << "'foo' debug type\n");
+ #undef DEBUG_TYPE
+ #define DEBUG_TYPE "bar"
+ DEBUG(std::cerr << "'bar' debug type\n");
+ #undef DEBUG_TYPE
+ #define DEBUG_TYPE ""
+ DEBUG(std::cerr << "No debug type (2)\n");
+ ...
+</pre><p>
+
+Then you can run your pass like this:<p>
+
+<pre>
+ $ opt < a.bc > /dev/null -mypass
+ <no output>
+ $ opt < a.bc > /dev/null -mypass -debug
+ No debug type
+ 'foo' debug type
+ 'bar' debug type
+ No debug type (2)
+ $ opt < a.bc > /dev/null -mypass -debug-only=foo
+ 'foo' debug type
+ $ opt < a.bc > /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>
<!-- ======================================================================= -->
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
<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->begin(), e = func->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
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->size()</tt> is
exactly equivalent to <tt>(*i).size()</tt> just like you'd expect.
<!-- _______________________________________________________________________ -->
<pre>
// blk is a pointer to a BasicBlock instance
- for(BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i)
+ for (BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i)
// the next statement works since operator<<(ostream&,...)
// is overloaded for Instruction&
cerr << *i << "\n";
#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 << **i << "\n";
</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><<a href="#BranchInst">BranchInst</a>>(&*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
void printNextInstruction(Instruction* inst) {
BasicBlock::iterator it(inst);
++it; // after this line, it refers to the instruction after *inst.
- if(it != inst->getParent()->end()) cerr << *it << "\n";
+ if (it != inst->getParent()->end()) cerr << *it << "\n";
}
</pre>
Of course, this example is strictly pedagogical, because it'd be much
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
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>
OurFunctionPass(): callCounter(0) { }
virtual runOnFunction(Function& F) {
- for(Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
- for(BasicBlock::iterator i = b->begin(); ie = b->end(); i != ie; ++i) {
+ for (Function::iterator b = F.begin(), be = F.end(); b != be; ++b) {
+ for (BasicBlock::iterator i = b->begin(); ie = b->end(); i != ie; ++i) {
if (<a href="#CallInst">CallInst</a>* callInst = <a href="#isa">dyn_cast</a><<a href="#CallInst">CallInst</a>>(&*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->getCalledFunction() == targetFunc)
+ if (callInst->getCalledFunction() == targetFunc)
++callCounter;
}
}
};
</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 &
use-def chains</h4><ul>
<pre>
Function* F = ...;
-for(Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) {
- if(Instruction* Inst = dyn_cast<Instruction>(*i)) {
+for (Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) {
+ if (Instruction *Inst = dyn_cast<Instruction>(*i)) {
cerr << "F is used in instruction:\n";
cerr << *Inst << "\n";
}
<pre>
Instruction* pi = ...;
-for(User::op_iterator i = pi->op_begin(), e = pi->op_end(); i != e; ++i) {
+for (User::op_iterator i = pi->op_begin(), e = pi->op_end(); i != e; ++i) {
Value* v = *i;
...
}
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->getInstList().insert(pi, newInst); // inserts newInst before pi in pb
</pre>
</p>
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->getParent()->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
<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>
AllocaInst* instToReplace = ...;
BasicBlock::iterator ii(instToReplace);
ReplaceInstWithInst(instToReplace->getParent()->getInstList(), ii,
- new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt");
+ new AllocaInst(Type::IntTy, 0, "ptrToReplacedInt"));
</pre>
</ul>
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>
<li><tt>Function::BasicBlockListType &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>
<li><tt>Function::ArgumentListType &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>
-<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntry
Node()</tt><p>
+<li><tt><a href="#BasicBlock">BasicBlock</a> &getEntry
Block()</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,
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
-<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>
<li><tt>Module::FunctionListType &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 -->
<li><tt>Module::GlobalListType &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>
-<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>
-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 -->
</ul>
<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><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array.
</ul>
<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><tt>const std::vector<Use> &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>
<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 -->
-Last modified: Tue Oct 1 18:15:43 CDT 2002
+Last modified: Fri Nov 7 13:24:22 CST 2003
<!-- hhmts end -->
</font></body></html>
projects / oota-llvm.git / blobdiff