<li><a href="#AU::addRequired">The <tt>AnalysisUsage::addRequired<></tt> and <tt>AnalysisUsage::addRequiredTransitive<></tt> methods</a></li>
<li><a href="#AU::addPreserved">The <tt>AnalysisUsage::addPreserved<></tt> method</a></li>
<li><a href="#AU::examples">Example implementations of <tt>getAnalysisUsage</tt></a></li>
- <li><a href="#getAnalysis">The <tt>getAnalysis<></tt> and <tt>getAnalysisToUpdate<></tt> methods</a></li>
+ <li><a href="#getAnalysis">The <tt>getAnalysis<></tt> and
+<tt>getAnalysisIfAvailable<></tt> methods</a></li>
</ul></li>
<li><a href="#analysisgroup">Implementing Analysis Groups</a>
<ul>
<div class="doc_code"><pre>
# Makefile for hello pass
-# Path to top level of LLVM heirarchy
+# Path to top level of LLVM hierarchy
LEVEL = ../../..
# Name of the library to build
<div class="doc_code"><pre>
<b>#include</b> "<a href="http://llvm.org/doxygen/Pass_8h-source.html">llvm/Pass.h</a>"
<b>#include</b> "<a href="http://llvm.org/doxygen/Function_8h-source.html">llvm/Function.h</a>"
+<b>#include</b> "<a href="http://llvm.org/doxygen/raw__ostream_8h.html">llvm/Support/raw_ostream.h</a>"
</pre></div>
<p>Which are needed because we are writing a <tt><a
-href="http://llvm.org/doxygen/classllvm_1_1Pass.html">Pass</a></tt>, and
+href="http://llvm.org/doxygen/classllvm_1_1Pass.html">Pass</a></tt>,
we are operating on <tt><a
-href="http://llvm.org/doxygen/classllvm_1_1Function.html">Function</a></tt>'s.</p>
+href="http://llvm.org/doxygen/classllvm_1_1Function.html">Function</a></tt>'s,
+and we will be doing some printing.</p>
<p>Next we have:</p>
<div class="doc_code"><pre>
time.</p>
<div class="doc_code"><pre>
- static const int ID;
- Hello() : FunctionPass((intptr_t)&ID) {}
+ static char ID;
+ Hello() : FunctionPass(&ID) {}
</pre></div><p>
<p> This declares pass identifier used by LLVM to identify pass. This allows LLVM to
<div class="doc_code"><pre>
<b>virtual bool</b> <a href="#runOnFunction">runOnFunction</a>(Function &F) {
- llvm::cerr << "<i>Hello: </i>" << F.getName() << "\n";
+ errs() << "<i>Hello: </i>" << F.getName() << "\n";
<b>return false</b>;
}
}; <i>// end of struct Hello</i>
function.</p>
<div class="doc_code"><pre>
- const int Hello::ID = 0;
+ char Hello::ID = 0;
</pre></div>
<p> We initialize pass ID here. LLVM uses ID's address to identify pass so
initialization value is not important.</p>
<div class="doc_code"><pre>
- RegisterPass<Hello> X("<i>hello</i>", "<i>Hello World Pass</i>");
+ RegisterPass<Hello> X("<i>hello</i>", "<i>Hello World Pass</i>",
+ false /* Only looks at CFG */,
+ false /* Analysis Pass */);
} <i>// end of anonymous namespace</i>
</pre></div>
<p>Lastly, we <a href="#registration">register our class</a> <tt>Hello</tt>,
giving it a command line
-argument "<tt>hello</tt>", and a name "<tt>Hello World Pass</tt>".</p>
+argument "<tt>hello</tt>", and a name "<tt>Hello World Pass</tt>".
+Last two RegisterPass arguments are optional. Their default value is false.
+If a pass walks CFG without modifying it then third argument is set to true.
+If a pass is an analysis pass, for example dominator tree pass, then true
+is supplied as fourth argument. </p>
<p>As a whole, the <tt>.cpp</tt> file looks like:</p>
<div class="doc_code"><pre>
<b>#include</b> "<a href="http://llvm.org/doxygen/Pass_8h-source.html">llvm/Pass.h</a>"
<b>#include</b> "<a href="http://llvm.org/doxygen/Function_8h-source.html">llvm/Function.h</a>"
+<b>#include</b> "<a href="http://llvm.org/doxygen/raw__ostream_8h.html">llvm/Support/raw_ostream.h</a>"
<b>using namespace llvm;</b>
<b>namespace</b> {
<b>struct Hello</b> : <b>public</b> <a href="#FunctionPass">FunctionPass</a> {
- static const int ID;
- Hello() : FunctionPass((intptr_t)&ID) {}
+ static char ID;
+ Hello() : FunctionPass(&ID) {}
<b>virtual bool</b> <a href="#runOnFunction">runOnFunction</a>(Function &F) {
- llvm::cerr << "<i>Hello: </i>" << F.getName() << "\n";
+ errs() << "<i>Hello: </i>" << F.getName() << "\n";
<b>return false</b>;
}
};
+ char Hello::ID = 0;
RegisterPass<Hello> X("<i>hello</i>", "<i>Hello World Pass</i>");
}
</pre></div>
<p>To test it, follow the example at the end of the <a
href="GettingStarted.html">Getting Started Guide</a> to compile "Hello World" to
-LLVM. We can now run the bytecode file (<tt>hello.bc</tt>) for the program
-through our transformation like this (or course, any bytecode file will
+LLVM. We can now run the bitcode file (<tt>hello.bc</tt>) for the program
+through our transformation like this (or course, any bitcode file will
work):</p>
<div class="doc_code"><pre>
<tt>/dev/null</tt>).</p>
<p>To see what happened to the other string you registered, try running
-<tt>opt</tt> with the <tt>--help</tt> option:</p>
+<tt>opt</tt> with the <tt>-help</tt> option:</p>
<div class="doc_code"><pre>
-$ opt -load ../../../Debug/lib/Hello.so --help
+$ opt -load ../../../Debug/lib/Hello.so -help
OVERVIEW: llvm .bc -> .bc modular optimizer
-USAGE: opt [options] <input bytecode>
+USAGE: opt [options] <input bitcode>
OPTIONS:
Optimizations available:
Total Execution Time: 0.02 seconds (0.0479059 wall clock)
---User Time--- --System Time-- --User+System-- ---Wall Time--- --- Pass Name ---
- 0.0100 (100.0%) 0.0000 ( 0.0%) 0.0100 ( 50.0%) 0.0402 ( 84.0%) Bytecode Writer
+ 0.0100 (100.0%) 0.0000 ( 0.0%) 0.0100 ( 50.0%) 0.0402 ( 84.0%) Bitcode Writer
0.0000 ( 0.0%) 0.0100 (100.0%) 0.0100 ( 50.0%) 0.0031 ( 6.4%) Dominator Set Construction
0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0013 ( 2.7%) Module Verifier
<b> 0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0000 ( 0.0%) 0.0033 ( 6.9%) Hello World Pass</b>
<p>When choosing a superclass for your Pass, you should choose the <b>most
specific</b> class possible, while still being able to meet the requirements
listed. This gives the LLVM Pass Infrastructure information necessary to
-optimize how passes are run, so that the resultant compiler isn't unneccesarily
+optimize how passes are run, so that the resultant compiler isn't unnecessarily
slow.</p>
</div>
href="http://llvm.org/doxygen/classllvm_1_1ModulePass.html">ModulePass</a></tt>"
class is the most general of all superclasses that you can use. Deriving from
<tt>ModulePass</tt> indicates that your pass uses the entire program as a unit,
-refering to function bodies in no predictable order, or adding and removing
+referring to function bodies in no predictable order, or adding and removing
functions. Because nothing is known about the behavior of <tt>ModulePass</tt>
-subclasses, no optimization can be done for their execution. A module pass
-can use function level passes (e.g. dominators) using getAnalysis interface
-<tt> getAnalysis<DominatorTree>(Function)</tt>. </p>
+subclasses, no optimization can be done for their execution.</p>
+
+<p>A module pass can use function level passes (e.g. dominators) using
+the getAnalysis interface
+<tt>getAnalysis<DominatorTree>(llvm::Function *)</tt> to provide the
+function to retrieve analysis result for, if the function pass does not require
+any module or immutable passes. Note that this can only be done for functions for which the
+analysis ran, e.g. in the case of dominators you should only ask for the
+DominatorTree for function definitions, not declarations.</p>
<p>To write a correct <tt>ModulePass</tt> subclass, derive from
<tt>ModulePass</tt> and overload the <tt>runOnModule</tt> method with the
<li>... <em>not allowed</em> to modify any <tt>Function</tt>s that are not in
the current SCC.</li>
-<li>... <em>allowed</em> to inspect any Function's other than those in the
+<li>... <em>not allowed</em> to inspect any Function's other than those in the
current SCC and the direct callees of the SCC.</li>
<li>... <em>required</em> to preserve the current CallGraph object, updating it
<b>virtual bool</b> doInitialization(Loop *, LPPassManager &LPM);
</pre></div>
-The <tt>doInitialization</tt> method is designed to do simple initialization
+<p>The <tt>doInitialization</tt> method is designed to do simple initialization
type of stuff that does not depend on the functions being processed. The
<tt>doInitialization</tt> method call is not scheduled to overlap with any
other pass executions (thus it should be very fast). LPPassManager
parameters. The first parameter is the name of the pass that is to be used on
the command line to specify that the pass should be added to a program (for
example, with <tt>opt</tt> or <tt>bugpoint</tt>). The second argument is the
-name of the pass, which is to be used for the <tt>--help</tt> output of
+name of the pass, which is to be used for the <tt>-help</tt> output of
programs, as
well as for debug output generated by the <tt>--debug-pass</tt> option.</p>
<div class="doc_text">
<div class="doc_code"><pre>
- <b>virtual void</b> print(llvm::OStream &O, <b>const</b> Module *M) <b>const</b>;
+ <b>virtual void</b> print(std::ostream &O, <b>const</b> Module *M) <b>const</b>;
</pre></div>
<p>The <tt>print</tt> method must be implemented by "analyses" in order to print
<div class="doc_text">
-<p>One of the main responsibilities of the <tt>PassManager</tt> is the make sure
+<p>One of the main responsibilities of the <tt>PassManager</tt> is to make sure
that passes interact with each other correctly. Because <tt>PassManager</tt>
tries to <a href="#passmanager">optimize the execution of passes</a> it must
know how the passes interact with each other and what dependencies exist between
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection">
- <a name="getAnalysis">The <tt>getAnalysis<></tt> and <tt>getAnalysisToUpdate<></tt> methods</a>
+ <a name="getAnalysis">The <tt>getAnalysis<></tt> and
+<tt>getAnalysisIfAvailable<></tt> methods</a>
</div>
<div class="doc_text">
}
</pre></div>
-In above example, runOnFunction for DominatorTree is called by pass manager
+<p>In above example, runOnFunction for DominatorTree is called by pass manager
before returning a reference to the desired pass.</p>
<p>
If your pass is capable of updating analyses if they exist (e.g.,
<tt>BreakCriticalEdges</tt>, as described above), you can use the
-<tt>getAnalysisToUpdate</tt> method, which returns a pointer to the analysis if
-it is active. For example:</p>
+<tt>getAnalysisIfAvailable</tt> method, which returns a pointer to the analysis
+if it is active. For example:</p>
<div class="doc_code"><pre>
...
- if (DominatorSet *DS = getAnalysisToUpdate<DominatorSet>()) {
+ if (DominatorSet *DS = getAnalysisIfAvailable<DominatorSet>()) {
<i>// A DominatorSet is active. This code will update it.</i>
}
...
<div class="doc_text">
-<p>Now that we understand the basics of how passes are defined, how the are
+<p>Now that we understand the basics of how passes are defined, how they are
used, and how they are required from other passes, it's time to get a little bit
fancier. All of the pass relationships that we have seen so far are very
simple: one pass depends on one other specific pass to be run before it can run.
<p>Here we show how the default implementation is specified (using the extra
argument to the <tt>RegisterAnalysisGroup</tt> template). There must be exactly
one default implementation available at all times for an Analysis Group to be
-used. Here we declare that the <tt><a
-href="http://llvm.org/doxygen/structBasicAliasAnalysis.html">BasicAliasAnalysis</a></tt>
+used. Only default implementation can derive from <tt>ImmutablePass</tt>.
+Here we declare that the
+ <tt><a href="http://llvm.org/doxygen/structBasicAliasAnalysis.html">BasicAliasAnalysis</a></tt>
pass is the default implementation for the interface.</p>
</div>
traversing the entire program. It reduces the memory consumption of compiler,
because, for example, only one <a
href="http://llvm.org/doxygen/classllvm_1_1DominatorSet.html"><tt>DominatorSet</tt></a>
-needs to be calculated at a time. This also makes it possible some <a
+needs to be calculated at a time. This also makes it possible to implement
+some <a
href="#SMP">interesting enhancements</a> in the future.</p></li>
</ol>
options that is useful for debugging pass execution, seeing how things work, and
diagnosing when you should be preserving more analyses than you currently are
(To get information about all of the variants of the <tt>--debug-pass</tt>
-option, just type '<tt>opt --help-hidden</tt>').</p>
+option, just type '<tt>opt -help-hidden</tt>').</p>
<p>By using the <tt>--debug-pass=Structure</tt> option, for example, we can see
how our <a href="#basiccode">Hello World</a> pass interacts with other passes.
Module Verifier
-- Dominator Set Construction
-- Module Verifier
- Bytecode Writer
---Bytecode Writer
+ Bitcode Writer
+--Bitcode Writer
</pre></div>
<p>This output shows us when passes are constructed and when the analysis
Module Verifier
-- Dominator Set Construction
-- Module Verifier
- Bytecode Writer
---Bytecode Writer
+ Bitcode Writer
+--Bitcode Writer
Hello: __main
Hello: puts
Hello: main
Module Verifier
-- Dominator Set Construction
-- Module Verifier
- Bytecode Writer
---Bytecode Writer
+ Bitcode Writer
+--Bitcode Writer
Hello: __main
Hello: puts
Hello: main
<p>If you are writing an analysis or any other pass that retains a significant
amount of state (for use by another pass which "requires" your pass and uses the
<a href="#getAnalysis">getAnalysis</a> method) you should implement
-<tt>releaseMEmory</tt> to, well, release the memory allocated to maintain this
+<tt>releaseMemory</tt> to, well, release the memory allocated to maintain this
internal state. This method is called after the <tt>run*</tt> method for the
class, before the next call of <tt>run*</tt> in your pass.</p>
</pre></div>
<p>Note the two spaces prior to the help string produces a tidy result on the
---help query.</p>
+-help query.</p>
<div class="doc_code"><pre>
-$ llc --help
+$ llc -help
...
- -regalloc - Register allocator to use: (default = linearscan)
+ -regalloc - Register allocator to use (default=linearscan)
=linearscan - linear scan register allocator
=local - local register allocator
=simple - simple register allocator
<div class="doc_code"><pre>
cl::opt<RegisterMyPasses::FunctionPassCtor, false,
- RegisterPassParser<RegisterMyPasses> >
+ RegisterPassParser<RegisterMyPasses> >
MyPassOpt("mypass",
cl::init(&createDefaultMyPass),
cl::desc("my pass option help"));
haven't had time (or multiprocessor machines, thus a reason) to implement this.
Despite that, we have kept the LLVM passes SMP ready, and you should too.</p>
+</div>
+
<!-- *********************************************************************** -->
<hr>
<address>
<a href="http://jigsaw.w3.org/css-validator/check/referer"><img
- src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
+ src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a>
<a href="http://validator.w3.org/check/referer"><img
- src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
+ src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a>
<a href="mailto:sabre@nondot.org">Chris Lattner</a><br>
<a href="http://llvm.org">The LLVM Compiler Infrastructure</a><br>
projects / oota-llvm.git / blobdiff