<a name="internalize">Internalize Global Symbols</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass loops over all of the functions in the input module, looking for a
+ main function. If a main function is found, all other functions and all
+ global variables with initializers are marked as internal.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="ipconstprop">Interprocedural constant propagation</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass implements an <em>extremely</em> simple interprocedural constant
+ propagation pass. It could certainly be improved in many different ways,
+ like using a worklist. This pass makes arguments dead, but does not remove
+ them. The existing dead argument elimination pass should be run after this
+ to clean up the mess.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="ipsccp">Interprocedural Sparse Conditional Constant Propagation</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ An interprocedural variant of <a href="#sccp">Sparse Conditional Constant
+ Propagation</a>.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lcssa">Loop-Closed SSA Form Pass</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass transforms loops by placing phi nodes at the end of the loops for
+ all values that are live across the loop boundary. For example, it turns
+ the left into the right code:
+ </p>
+
+ <pre
+>for (...) for (...)
+ if (c) if (c)
+ X1 = ... X1 = ...
+ else else
+ X2 = ... X2 = ...
+ X3 = phi(X1, X2) X3 = phi(X1, X2)
+... = X3 + 4 X4 = phi(X3)
+ ... = X4 + 4</pre>
+
+ <p>
+ This is still valid LLVM; the extra phi nodes are purely redundant, and will
+ be trivially eliminated by <code>InstCombine</code>. The major benefit of
+ this transformation is that it makes many other loop optimizations, such as
+ LoopUnswitching, simpler.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="licm">Loop Invariant Code Motion</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass performs loop invariant code motion, attempting to remove as much
+ code from the body of a loop as possible. It does this by either hoisting
+ code into the preheader block, or by sinking code to the exit blocks if it is
+ safe. This pass also promotes must-aliased memory locations in the loop to
+ live in registers, thus hoisting and sinking "invariant" loads and stores.
+ </p>
+
+ <p>
+ This pass uses alias analysis for two purposes:
+ </p>
+
+ <ul>
+ <li>Moving loop invariant loads and calls out of loops. If we can determine
+ that a load or call inside of a loop never aliases anything stored to,
+ we can hoist it or sink it like any other instruction.</li>
+ <li>Scalar Promotion of Memory - If there is a store instruction inside of
+ the loop, we try to move the store to happen AFTER the loop instead of
+ inside of the loop. This can only happen if a few conditions are true:
+ <ul>
+ <li>The pointer stored through is loop invariant.</li>
+ <li>There are no stores or loads in the loop which <em>may</em> alias
+ the pointer. There are no calls in the loop which mod/ref the
+ pointer.</li>
+ </ul>
+ If these conditions are true, we can promote the loads and stores in the
+ loop of the pointer to use a temporary alloca'd variable. We then use
+ the mem2reg functionality to construct the appropriate SSA form for the
+ variable.</li>
+ </ul>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-extract">Extract loops into new functions</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ A pass wrapper around the <code>ExtractLoop()</code> scalar transformation to
+ extract each top-level loop into its own new function. If the loop is the
+ <em>only</em> loop in a given function, it is not touched. This is a pass most
+ useful for debugging via bugpoint.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-extract-single">Extract at most one loop into a new function</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Similar to <a href="#loop-extract">Extract loops into new functions</a>,
+ this pass extracts one natural loop from the program into a function if it
+ can. This is used by bugpoint.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-index-split">Index Split Loops</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass divides loop's iteration range by spliting loop such that each
+ individual loop is executed efficiently.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-reduce">Loop Strength Reduction</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass performs a strength reduction on array references inside loops that
+ have as one or more of their components the loop induction variable. This is
+ accomplished by creating a new value to hold the initial value of the array
+ access for the first iteration, and then creating a new GEP instruction in
+ the loop to increment the value by the appropriate amount.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-rotate">Rotate Loops</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>A simple loop rotation transformation.</p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-unroll">Unroll loops</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass implements a simple loop unroller. It works best when loops have
+ been canonicalized by the <a href="#indvars"><tt>-indvars</tt></a> pass,
+ allowing it to determine the trip counts of loops easily.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loop-unswitch">Unswitch loops</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass transforms loops that contain branches on loop-invariant conditions
+ to have multiple loops. For example, it turns the left into the right code:
+ </p>
+
+ <pre
+>for (...) if (lic)
+ A for (...)
+ if (lic) A; B; C
+ B else
+ C for (...)
+ A; C</pre>
+
+ <p>
+ This can increase the size of the code exponentially (doubling it every time
+ a loop is unswitched) so we only unswitch if the resultant code will be
+ smaller than a threshold.
+ </p>
+
+ <p>
+ This pass expects LICM to be run before it to hoist invariant conditions out
+ of the loop, to make the unswitching opportunity obvious.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="loopsimplify">Canonicalize natural loops</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass performs several transformations to transform natural loops into a
+ simpler form, which makes subsequent analyses and transformations simpler and
+ more effective.
+ </p>
+
+ <p>
+ Loop pre-header insertion guarantees that there is a single, non-critical
+ entry edge from outside of the loop to the loop header. This simplifies a
+ number of analyses and transformations, such as LICM.
+ </p>
+
+ <p>
+ Loop exit-block insertion guarantees that all exit blocks from the loop
+ (blocks which are outside of the loop that have predecessors inside of the
+ loop) only have predecessors from inside of the loop (and are thus dominated
+ by the loop header). This simplifies transformations such as store-sinking
+ that are built into LICM.
+ </p>
+
+ <p>
+ This pass also guarantees that loops will have exactly one backedge.
+ </p>
+
+ <p>
+ Note that the simplifycfg pass will clean up blocks which are split out but
+ end up being unnecessary, so usage of this pass should not pessimize
+ generated code.
+ </p>
+
+ <p>
+ This pass obviously modifies the CFG, but updates loop information and
+ dominator information.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lower-packed">lowers packed operations to operations on smaller packed datatypes</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Lowers operations on vector datatypes into operations on more primitive vector
+ datatypes, and finally to scalar operations.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lowerallocs">Lower allocations from instructions to calls</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Turn <tt>malloc</tt> and <tt>free</tt> instructions into <tt>@malloc</tt> and
+ <tt>@free</tt> calls.
+ </p>
+
+ <p>
+ This is a target-dependent tranformation because it depends on the size of
+ data types and alignment constraints.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lowergc">Lower GC intrinsics, for GCless code generators</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This file implements lowering for the <tt>llvm.gc*</tt> intrinsics for targets
+ that do not natively support them (which includes the C backend). Note that
+ the code generated is not as efficient as it would be for targets that
+ natively support the GC intrinsics, but it is useful for getting new targets
+ up-and-running quickly.
+ </p>
+
+ <p>
+ This pass implements the code transformation described in this paper:
+ </p>
+
+ <blockquote><p>
+ "Accurate Garbage Collection in an Uncooperative Environment"
+ Fergus Henderson, ISMM, 2002
+ </p></blockquote>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lowerinvoke">Lower invoke and unwind, for unwindless code generators</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This transformation is designed for use by code generators which do not yet
+ support stack unwinding. This pass supports two models of exception handling
+ lowering, the 'cheap' support and the 'expensive' support.
+ </p>
+
+ <p>
+ 'Cheap' exception handling support gives the program the ability to execute
+ any program which does not "throw an exception", by turning 'invoke'
+ instructions into calls and by turning 'unwind' instructions into calls to
+ abort(). If the program does dynamically use the unwind instruction, the
+ program will print a message then abort.
+ </p>
+
+ <p>
+ 'Expensive' exception handling support gives the full exception handling
+ support to the program at the cost of making the 'invoke' instruction
+ really expensive. It basically inserts setjmp/longjmp calls to emulate the
+ exception handling as necessary.
+ </p>
+
+ <p>
+ Because the 'expensive' support slows down programs a lot, and EH is only
+ used for a subset of the programs, it must be specifically enabled by the
+ <tt>-enable-correct-eh-support</tt> option.
+ </p>
+
+ <p>
+ Note that after this pass runs the CFG is not entirely accurate (exceptional
+ control flow edges are not correct anymore) so only very simple things should
+ be done after the lowerinvoke pass has run (like generation of native code).
+ This should not be used as a general purpose "my LLVM-to-LLVM pass doesn't
+ support the invoke instruction yet" lowering pass.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lowerselect">Lower select instructions to branches</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Lowers select instructions into conditional branches for targets that do not
+ have conditional moves or that have not implemented the select instruction
+ yet.
+ </p>
+
+ <p>
+ Note that this pass could be improved. In particular it turns every select
+ instruction into a new conditional branch, even though some common cases have
+ select instructions on the same predicate next to each other. It would be
+ better to use the same branch for the whole group of selects.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lowersetjmp">Lower Set Jump</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Lowers <tt>setjmp</tt> and <tt>longjmp</tt> to use the LLVM invoke and unwind
+ instructions as necessary.
+ </p>
+
+ <p>
+ Lowering of <tt>longjmp</tt> is fairly trivial. We replace the call with a
+ call to the LLVM library function <tt>__llvm_sjljeh_throw_longjmp()</tt>.
+ This unwinds the stack for us calling all of the destructors for
+ objects allocated on the stack.
+ </p>
+
+ <p>
+ At a <tt>setjmp</tt> call, the basic block is split and the <tt>setjmp</tt>
+ removed. The calls in a function that have a <tt>setjmp</tt> are converted to
+ invoke where the except part checks to see if it's a <tt>longjmp</tt>
+ exception and, if so, if it's handled in the function. If it is, then it gets
+ the value returned by the <tt>longjmp</tt> and goes to where the basic block
+ was split. <tt>invoke</tt> instructions are handled in a similar fashion with
+ the original except block being executed if it isn't a <tt>longjmp</tt>
+ except that is handled by that function.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="lowerswitch">Lower SwitchInst's to branches</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Rewrites <tt>switch</tt> instructions with a sequence of branches, which
+ allows targets to get away with not implementing the switch instruction until
+ it is convenient.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="mem2reg">Promote Memory to Register</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This file promotes memory references to be register references. It promotes
+ <tt>alloca</tt> instructions which only have <tt>load</tt>s and
+ <tt>store</tt>s as uses. An <tt>alloca</tt> is transformed by using dominator
+ frontiers to place <tt>phi</tt> nodes, then traversing the function in
+ depth-first order to rewrite <tt>load</tt>s and <tt>store</tt>s as
+ appropriate. This is just the standard SSA construction algorithm to construct
+ "pruned" SSA form.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="mergereturn">Unify function exit nodes</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Ensure that functions have at most one <tt>ret</tt> instruction in them.
+ Additionally, it keeps track of which node is the new exit node of the CFG.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="predsimplify">Predicate Simplifier</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Path-sensitive optimizer. In a branch where <tt>x == y</tt>, replace uses of
+ <tt>x</tt> with <tt>y</tt>. Permits further optimization, such as the
+ elimination of the unreachable call:
+ </p>
+
+<blockquote><pre
+>void test(int *p, int *q)
+{
+ if (p != q)
+ return;
+
+ if (*p != *q)
+ foo(); // unreachable
+}</pre></blockquote>
</div>
<!-------------------------------------------------------------------------- -->
<a name="prune-eh">Remove unused exception handling info</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This file implements a simple interprocedural pass which walks the call-graph,
+ turning <tt>invoke</tt> instructions into <tt>call</tt> instructions if and
+ only if the callee cannot throw an exception. It implements this as a
+ bottom-up traversal of the call-graph.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="raiseallocs">Raise allocations from calls to instructions</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Converts <tt>@malloc</tt> and <tt>@free</tt> calls to <tt>malloc</tt> and
+ <tt>free</tt> instructions.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="reassociate">Reassociate expressions</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass reassociates commutative expressions in an order that is designed
+ to promote better constant propagation, GCSE, LICM, PRE, etc.
+ </p>
+
+ <p>
+ For example: 4 + (<var>x</var> + 5) ⇒ <var>x</var> + (4 + 5)
+ </p>
+
+ <p>
+ In the implementation of this algorithm, constants are assigned rank = 0,
+ function arguments are rank = 1, and other values are assigned ranks
+ corresponding to the reverse post order traversal of current function
+ (starting at 2), which effectively gives values in deep loops higher rank
+ than values not in loops.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="reg2mem">Demote all values to stack slots</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This file demotes all registers to memory references. It is intented to be
+ the inverse of <a href="#mem2reg"><tt>-mem2reg</tt></a>. By converting to
+ <tt>load</tt> instructions, the only values live accross basic blocks are
+ <tt>alloca</tt> instructions and <tt>load</tt> instructions before
+ <tt>phi</tt> nodes. It is intended that this should make CFG hacking much
+ easier. To make later hacking easier, the entry block is split into two, such
+ that all introduced <tt>alloca</tt> instructions (and nothing else) are in the
+ entry block.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="scalarrepl">Scalar Replacement of Aggregates</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ The well-known scalar replacement of aggregates transformation. This
+ transform breaks up <tt>alloca</tt> instructions of aggregate type (structure
+ or array) into individual <tt>alloca</tt> instructions for each member if
+ possible. Then, if possible, it transforms the individual <tt>alloca</tt>
+ instructions into nice clean scalar SSA form.
+ </p>
+
+ <p>
+ This combines a simple scalar replacement of aggregates algorithm with the <a
+ href="#mem2reg"><tt>mem2reg</tt></a> algorithm because often interact,
+ especially for C++ programs. As such, iterating between <tt>scalarrepl</tt>,
+ then <a href="#mem2reg"><tt>mem2reg</tt></a> until we run out of things to
+ promote works well.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="sccp">Sparse Conditional Constant Propagation</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Sparse conditional constant propagation and merging, which can be summarized
+ as:
+ </p>
+
+ <ol>
+ <li>Assumes values are constant unless proven otherwise</li>
+ <li>Assumes BasicBlocks are dead unless proven otherwise</li>
+ <li>Proves values to be constant, and replaces them with constants</li>
+ <li>Proves conditional branches to be unconditional</li>
+ </ol>
+
+ <p>
+ Note that this pass has a habit of making definitions be dead. It is a good
+ idea to to run a DCE pass sometime after running this pass.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="simplify-libcalls">Simplify well-known library calls</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Applies a variety of small optimizations for calls to specific well-known
+ function calls (e.g. runtime library functions). For example, a call
+ <tt>exit(3)</tt> that occurs within the <tt>main()</tt> function can be
+ transformed into simply <tt>return 3</tt>.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="simplifycfg">Simplify the CFG</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Performs dead code elimination and basic block merging. Specifically:
+ </p>
+
+ <ol>
+ <li>Removes basic blocks with no predecessors.</li>
+ <li>Merges a basic block into its predecessor if there is only one and the
+ predecessor only has one successor.</li>
+ <li>Eliminates PHI nodes for basic blocks with a single predecessor.</li>
+ <li>Eliminates a basic block that only contains an unconditional
+ branch.</li>
+ </ol>
</div>
<!-------------------------------------------------------------------------- -->
<a name="strip">Strip all symbols from a module</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Performs code stripping. This transformation can delete:
+ </p>
+
+ <ol>
+ <li>names for virtual registers</li>
+ <li>symbols for internal globals and functions</li>
+ <li>debug information</li>
+ </ol>
+
+ <p>
+ Note that this transformation makes code much less readable, so it should
+ only be used in situations where the <tt>strip</tt> utility would be used,
+ such as reducing code size or making it harder to reverse engineer code.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<a name="tailcallelim">Tail Call Elimination</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This file transforms calls of the current function (self recursion) followed
+ by a return instruction with a branch to the entry of the function, creating
+ a loop. This pass also implements the following extensions to the basic
+ algorithm:
+ </p>
+
+ <ul>
+ <li>Trivial instructions between the call and return do not prevent the
+ transformation from taking place, though currently the analysis cannot
+ support moving any really useful instructions (only dead ones).
+ <li>This pass transforms functions that are prevented from being tail
+ recursive by an associative expression to use an accumulator variable,
+ thus compiling the typical naive factorial or <tt>fib</tt> implementation
+ into efficient code.
+ <li>TRE is performed if the function returns void, if the return
+ returns the result returned by the call, or if the function returns a
+ run-time constant on all exits from the function. It is possible, though
+ unlikely, that the return returns something else (like constant 0), and
+ can still be TRE'd. It can be TRE'd if <em>all other</em> return
+ instructions in the function return the exact same value.
+ <li>If it can prove that callees do not access theier caller stack frame,
+ they are marked as eligible for tail call elimination (by the code
+ generator).
+ </ul>
</div>
<!-------------------------------------------------------------------------- -->
<a name="tailduplicate">Tail Duplication</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass performs a limited form of tail duplication, intended to simplify
+ CFGs by removing some unconditional branches. This pass is necessary to
+ straighten out loops created by the C front-end, but also is capable of
+ making other code nicer. After this pass is run, the CFG simplify pass
+ should be run to clean up the mess.
+ </p>
</div>
<!-- ======================================================================= -->
projects / oota-llvm.git / commitdiff