my $o = $order{$1};
$o = "000" unless defined $o;
push @x, "$o<tr><td><a href=\"#$1\">-$1</a></td><td>$2</td></tr>\n";
- push @y, "$o <a name=\"$1\">$2</a>\n";
+ push @y, "$o <a name=\"$1\">-$1: $2</a>\n";
}
@x = map { s/^\d\d\d//; $_ } sort @x;
@y = map { s/^\d\d\d//; $_ } sort @y;
-->
-<div class="doc_title">LLVM's Analysis and Transform Passes</div>
+<h1>LLVM's Analysis and Transform Passes</h1>
<ol>
<li><a href="#intro">Introduction</a></li>
</div>
<!-- ======================================================================= -->
-<div class="doc_section"> <a name="intro">Introduction</a> </div>
-<div class="doc_text">
+<h2><a name="intro">Introduction</a></h2>
+<div>
<p>This document serves as a high level summary of the optimization features
that LLVM provides. Optimizations are implemented as Passes that traverse some
portion of a program to either collect information or transform the program.
bitcode are neither analysis nor transform passes.
<p>The table below provides a quick summary of each pass and links to the more
complete pass description later in the document.</p>
-</div>
-<div class="doc_text" >
+
<table>
<tr><th colspan="2"><b>ANALYSIS PASSES</b></th></tr>
<tr><th>Option</th><th>Name</th></tr>
<tr><td><a href="#aa-eval">-aa-eval</a></td><td>Exhaustive Alias Analysis Precision Evaluator</td></tr>
-<tr><td><a href="#anders-aa">-anders-aa</a></td><td>Andersen's Interprocedural Alias Analysis</td></tr>
-<tr><td><a href="#basicaa">-basicaa</a></td><td>Basic Alias Analysis (default AA impl)</td></tr>
+<tr><td><a href="#basicaa">-basicaa</a></td><td>Basic Alias Analysis (stateless AA impl)</td></tr>
<tr><td><a href="#basiccg">-basiccg</a></td><td>Basic CallGraph Construction</td></tr>
-<tr><td><a href="#basicvn">-basicvn</a></td><td>Basic Value Numbering (default GVN impl)</td></tr>
-<tr><td><a href="#codegenprepare">-codegenprepare</a></td><td>Optimize for code generation</td></tr>
<tr><td><a href="#count-aa">-count-aa</a></td><td>Count Alias Analysis Query Responses</td></tr>
<tr><td><a href="#debug-aa">-debug-aa</a></td><td>AA use debugger</td></tr>
<tr><td><a href="#domfrontier">-domfrontier</a></td><td>Dominance Frontier Construction</td></tr>
<tr><td><a href="#dot-callgraph">-dot-callgraph</a></td><td>Print Call Graph to 'dot' file</td></tr>
<tr><td><a href="#dot-cfg">-dot-cfg</a></td><td>Print CFG of function to 'dot' file</td></tr>
<tr><td><a href="#dot-cfg-only">-dot-cfg-only</a></td><td>Print CFG of function to 'dot' file (with no function bodies)</td></tr>
+<tr><td><a href="#dot-dom">-dot-dom</a></td><td>Print dominance tree of function to 'dot' file</td></tr>
+<tr><td><a href="#dot-dom-only">-dot-dom-only</a></td><td>Print dominance tree of function to 'dot' file (with no function bodies)</td></tr>
+<tr><td><a href="#dot-postdom">-dot-postdom</a></td><td>Print postdominance tree of function to 'dot' file</td></tr>
+<tr><td><a href="#dot-postdom-only">-dot-postdom-only</a></td><td>Print postdominance tree of function to 'dot' file (with no function bodies)</td></tr>
<tr><td><a href="#globalsmodref-aa">-globalsmodref-aa</a></td><td>Simple mod/ref analysis for globals</td></tr>
<tr><td><a href="#instcount">-instcount</a></td><td>Counts the various types of Instructions</td></tr>
<tr><td><a href="#intervals">-intervals</a></td><td>Interval Partition Construction</td></tr>
-<tr><td><a href="#load-vn">-load-vn</a></td><td>Load Value Numbering</td></tr>
-<tr><td><a href="#loops">-loops</a></td><td>Natural Loop Construction</td></tr>
+<tr><td><a href="#iv-users">-iv-users</a></td><td>Induction Variable Users</td></tr>
+<tr><td><a href="#lazy-value-info">-lazy-value-info</a></td><td>Lazy Value Information Analysis</td></tr>
+<tr><td><a href="#lda">-lda</a></td><td>Loop Dependence Analysis</td></tr>
+<tr><td><a href="#libcall-aa">-libcall-aa</a></td><td>LibCall Alias Analysis</td></tr>
+<tr><td><a href="#lint">-lint</a></td><td>Statically lint-checks LLVM IR</td></tr>
+<tr><td><a href="#loops">-loops</a></td><td>Natural Loop Information</td></tr>
<tr><td><a href="#memdep">-memdep</a></td><td>Memory Dependence Analysis</td></tr>
+<tr><td><a href="#module-debuginfo">-module-debuginfo</a></td><td>Decodes module-level debug info</td></tr>
<tr><td><a href="#no-aa">-no-aa</a></td><td>No Alias Analysis (always returns 'may' alias)</td></tr>
<tr><td><a href="#no-profile">-no-profile</a></td><td>No Profile Information</td></tr>
<tr><td><a href="#postdomfrontier">-postdomfrontier</a></td><td>Post-Dominance Frontier Construction</td></tr>
<tr><td><a href="#print-callgraph">-print-callgraph</a></td><td>Print a call graph</td></tr>
<tr><td><a href="#print-callgraph-sccs">-print-callgraph-sccs</a></td><td>Print SCCs of the Call Graph</td></tr>
<tr><td><a href="#print-cfg-sccs">-print-cfg-sccs</a></td><td>Print SCCs of each function CFG</td></tr>
+<tr><td><a href="#print-dbginfo">-print-dbginfo</a></td><td>Print debug info in human readable form</td></tr>
+<tr><td><a href="#print-dom-info">-print-dom-info</a></td><td>Dominator Info Printer</td></tr>
<tr><td><a href="#print-externalfnconstants">-print-externalfnconstants</a></td><td>Print external fn callsites passed constants</td></tr>
<tr><td><a href="#print-function">-print-function</a></td><td>Print function to stderr</td></tr>
<tr><td><a href="#print-module">-print-module</a></td><td>Print module to stderr</td></tr>
<tr><td><a href="#print-used-types">-print-used-types</a></td><td>Find Used Types</td></tr>
+<tr><td><a href="#profile-estimator">-profile-estimator</a></td><td>Estimate profiling information</td></tr>
<tr><td><a href="#profile-loader">-profile-loader</a></td><td>Load profile information from llvmprof.out</td></tr>
+<tr><td><a href="#profile-verifier">-profile-verifier</a></td><td>Verify profiling information</td></tr>
+<tr><td><a href="#regions">-regions</a></td><td>Detect single entry single exit regions</td></tr>
<tr><td><a href="#scalar-evolution">-scalar-evolution</a></td><td>Scalar Evolution Analysis</td></tr>
+<tr><td><a href="#scev-aa">-scev-aa</a></td><td>ScalarEvolution-based Alias Analysis</td></tr>
<tr><td><a href="#targetdata">-targetdata</a></td><td>Target Data Layout</td></tr>
<tr><th colspan="2"><b>TRANSFORM PASSES</b></th></tr>
<tr><th>Option</th><th>Name</th></tr>
<tr><td><a href="#adce">-adce</a></td><td>Aggressive Dead Code Elimination</td></tr>
+<tr><td><a href="#always-inline">-always-inline</a></td><td>Inliner for always_inline functions</td></tr>
<tr><td><a href="#argpromotion">-argpromotion</a></td><td>Promote 'by reference' arguments to scalars</td></tr>
+<tr><td><a href="#bb-vectorize">-bb-vectorize</a></td><td>Combine instructions to form vector instructions within basic blocks</td></tr>
<tr><td><a href="#block-placement">-block-placement</a></td><td>Profile Guided Basic Block Placement</td></tr>
<tr><td><a href="#break-crit-edges">-break-crit-edges</a></td><td>Break critical edges in CFG</td></tr>
-<tr><td><a href="#codegenprepare">-codegenprepare</a></td><td>Prepare a function for code generation </td></tr>
-<tr><td><a href="#condprop">-condprop</a></td><td>Conditional Propagation</td></tr>
+<tr><td><a href="#codegenprepare">-codegenprepare</a></td><td>Optimize for code generation</td></tr>
<tr><td><a href="#constmerge">-constmerge</a></td><td>Merge Duplicate Global Constants</td></tr>
<tr><td><a href="#constprop">-constprop</a></td><td>Simple constant propagation</td></tr>
<tr><td><a href="#dce">-dce</a></td><td>Dead Code Elimination</td></tr>
<tr><td><a href="#deadtypeelim">-deadtypeelim</a></td><td>Dead Type Elimination</td></tr>
<tr><td><a href="#die">-die</a></td><td>Dead Instruction Elimination</td></tr>
<tr><td><a href="#dse">-dse</a></td><td>Dead Store Elimination</td></tr>
-<tr><td><a href="#gcse">-gcse</a></td><td>Global Common Subexpression Elimination</td></tr>
+<tr><td><a href="#functionattrs">-functionattrs</a></td><td>Deduce function attributes</td></tr>
<tr><td><a href="#globaldce">-globaldce</a></td><td>Dead Global Elimination</td></tr>
<tr><td><a href="#globalopt">-globalopt</a></td><td>Global Variable Optimizer</td></tr>
<tr><td><a href="#gvn">-gvn</a></td><td>Global Value Numbering</td></tr>
-<tr><td><a href="#gvnpre">-gvnpre</a></td><td>Global Value Numbering/Partial Redundancy Elimination</td></tr>
-<tr><td><a href="#indmemrem">-indmemrem</a></td><td>Indirect Malloc and Free Removal</td></tr>
<tr><td><a href="#indvars">-indvars</a></td><td>Canonicalize Induction Variables</td></tr>
<tr><td><a href="#inline">-inline</a></td><td>Function Integration/Inlining</td></tr>
-<tr><td><a href="#insert-block-profiling">-insert-block-profiling</a></td><td>Insert instrumentation for block profiling</td></tr>
<tr><td><a href="#insert-edge-profiling">-insert-edge-profiling</a></td><td>Insert instrumentation for edge profiling</td></tr>
-<tr><td><a href="#insert-function-profiling">-insert-function-profiling</a></td><td>Insert instrumentation for function profiling</td></tr>
-<tr><td><a href="#insert-null-profiling-rs">-insert-null-profiling-rs</a></td><td>Measure profiling framework overhead</td></tr>
-<tr><td><a href="#insert-rs-profiling-framework">-insert-rs-profiling-framework</a></td><td>Insert random sampling instrumentation framework</td></tr>
+<tr><td><a href="#insert-optimal-edge-profiling">-insert-optimal-edge-profiling</a></td><td>Insert optimal instrumentation for edge profiling</td></tr>
<tr><td><a href="#instcombine">-instcombine</a></td><td>Combine redundant instructions</td></tr>
<tr><td><a href="#internalize">-internalize</a></td><td>Internalize Global Symbols</td></tr>
<tr><td><a href="#ipconstprop">-ipconstprop</a></td><td>Interprocedural constant propagation</td></tr>
<tr><td><a href="#ipsccp">-ipsccp</a></td><td>Interprocedural Sparse Conditional Constant Propagation</td></tr>
-<tr><td><a href="#jump-threading">-jump-threading</a></td><td>Thread control through conditional blocks </td></tr>
+<tr><td><a href="#jump-threading">-jump-threading</a></td><td>Jump Threading</td></tr>
<tr><td><a href="#lcssa">-lcssa</a></td><td>Loop-Closed SSA Form Pass</td></tr>
<tr><td><a href="#licm">-licm</a></td><td>Loop Invariant Code Motion</td></tr>
-<tr><td><a href="#loop-deletion">-loop-deletion</a></td><td>Dead Loop Deletion Pass </td></tr>
+<tr><td><a href="#loop-deletion">-loop-deletion</a></td><td>Delete dead loops</td></tr>
<tr><td><a href="#loop-extract">-loop-extract</a></td><td>Extract loops into new functions</td></tr>
<tr><td><a href="#loop-extract-single">-loop-extract-single</a></td><td>Extract at most one loop into a new function</td></tr>
-<tr><td><a href="#loop-index-split">-loop-index-split</a></td><td>Index Split Loops</td></tr>
<tr><td><a href="#loop-reduce">-loop-reduce</a></td><td>Loop Strength Reduction</td></tr>
<tr><td><a href="#loop-rotate">-loop-rotate</a></td><td>Rotate Loops</td></tr>
+<tr><td><a href="#loop-simplify">-loop-simplify</a></td><td>Canonicalize natural loops</td></tr>
<tr><td><a href="#loop-unroll">-loop-unroll</a></td><td>Unroll loops</td></tr>
<tr><td><a href="#loop-unswitch">-loop-unswitch</a></td><td>Unswitch loops</td></tr>
-<tr><td><a href="#loopsimplify">-loopsimplify</a></td><td>Canonicalize natural loops</td></tr>
-<tr><td><a href="#lowerallocs">-lowerallocs</a></td><td>Lower allocations from instructions to calls</td></tr>
+<tr><td><a href="#loweratomic">-loweratomic</a></td><td>Lower atomic intrinsics to non-atomic form</td></tr>
<tr><td><a href="#lowerinvoke">-lowerinvoke</a></td><td>Lower invoke and unwind, for unwindless code generators</td></tr>
-<tr><td><a href="#lowersetjmp">-lowersetjmp</a></td><td>Lower Set Jump</td></tr>
<tr><td><a href="#lowerswitch">-lowerswitch</a></td><td>Lower SwitchInst's to branches</td></tr>
<tr><td><a href="#mem2reg">-mem2reg</a></td><td>Promote Memory to Register</td></tr>
-<tr><td><a href="#memcpyopt">-memcpyopt</a></td><td>Optimize use of memcpy and friends</td></tr>
+<tr><td><a href="#memcpyopt">-memcpyopt</a></td><td>MemCpy Optimization</td></tr>
+<tr><td><a href="#mergefunc">-mergefunc</a></td><td>Merge Functions</td></tr>
<tr><td><a href="#mergereturn">-mergereturn</a></td><td>Unify function exit nodes</td></tr>
-<tr><td><a href="#predsimplify">-predsimplify</a></td><td>Predicate Simplifier</td></tr>
+<tr><td><a href="#partial-inliner">-partial-inliner</a></td><td>Partial Inliner</td></tr>
<tr><td><a href="#prune-eh">-prune-eh</a></td><td>Remove unused exception handling info</td></tr>
-<tr><td><a href="#raiseallocs">-raiseallocs</a></td><td>Raise allocations from calls to instructions</td></tr>
<tr><td><a href="#reassociate">-reassociate</a></td><td>Reassociate expressions</td></tr>
<tr><td><a href="#reg2mem">-reg2mem</a></td><td>Demote all values to stack slots</td></tr>
-<tr><td><a href="#scalarrepl">-scalarrepl</a></td><td>Scalar Replacement of Aggregates</td></tr>
+<tr><td><a href="#scalarrepl">-scalarrepl</a></td><td>Scalar Replacement of Aggregates (DT)</td></tr>
<tr><td><a href="#sccp">-sccp</a></td><td>Sparse Conditional Constant Propagation</td></tr>
<tr><td><a href="#simplify-libcalls">-simplify-libcalls</a></td><td>Simplify well-known library calls</td></tr>
<tr><td><a href="#simplifycfg">-simplifycfg</a></td><td>Simplify the CFG</td></tr>
+<tr><td><a href="#sink">-sink</a></td><td>Code sinking</td></tr>
+<tr><td><a href="#sretpromotion">-sretpromotion</a></td><td>Promote sret arguments to multiple ret values</td></tr>
<tr><td><a href="#strip">-strip</a></td><td>Strip all symbols from a module</td></tr>
-<tr><td><a href="#strip-dead-prototypes">-strip-dead-prototypes</a></td><td>Remove unused function declarations</td></tr>
-<tr><td><a href="#sretpromotion">-sretpromotion</a></td><td>Promote sret arguments</td></tr>
+<tr><td><a href="#strip-dead-debug-info">-strip-dead-debug-info</a></td><td>Strip debug info for unused symbols</td></tr>
+<tr><td><a href="#strip-dead-prototypes">-strip-dead-prototypes</a></td><td>Strip Unused Function Prototypes</td></tr>
+<tr><td><a href="#strip-debug-declare">-strip-debug-declare</a></td><td>Strip all llvm.dbg.declare intrinsics</td></tr>
+<tr><td><a href="#strip-nondebug">-strip-nondebug</a></td><td>Strip all symbols, except dbg symbols, from a module</td></tr>
<tr><td><a href="#tailcallelim">-tailcallelim</a></td><td>Tail Call Elimination</td></tr>
<tr><td><a href="#tailduplicate">-tailduplicate</a></td><td>Tail Duplication</td></tr>
<tr><th>Option</th><th>Name</th></tr>
<tr><td><a href="#deadarghaX0r">-deadarghaX0r</a></td><td>Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)</td></tr>
<tr><td><a href="#extract-blocks">-extract-blocks</a></td><td>Extract Basic Blocks From Module (for bugpoint use)</td></tr>
+<tr><td><a href="#instnamer">-instnamer</a></td><td>Assign names to anonymous instructions</td></tr>
<tr><td><a href="#preverify">-preverify</a></td><td>Preliminary module verification</td></tr>
<tr><td><a href="#verify">-verify</a></td><td>Module Verifier</td></tr>
<tr><td><a href="#view-cfg">-view-cfg</a></td><td>View CFG of function</td></tr>
<tr><td><a href="#view-cfg-only">-view-cfg-only</a></td><td>View CFG of function (with no function bodies)</td></tr>
+<tr><td><a href="#view-dom">-view-dom</a></td><td>View dominance tree of function</td></tr>
+<tr><td><a href="#view-dom-only">-view-dom-only</a></td><td>View dominance tree of function (with no function bodies)</td></tr>
+<tr><td><a href="#view-postdom">-view-postdom</a></td><td>View postdominance tree of function</td></tr>
+<tr><td><a href="#view-postdom-only">-view-postdom-only</a></td><td>View postdominance tree of function (with no function bodies)</td></tr>
</table>
+
</div>
<!-- ======================================================================= -->
-<div class="doc_section"> <a name="example">Analysis Passes</a></div>
-<div class="doc_text">
+<h2><a name="analyses">Analysis Passes</a></h2>
+<div>
<p>This section describes the LLVM Analysis Passes.</p>
-</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="aa-eval">Exhaustive Alias Analysis Precision Evaluator</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="aa-eval">-aa-eval: Exhaustive Alias Analysis Precision Evaluator</a>
+</h3>
+<div>
<p>This is a simple N^2 alias analysis accuracy evaluator.
Basically, for each function in the program, it simply queries to see how the
alias analysis implementation answers alias queries between each pair of
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="anders-aa">Andersen's Interprocedural Alias Analysis</a>
-</div>
-<div class="doc_text">
- <p>
- This is an implementation of Andersen's interprocedural alias
- analysis
- </p>
-
- <p>
- In pointer analysis terms, this is a subset-based, flow-insensitive,
- field-sensitive, and context-insensitive algorithm pointer algorithm.
- </p>
-
- <p>
- This algorithm is implemented as three stages:
- </p>
-
- <ol>
- <li>Object identification.</li>
- <li>Inclusion constraint identification.</li>
- <li>Offline constraint graph optimization.</li>
- <li>Inclusion constraint solving.</li>
- </ol>
-
- <p>
- The object identification stage identifies all of the memory objects in the
- program, which includes globals, heap allocated objects, and stack allocated
- objects.
- </p>
-
- <p>
- The inclusion constraint identification stage finds all inclusion constraints
- in the program by scanning the program, looking for pointer assignments and
- other statements that effect the points-to graph. For a statement like
- <code><var>A</var> = <var>B</var></code>, this statement is processed to
- indicate that <var>A</var> can point to anything that <var>B</var> can point
- to. Constraints can handle copies, loads, and stores, and address taking.
- </p>
-
- <p>
- The offline constraint graph optimization portion includes offline variable
- substitution algorithms intended to computer pointer and location
- equivalences. Pointer equivalences are those pointers that will have the
- same points-to sets, and location equivalences are those variables that
- always appear together in points-to sets.
- </p>
-
- <p>
- The inclusion constraint solving phase iteratively propagates the inclusion
- constraints until a fixed point is reached. This is an O(<var>n</var>³)
- algorithm.
- </p>
-
- <p>
- Function constraints are handled as if they were structs with <var>X</var>
- fields. Thus, an access to argument <var>X</var> of function <var>Y</var> is
- an access to node index <code>getNode(<var>Y</var>) + <var>X</var></code>.
- This representation allows handling of indirect calls without any issues. To
- wit, an indirect call <code><var>Y</var>(<var>a</var>,<var>b</var>)</code> is
- equivalent to <code>*(<var>Y</var> + 1) = <var>a</var>, *(<var>Y</var> + 2) =
- <var>b</var></code>. The return node for a function <var>F</var> is always
- located at <code>getNode(<var>F</var>) + CallReturnPos</code>. The arguments
- start at <code>getNode(<var>F</var>) + CallArgPos</code>.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="basicaa">Basic Alias Analysis (default AA impl)</a>
-</div>
-<div class="doc_text">
- <p>
- This is the default implementation of the Alias Analysis interface
- that simply implements a few identities (two different globals cannot alias,
- etc), but otherwise does no analysis.
- </p>
+<h3>
+ <a name="basicaa">-basicaa: Basic Alias Analysis (stateless AA impl)</a>
+</h3>
+<div>
+ <p>A basic alias analysis pass that implements identities (two different
+ globals cannot alias, etc), but does no stateful analysis.</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="basiccg">Basic CallGraph Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="basiccg">-basiccg: Basic CallGraph Construction</a>
+</h3>
+<div>
<p>Yet to be written.</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="basicvn">Basic Value Numbering (default Value Numbering impl)</a>
-</div>
-<div class="doc_text">
- <p>
- This is the default implementation of the <code>ValueNumbering</code>
- interface. It walks the SSA def-use chains to trivially identify
- lexically identical expressions. This does not require any ahead of time
- analysis, so it is a very fast default implementation.
- </p>
- <p>
- The ValueNumbering analysis passes are mostly deprecated. They are only used
- by the <a href="#gcse">Global Common Subexpression Elimination pass</a>, which
- is deprecated by the <a href="#gvn">Global Value Numbering pass</a> (which
- does its value numbering on its own).
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="codegenprepare">Optimize for code generation</a>
-</div>
-<div class="doc_text">
- <p>
- This pass munges the code in the input function to better prepare it for
- SelectionDAG-based code generation. This works around limitations in it's
- basic-block-at-a-time approach. It should eventually be removed.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="count-aa">Count Alias Analysis Query Responses</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="count-aa">-count-aa: Count Alias Analysis Query Responses</a>
+</h3>
+<div>
<p>
A pass which can be used to count how many alias queries
are being made and how the alias analysis implementation being used responds.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="debug-aa">AA use debugger</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="debug-aa">-debug-aa: AA use debugger</a>
+</h3>
+<div>
<p>
This simple pass checks alias analysis users to ensure that if they
create a new value, they do not query AA without informing it of the value.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="domfrontier">Dominance Frontier Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="domfrontier">-domfrontier: Dominance Frontier Construction</a>
+</h3>
+<div>
<p>
This pass is a simple dominator construction algorithm for finding forward
dominator frontiers.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="domtree">Dominator Tree Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="domtree">-domtree: Dominator Tree Construction</a>
+</h3>
+<div>
<p>
This pass is a simple dominator construction algorithm for finding forward
dominators.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="dot-callgraph">Print Call Graph to 'dot' file</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="dot-callgraph">-dot-callgraph: Print Call Graph to 'dot' file</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints the call graph into a
<code>.dot</code> graph. This graph can then be processed with the "dot" tool
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="dot-cfg">Print CFG of function to 'dot' file</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="dot-cfg">-dot-cfg: Print CFG of function to 'dot' file</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints the control flow graph
into a <code>.dot</code> graph. This graph can then be processed with the
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="dot-cfg-only">Print CFG of function to 'dot' file (with no function bodies)</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="dot-cfg-only">-dot-cfg-only: Print CFG of function to 'dot' file (with no function bodies)</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints the control flow graph
into a <code>.dot</code> graph, omitting the function bodies. This graph can
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="globalsmodref-aa">Simple mod/ref analysis for globals</a>
+<h3>
+ <a name="dot-dom">-dot-dom: Print dominance tree of function to 'dot' file</a>
+</h3>
+<div>
+ <p>
+ This pass, only available in <code>opt</code>, prints the dominator tree
+ into a <code>.dot</code> graph. This graph can then be processed with the
+ "dot" tool to convert it to postscript or some other suitable format.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="dot-dom-only">-dot-dom-only: Print dominance tree of function to 'dot' file (with no function bodies)</a>
+</h3>
+<div>
+ <p>
+ This pass, only available in <code>opt</code>, prints the dominator tree
+ into a <code>.dot</code> graph, omitting the function bodies. This graph can
+ then be processed with the "dot" tool to convert it to postscript or some
+ other suitable format.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="dot-postdom">-dot-postdom: Print postdominance tree of function to 'dot' file</a>
+</h3>
+<div>
+ <p>
+ This pass, only available in <code>opt</code>, prints the post dominator tree
+ into a <code>.dot</code> graph. This graph can then be processed with the
+ "dot" tool to convert it to postscript or some other suitable format.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="dot-postdom-only">-dot-postdom-only: Print postdominance tree of function to 'dot' file (with no function bodies)</a>
+</h3>
+<div>
+ <p>
+ This pass, only available in <code>opt</code>, prints the post dominator tree
+ into a <code>.dot</code> graph, omitting the function bodies. This graph can
+ then be processed with the "dot" tool to convert it to postscript or some
+ other suitable format.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="globalsmodref-aa">-globalsmodref-aa: Simple mod/ref analysis for globals</a>
+</h3>
+<div>
<p>
This simple pass provides alias and mod/ref information for global values
that do not have their address taken, and keeps track of whether functions
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="instcount">Counts the various types of Instructions</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="instcount">-instcount: Counts the various types of Instructions</a>
+</h3>
+<div>
<p>
This pass collects the count of all instructions and reports them
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="intervals">Interval Partition Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="intervals">-intervals: Interval Partition Construction</a>
+</h3>
+<div>
<p>
This analysis calculates and represents the interval partition of a function,
or a preexisting interval partition.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="load-vn">Load Value Numbering</a>
+<h3>
+ <a name="iv-users">-iv-users: Induction Variable Users</a>
+</h3>
+<div>
+ <p>Bookkeeping for "interesting" users of expressions computed from
+ induction variables.</p>
</div>
-<div class="doc_text">
- <p>
- This pass value numbers load and call instructions. To do this, it finds
- lexically identical load instructions, and uses alias analysis to determine
- which loads are guaranteed to produce the same value. To value number call
- instructions, it looks for calls to functions that do not write to memory
- which do not have intervening instructions that clobber the memory that is
- read from.
- </p>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="lazy-value-info">-lazy-value-info: Lazy Value Information Analysis</a>
+</h3>
+<div>
+ <p>Interface for lazy computation of value constraint information.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="lda">-lda: Loop Dependence Analysis</a>
+</h3>
+<div>
+ <p>Loop dependence analysis framework, which is used to detect dependences in
+ memory accesses in loops.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="libcall-aa">-libcall-aa: LibCall Alias Analysis</a>
+</h3>
+<div>
+ <p>LibCall Alias Analysis.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="lint">-lint: Statically lint-checks LLVM IR</a>
+</h3>
+<div>
+ <p>This pass statically checks for common and easily-identified constructs
+ which produce undefined or likely unintended behavior in LLVM IR.</p>
+
+ <p>It is not a guarantee of correctness, in two ways. First, it isn't
+ comprehensive. There are checks which could be done statically which are
+ not yet implemented. Some of these are indicated by TODO comments, but
+ those aren't comprehensive either. Second, many conditions cannot be
+ checked statically. This pass does no dynamic instrumentation, so it
+ can't check for all possible problems.</p>
- <p>
- This pass builds off of another value numbering pass to implement value
- numbering for non-load and non-call instructions. It uses Alias Analysis so
- that it can disambiguate the load instructions. The more powerful these base
- analyses are, the more powerful the resultant value numbering will be.
+ <p>Another limitation is that it assumes all code will be executed. A store
+ through a null pointer in a basic block which is never reached is harmless,
+ but this pass will warn about it anyway.</p>
+
+ <p>Optimization passes may make conditions that this pass checks for more or
+ less obvious. If an optimization pass appears to be introducing a warning,
+ it may be that the optimization pass is merely exposing an existing
+ condition in the code.</p>
+
+ <p>This code may be run before instcombine. In many cases, instcombine checks
+ for the same kinds of things and turns instructions with undefined behavior
+ into unreachable (or equivalent). Because of this, this pass makes some
+ effort to look through bitcasts and so on.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loops">Natural Loop Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loops">-loops: Natural Loop Information</a>
+</h3>
+<div>
<p>
This analysis is used to identify natural loops and determine the loop depth
of various nodes of the CFG. Note that the loops identified may actually be
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="memdep">Memory Dependence Analysis</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="memdep">-memdep: Memory Dependence Analysis</a>
+</h3>
+<div>
<p>
An analysis that determines, for a given memory operation, what preceding
memory operations it depends on. It builds on alias analysis information, and
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="no-aa">No Alias Analysis (always returns 'may' alias)</a>
+<h3>
+ <a name="module-debuginfo">-module-debuginfo: Decodes module-level debug info</a>
+</h3>
+<div>
+ <p>This pass decodes the debug info metadata in a module and prints in a
+ (sufficiently-prepared-) human-readable form.
+
+ For example, run this pass from opt along with the -analyze option, and
+ it'll print to standard output.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="no-aa">-no-aa: No Alias Analysis (always returns 'may' alias)</a>
+</h3>
+<div>
<p>
- Always returns "I don't know" for alias queries. NoAA is unlike other alias
- analysis implementations, in that it does not chain to a previous analysis. As
- such it doesn't follow many of the rules that other alias analyses must.
+ This is the default implementation of the Alias Analysis interface. It always
+ returns "I don't know" for alias queries. NoAA is unlike other alias analysis
+ implementations, in that it does not chain to a previous analysis. As such it
+ doesn't follow many of the rules that other alias analyses must.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="no-profile">No Profile Information</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="no-profile">-no-profile: No Profile Information</a>
+</h3>
+<div>
<p>
The default "no profile" implementation of the abstract
<code>ProfileInfo</code> interface.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="postdomfrontier">Post-Dominance Frontier Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="postdomfrontier">-postdomfrontier: Post-Dominance Frontier Construction</a>
+</h3>
+<div>
<p>
This pass is a simple post-dominator construction algorithm for finding
post-dominator frontiers.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="postdomtree">Post-Dominator Tree Construction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="postdomtree">-postdomtree: Post-Dominator Tree Construction</a>
+</h3>
+<div>
<p>
This pass is a simple post-dominator construction algorithm for finding
post-dominators.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-alias-sets">Alias Set Printer</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-alias-sets">-print-alias-sets: Alias Set Printer</a>
+</h3>
+<div>
<p>Yet to be written.</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-callgraph">Print a call graph</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-callgraph">-print-callgraph: Print a call graph</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints the call graph to
- standard output in a human-readable form.
+ standard error in a human-readable form.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-callgraph-sccs">Print SCCs of the Call Graph</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-callgraph-sccs">-print-callgraph-sccs: Print SCCs of the Call Graph</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints the SCCs of the call
- graph to standard output in a human-readable form.
+ graph to standard error in a human-readable form.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-cfg-sccs">Print SCCs of each function CFG</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-cfg-sccs">-print-cfg-sccs: Print SCCs of each function CFG</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints the SCCs of each
- function CFG to standard output in a human-readable form.
+ function CFG to standard error in a human-readable form.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-externalfnconstants">Print external fn callsites passed constants</a>
+<h3>
+ <a name="print-dbginfo">-print-dbginfo: Print debug info in human readable form</a>
+</h3>
+<div>
+ <p>Pass that prints instructions, and associated debug info:</p>
+ <ul>
+
+ <li>source/line/col information</li>
+ <li>original variable name</li>
+ <li>original type name</li>
+ </ul>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="print-dom-info">-print-dom-info: Dominator Info Printer</a>
+</h3>
+<div>
+ <p>Dominator Info Printer.</p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="print-externalfnconstants">-print-externalfnconstants: Print external fn callsites passed constants</a>
+</h3>
+<div>
<p>
This pass, only available in <code>opt</code>, prints out call sites to
external functions that are called with constant arguments. This can be
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-function">Print function to stderr</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-function">-print-function: Print function to stderr</a>
+</h3>
+<div>
<p>
The <code>PrintFunctionPass</code> class is designed to be pipelined with
other <code>FunctionPass</code>es, and prints out the functions of the module
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-module">Print module to stderr</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-module">-print-module: Print module to stderr</a>
+</h3>
+<div>
<p>
This pass simply prints out the entire module when it is executed.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="print-used-types">Find Used Types</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="print-used-types">-print-used-types: Find Used Types</a>
+</h3>
+<div>
<p>
This pass is used to seek out all of the types in use by the program. Note
that this analysis explicitly does not include types only used by the symbol
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="profile-loader">Load profile information from llvmprof.out</a>
+<h3>
+ <a name="profile-estimator">-profile-estimator: Estimate profiling information</a>
+</h3>
+<div>
+ <p>Profiling information that estimates the profiling information
+ in a very crude and unimaginative way.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="profile-loader">-profile-loader: Load profile information from llvmprof.out</a>
+</h3>
+<div>
<p>
A concrete implementation of profiling information that loads the information
from a profile dump file.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="scalar-evolution">Scalar Evolution Analysis</a>
+<h3>
+ <a name="profile-verifier">-profile-verifier: Verify profiling information</a>
+</h3>
+<div>
+ <p>Pass that checks profiling information for plausibility.</p>
+</div>
+<h3>
+ <a name="regions">-regions: Detect single entry single exit regions</a>
+</h3>
+<div>
+ <p>
+ The <code>RegionInfo</code> pass detects single entry single exit regions in a
+ function, where a region is defined as any subgraph that is connected to the
+ remaining graph at only two spots. Furthermore, an hierarchical region tree is
+ built.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="scalar-evolution">-scalar-evolution: Scalar Evolution Analysis</a>
+</h3>
+<div>
<p>
The <code>ScalarEvolution</code> analysis can be used to analyze and
catagorize scalar expressions in loops. It specializes in recognizing general
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="targetdata">Target Data Layout</a>
+<h3>
+ <a name="scev-aa">-scev-aa: ScalarEvolution-based Alias Analysis</a>
+</h3>
+<div>
+ <p>Simple alias analysis implemented in terms of ScalarEvolution queries.
+
+ This differs from traditional loop dependence analysis in that it tests
+ for dependencies within a single iteration of a loop, rather than
+ dependencies between different iterations.
+
+ ScalarEvolution has a more complete understanding of pointer arithmetic
+ than BasicAliasAnalysis' collection of ad-hoc analyses.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="targetdata">-targetdata: Target Data Layout</a>
+</h3>
+<div>
<p>Provides other passes access to information on how the size and alignment
required by the the target ABI for various data types.</p>
</div>
+</div>
+
<!-- ======================================================================= -->
-<div class="doc_section"> <a name="transform">Transform Passes</a></div>
-<div class="doc_text">
+<h2><a name="transforms">Transform Passes</a></h2>
+<div>
<p>This section describes the LLVM Transform Passes.</p>
-</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="adce">Aggressive Dead Code Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="adce">-adce: Aggressive Dead Code Elimination</a>
+</h3>
+<div>
<p>ADCE aggressively tries to eliminate code. This pass is similar to
<a href="#dce">DCE</a> but it assumes that values are dead until proven
otherwise. This is similar to <a href="#sccp">SCCP</a>, except applied to
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="argpromotion">Promote 'by reference' arguments to scalars</a>
+<h3>
+ <a name="always-inline">-always-inline: Inliner for always_inline functions</a>
+</h3>
+<div>
+ <p>A custom inliner that handles only functions that are marked as
+ "always inline".</p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="argpromotion">-argpromotion: Promote 'by reference' arguments to scalars</a>
+</h3>
+<div>
<p>
This pass promotes "by reference" arguments to be "by value" arguments. In
practice, this means looking for internal functions that have pointer
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="block-placement">Profile Guided Basic Block Placement</a>
+<h3>
+ <a name="bb-vectorize">-bb-vectorize: Basic-Block Vectorization</a>
+</h3>
+<div>
+ <p>This pass combines instructions inside basic blocks to form vector
+ instructions. It iterates over each basic block, attempting to pair
+ compatible instructions, repeating this process until no additional
+ pairs are selected for vectorization. When the outputs of some pair
+ of compatible instructions are used as inputs by some other pair of
+ compatible instructions, those pairs are part of a potential
+ vectorization chain. Instruction pairs are only fused into vector
+ instructions when they are part of a chain longer than some
+ threshold length. Moreover, the pass attempts to find the best
+ possible chain for each pair of compatible instructions. These
+ heuristics are intended to prevent vectorization in cases where
+ it would not yield a performance increase of the resulting code.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="block-placement">-block-placement: Profile Guided Basic Block Placement</a>
+</h3>
+<div>
<p>This pass is a very simple profile guided basic block placement algorithm.
The idea is to put frequently executed blocks together at the start of the
function and hopefully increase the number of fall-through conditional
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="break-crit-edges">Break critical edges in CFG</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="break-crit-edges">-break-crit-edges: Break critical edges in CFG</a>
+</h3>
+<div>
<p>
Break all of the critical edges in the CFG by inserting a dummy basic block.
It may be "required" by passes that cannot deal with critical edges. This
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="codegenprepare">Prepare a function for code generation</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="codegenprepare">-codegenprepare: Optimize for code generation</a>
+</h3>
+<div>
This pass munges the code in the input function to better prepare it for
SelectionDAG-based code generation. This works around limitations in it's
basic-block-at-a-time approach. It should eventually be removed.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="condprop">Conditional Propagation</a>
-</div>
-<div class="doc_text">
- <p>This pass propagates information about conditional expressions through the
- program, allowing it to eliminate conditional branches in some cases.</p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="constmerge">Merge Duplicate Global Constants</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="constmerge">-constmerge: Merge Duplicate Global Constants</a>
+</h3>
+<div>
<p>
Merges duplicate global constants together into a single constant that is
shared. This is useful because some passes (ie TraceValues) insert a lot of
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="constprop">Simple constant propagation</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="constprop">-constprop: Simple constant propagation</a>
+</h3>
+<div>
<p>This file implements constant propagation and merging. It looks for
instructions involving only constant operands and replaces them with a
constant value instead of an instruction. For example:</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="dce">Dead Code Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="dce">-dce: Dead Code Elimination</a>
+</h3>
+<div>
<p>
Dead code elimination is similar to <a href="#die">dead instruction
elimination</a>, but it rechecks instructions that were used by removed
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="deadargelim">Dead Argument Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="deadargelim">-deadargelim: Dead Argument Elimination</a>
+</h3>
+<div>
<p>
This pass deletes dead arguments from internal functions. Dead argument
elimination removes arguments which are directly dead, as well as arguments
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="deadtypeelim">Dead Type Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="deadtypeelim">-deadtypeelim: Dead Type Elimination</a>
+</h3>
+<div>
<p>
This pass is used to cleanup the output of GCC. It eliminate names for types
that are unused in the entire translation unit, using the <a
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="die">Dead Instruction Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="die">-die: Dead Instruction Elimination</a>
+</h3>
+<div>
<p>
Dead instruction elimination performs a single pass over the function,
removing instructions that are obviously dead.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="dse">Dead Store Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="dse">-dse: Dead Store Elimination</a>
+</h3>
+<div>
<p>
A trivial dead store elimination that only considers basic-block local
redundant stores.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="gcse">Global Common Subexpression Elimination</a>
-</div>
-<div class="doc_text">
- <p>
- This pass is designed to be a very quick global transformation that
- eliminates global common subexpressions from a function. It does this by
- using an existing value numbering analysis pass to identify the common
- subexpressions, eliminating them when possible.
- </p>
- <p>
- This pass is deprecated by the <a href="#gvn">Global Value Numbering pass</a>
- (which does a better job with its own value numbering).
+<h3>
+ <a name="functionattrs">-functionattrs: Deduce function attributes</a>
+</h3>
+<div>
+ <p>A simple interprocedural pass which walks the call-graph, looking for
+ functions which do not access or only read non-local memory, and marking them
+ readnone/readonly. In addition, it marks function arguments (of pointer type)
+ 'nocapture' if a call to the function does not create any copies of the pointer
+ value that outlive the call. This more or less means that the pointer is only
+ dereferenced, and not returned from the function or stored in a global.
+ This pass is implemented as a bottom-up traversal of the call-graph.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="globaldce">Dead Global Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="globaldce">-globaldce: Dead Global Elimination</a>
+</h3>
+<div>
<p>
This transform is designed to eliminate unreachable internal globals from the
program. It uses an aggressive algorithm, searching out globals that are
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="globalopt">Global Variable Optimizer</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="globalopt">-globalopt: Global Variable Optimizer</a>
+</h3>
+<div>
<p>
This pass transforms simple global variables that never have their address
taken. If obviously true, it marks read/write globals as constant, deletes
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="gvn">Global Value Numbering</a>
-</div>
-<div class="doc_text">
- <p>
- This pass performs global value numbering to eliminate fully redundant
- instructions. It also performs simple dead load elimination.
- </p>
- <p>
- Note that this pass does the value numbering itself, it does not use the
- ValueNumbering analysis passes.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="gvnpre">Global Value Numbering/Partial Redundancy Elimination</a>
-</div>
-<div class="doc_text">
- <p>
- This pass performs a hybrid of global value numbering and partial redundancy
- elimination, known as GVN-PRE. It performs partial redundancy elimination on
- values, rather than lexical expressions, allowing a more comprehensive view
- the optimization. It replaces redundant values with uses of earlier
- occurences of the same value. While this is beneficial in that it eliminates
- unneeded computation, it also increases register pressure by creating large
- live ranges, and should be used with caution on platforms that are very
- sensitive to register pressure.
- </p>
- <p>
- Note that this pass does the value numbering itself, it does not use the
- ValueNumbering analysis passes.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="indmemrem">Indirect Malloc and Free Removal</a>
-</div>
-<div class="doc_text">
- <p>
- This pass finds places where memory allocation functions may escape into
- indirect land. Some transforms are much easier (aka possible) only if free
- or malloc are not called indirectly.
- </p>
-
+<h3>
+ <a name="gvn">-gvn: Global Value Numbering</a>
+</h3>
+<div>
<p>
- Thus find places where the address of memory functions are taken and construct
- bounce functions with direct calls of those functions.
+ This pass performs global value numbering to eliminate fully and partially
+ redundant instructions. It also performs redundant load elimination.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="indvars">Canonicalize Induction Variables</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="indvars">-indvars: Canonicalize Induction Variables</a>
+</h3>
+<div>
<p>
This transformation analyzes and transforms the induction variables (and
computations derived from them) into simpler forms suitable for subsequent
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="inline">Function Integration/Inlining</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="inline">-inline: Function Integration/Inlining</a>
+</h3>
+<div>
<p>
Bottom-up inlining of functions into callees.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="insert-block-profiling">Insert instrumentation for block profiling</a>
-</div>
-<div class="doc_text">
- <p>
- This pass instruments the specified program with counters for basic block
- profiling, which counts the number of times each basic block executes. This
- is the most basic form of profiling, which can tell which blocks are hot, but
- cannot reliably detect hot paths through the CFG.
- </p>
-
- <p>
- Note that this implementation is very naïve. Control equivalent regions of
- the CFG should not require duplicate counters, but it does put duplicate
- counters in.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="insert-edge-profiling">Insert instrumentation for edge profiling</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="insert-edge-profiling">-insert-edge-profiling: Insert instrumentation for edge profiling</a>
+</h3>
+<div>
<p>
This pass instruments the specified program with counters for edge profiling.
Edge profiling can give a reasonable approximation of the hot paths through a
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="insert-function-profiling">Insert instrumentation for function profiling</a>
-</div>
-<div class="doc_text">
- <p>
- This pass instruments the specified program with counters for function
- profiling, which counts the number of times each function is called.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="insert-null-profiling-rs">Measure profiling framework overhead</a>
-</div>
-<div class="doc_text">
- <p>
- The basic profiler that does nothing. It is the default profiler and thus
- terminates <code>RSProfiler</code> chains. It is useful for measuring
- framework overhead.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="insert-rs-profiling-framework">Insert random sampling instrumentation framework</a>
-</div>
-<div class="doc_text">
- <p>
- The second stage of the random-sampling instrumentation framework, duplicates
- all instructions in a function, ignoring the profiling code, then connects the
- two versions together at the entry and at backedges. At each connection point
- a choice is made as to whether to jump to the profiled code (take a sample) or
- execute the unprofiled code.
- </p>
-
- <p>
- After this pass, it is highly recommended to run<a href="#mem2reg">mem2reg</a>
- and <a href="#adce">adce</a>. <a href="#instcombine">instcombine</a>,
- <a href="#load-vn">load-vn</a>, <a href="#gdce">gdce</a>, and
- <a href="#dse">dse</a> also are good to run afterwards.
+<h3>
+ <a name="insert-optimal-edge-profiling">-insert-optimal-edge-profiling: Insert optimal instrumentation for edge profiling</a>
+</h3>
+<div>
+ <p>This pass instruments the specified program with counters for edge profiling.
+ Edge profiling can give a reasonable approximation of the hot paths through a
+ program, and is used for a wide variety of program transformations.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="instcombine">Combine redundant instructions</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="instcombine">-instcombine: Combine redundant instructions</a>
+</h3>
+<div>
<p>
Combine instructions to form fewer, simple
instructions. This pass does not modify the CFG This pass is where algebraic
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="internalize">Internalize Global Symbols</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="internalize">-internalize: Internalize Global Symbols</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="ipconstprop">Interprocedural constant propagation</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="ipconstprop">-ipconstprop: Interprocedural constant propagation</a>
+</h3>
+<div>
<p>
This pass implements an <em>extremely</em> simple interprocedural constant
propagation pass. It could certainly be improved in many different ways,
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="ipsccp">Interprocedural Sparse Conditional Constant Propagation</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="ipsccp">-ipsccp: Interprocedural Sparse Conditional Constant Propagation</a>
+</h3>
+<div>
<p>
An interprocedural variant of <a href="#sccp">Sparse Conditional Constant
Propagation</a>.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="jump-threading">Thread control through conditional blocks</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="jump-threading">-jump-threading: Jump Threading</a>
+</h3>
+<div>
<p>
Jump threading tries to find distinct threads of control flow running through
a basic block. This pass looks at blocks that have multiple predecessors and
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lcssa">Loop-Closed SSA Form Pass</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="lcssa">-lcssa: Loop-Closed SSA Form Pass</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="licm">Loop Invariant Code Motion</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="licm">-licm: Loop Invariant Code Motion</a>
+</h3>
+<div>
<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
variable.</li>
</ul>
</div>
+
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-deletion">Dead Loop Deletion Pass</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-deletion">-loop-deletion: Delete dead loops</a>
+</h3>
+<div>
<p>
This file implements the Dead Loop Deletion Pass. This pass is responsible
for eliminating loops with non-infinite computable trip counts that have no
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-extract">Extract loops into new functions</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-extract">-loop-extract: Extract loops into new functions</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-extract-single">Extract at most one loop into a new function</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-extract-single">-loop-extract-single: Extract at most one loop into a new function</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-index-split">Index Split Loops</a>
-</div>
-<div class="doc_text">
- <p>
- This pass divides loop's iteration range by spliting loop such that each
- individual loop is executed efficiently.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-reduce">Loop Strength Reduction</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-reduce">-loop-reduce: Loop Strength Reduction</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-rotate">Rotate Loops</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-rotate">-loop-rotate: Rotate Loops</a>
+</h3>
+<div>
<p>A simple loop rotation transformation.</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-unroll">Unroll loops</a>
-</div>
-<div class="doc_text">
- <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>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loop-unswitch">Unswitch loops</a>
-</div>
-<div class="doc_text">
- <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>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="loopsimplify">Canonicalize natural loops</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-simplify">-loop-simplify: Canonicalize natural loops</a>
+</h3>
+<div>
<p>
This pass performs several transformations to transform natural loops into a
simpler form, which makes subsequent analyses and transformations simpler and
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lowerallocs">Lower allocations from instructions to calls</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="loop-unroll">-loop-unroll: Unroll loops</a>
+</h3>
+<div>
<p>
- Turn <tt>malloc</tt> and <tt>free</tt> instructions into <tt>@malloc</tt> and
- <tt>@free</tt> calls.
+ 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>
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="loop-unswitch">-loop-unswitch: Unswitch loops</a>
+</h3>
+<div>
+ <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 is a target-dependent tranformation because it depends on the size of
- data types and alignment constraints.
+ 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>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lowerinvoke">Lower invoke and unwind, for unwindless code generators</a>
+<h3>
+ <a name="loweratomic">-loweratomic: Lower atomic intrinsics to non-atomic form</a>
+</h3>
+<div>
+ <p>
+ This pass lowers atomic intrinsics to non-atomic form for use in a known
+ non-preemptible environment.
+ </p>
+
+ <p>
+ The pass does not verify that the environment is non-preemptible (in
+ general this would require knowledge of the entire call graph of the
+ program including any libraries which may not be available in bitcode form);
+ it simply lowers every atomic intrinsic.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="lowerinvoke">-lowerinvoke: Lower invoke and unwind, for unwindless code generators</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lowersetjmp">Lower Set Jump</a>
-</div>
-<div class="doc_text">
- <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>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lowerswitch">Lower SwitchInst's to branches</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="lowerswitch">-lowerswitch: Lower SwitchInst's to branches</a>
+</h3>
+<div>
<p>
Rewrites <tt>switch</tt> instructions with a sequence of branches, which
allows targets to get away with not implementing the switch instruction until
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="mem2reg">Promote Memory to Register</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="mem2reg">-mem2reg: Promote Memory to Register</a>
+</h3>
+<div>
<p>
This file promotes memory references to be register references. It promotes
<tt>alloca</tt> instructions which only have <tt>load</tt>s and
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="memcpyopt">Optimize use of memcpy and friend</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="memcpyopt">-memcpyopt: MemCpy Optimization</a>
+</h3>
+<div>
<p>
This pass performs various transformations related to eliminating memcpy
calls, or transforming sets of stores into memset's.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="mergereturn">Unify function exit nodes</a>
+<h3>
+ <a name="mergefunc">-mergefunc: Merge Functions</a>
+</h3>
+<div>
+ <p>This pass looks for equivalent functions that are mergable and folds them.
+
+ A hash is computed from the function, based on its type and number of
+ basic blocks.
+
+ Once all hashes are computed, we perform an expensive equality comparison
+ on each function pair. This takes n^2/2 comparisons per bucket, so it's
+ important that the hash function be high quality. The equality comparison
+ iterates through each instruction in each basic block.
+
+ When a match is found the functions are folded. If both functions are
+ overridable, we move the functionality into a new internal function and
+ leave two overridable thunks to it.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="mergereturn">-mergereturn: Unify function exit nodes</a>
+</h3>
+<div>
<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.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="predsimplify">Predicate Simplifier</a>
-</div>
-<div class="doc_text">
- <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:
+<h3>
+ <a name="partial-inliner">-partial-inliner: Partial Inliner</a>
+</h3>
+<div>
+ <p>This pass performs partial inlining, typically by inlining an if
+ statement that surrounds the body of the function.
</p>
-
-<blockquote><pre
->void test(int *p, int *q)
-{
- if (p != q)
- return;
-
- if (*p != *q)
- foo(); // unreachable
-}</pre></blockquote>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="prune-eh">Remove unused exception handling info</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="prune-eh">-prune-eh: Remove unused exception handling info</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="raiseallocs">Raise allocations from calls to instructions</a>
-</div>
-<div class="doc_text">
- <p>
- Converts <tt>@malloc</tt> and <tt>@free</tt> calls to <tt>malloc</tt> and
- <tt>free</tt> instructions.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="reassociate">Reassociate expressions</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="reassociate">-reassociate: Reassociate expressions</a>
+</h3>
+<div>
<p>
This pass reassociates commutative expressions in an order that is designed
to promote better constant propagation, GCSE, LICM, PRE, etc.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="reg2mem">Demote all values to stack slots</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="reg2mem">-reg2mem: Demote all values to stack slots</a>
+</h3>
+<div>
<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>load</tt> instructions, the only values live across 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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="scalarrepl">Scalar Replacement of Aggregates</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="scalarrepl">-scalarrepl: Scalar Replacement of Aggregates (DT)</a>
+</h3>
+<div>
<p>
The well-known scalar replacement of aggregates transformation. This
transform breaks up <tt>alloca</tt> instructions of aggregate type (structure
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="sccp">Sparse Conditional Constant Propagation</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="sccp">-sccp: Sparse Conditional Constant Propagation</a>
+</h3>
+<div>
<p>
Sparse conditional constant propagation and merging, which can be summarized
as:
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="simplify-libcalls">Simplify well-known library calls</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="simplify-libcalls">-simplify-libcalls: Simplify well-known library calls</a>
+</h3>
+<div>
<p>
Applies a variety of small optimizations for calls to specific well-known
function calls (e.g. runtime library functions). For example, a call
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="simplifycfg">Simplify the CFG</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="simplifycfg">-simplifycfg: Simplify the CFG</a>
+</h3>
+<div>
<p>
Performs dead code elimination and basic block merging. Specifically:
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="strip">Strip all symbols from a module</a>
+<h3>
+ <a name="sink">-sink: Code sinking</a>
+</h3>
+<div>
+ <p>This pass moves instructions into successor blocks, when possible, so that
+ they aren't executed on paths where their results aren't needed.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="sretpromotion">-sretpromotion: Promote sret arguments to multiple ret values</a>
+</h3>
+<div>
+ <p>
+ This pass finds functions that return a struct (using a pointer to the struct
+ as the first argument of the function, marked with the '<tt>sret</tt>' attribute) and
+ replaces them with a new function that simply returns each of the elements of
+ that struct (using multiple return values).
+ </p>
+
<p>
- Performs code stripping. This transformation can delete:
+ This pass works under a number of conditions:
+ </p>
+
+ <ul>
+ <li>The returned struct must not contain other structs</li>
+ <li>The returned struct must only be used to load values from</li>
+ <li>The placeholder struct passed in is the result of an <tt>alloca</tt></li>
+ </ul>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="strip">-strip: Strip all symbols from a module</a>
+</h3>
+<div>
+ <p>
+ performs code stripping. this transformation can delete:
</p>
<ol>
</ol>
<p>
- Note that this transformation makes code much less readable, so it should
+ 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>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="strip-dead-prototypes">Remove unused function declarations</a>
+<h3>
+ <a name="strip-dead-debug-info">-strip-dead-debug-info: Strip debug info for unused symbols</a>
+</h3>
+<div>
+ <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>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="strip-dead-prototypes">-strip-dead-prototypes: Strip Unused Function Prototypes</a>
+</h3>
+<div>
<p>
This pass loops over all of the functions in the input module, looking for
dead declarations and removes them. Dead declarations are declarations of
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="sretpromotion">Promote sret arguments</a>
-</div>
-<div class="doc_text">
- <p>
- This pass finds functions that return a struct (using a pointer to the struct
- as the first argument of the function, marked with the '<tt>sret</tt>' attribute) and
- replaces them with a new function that simply returns each of the elements of
- that struct (using multiple return values).
- </p>
-
+<h3>
+ <a name="strip-debug-declare">-strip-debug-declare: Strip all llvm.dbg.declare intrinsics</a>
+</h3>
+<div>
+ <p>This pass implements code stripping. Specifically, it can delete:</p>
+ <ul>
+ <li>names for virtual registers</li>
+ <li>symbols for internal globals and functions</li>
+ <li>debug information</li>
+ </ul>
<p>
- This pass works under a number of conditions:
+ Note that this transformation makes code much less readable, so it should
+ only be used in situations where the 'strip' utility would be used, such as
+ reducing code size or making it harder to reverse engineer code.
</p>
+</div>
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="strip-nondebug">-strip-nondebug: Strip all symbols, except dbg symbols, from a module</a>
+</h3>
+<div>
+ <p>This pass implements code stripping. Specifically, it can delete:</p>
<ul>
- <li>The returned struct must not contain other structs</li>
- <li>The returned struct must only be used to load values from</li>
- <li>The placeholder struct passed in is the result of an <tt>alloca</tt></li>
+ <li>names for virtual registers</li>
+ <li>symbols for internal globals and functions</li>
+ <li>debug information</li>
</ul>
+ <p>
+ Note that this transformation makes code much less readable, so it should
+ only be used in situations where the 'strip' utility would be used, such as
+ reducing code size or making it harder to reverse engineer code.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="tailcallelim">Tail Call Elimination</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="tailcallelim">-tailcallelim: Tail Call Elimination</a>
+</h3>
+<div>
<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
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="tailduplicate">Tail Duplication</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="tailduplicate">-tailduplicate: Tail Duplication</a>
+</h3>
+<div>
<p>
This pass performs a limited form of tail duplication, intended to simplify
CFGs by removing some unconditional branches. This pass is necessary to
</p>
</div>
+</div>
+
<!-- ======================================================================= -->
-<div class="doc_section"> <a name="transform">Utility Passes</a></div>
-<div class="doc_text">
+<h2><a name="utilities">Utility Passes</a></h2>
+<div>
<p>This section describes the LLVM Utility Passes.</p>
-</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="deadarghaX0r">Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="deadarghaX0r">-deadarghaX0r: Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)</a>
+</h3>
+<div>
<p>
Same as dead argument elimination, but deletes arguments to functions which
are external. This is only for use by <a
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="extract-blocks">Extract Basic Blocks From Module (for bugpoint use)</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="extract-blocks">-extract-blocks: Extract Basic Blocks From Module (for bugpoint use)</a>
+</h3>
+<div>
<p>
This pass is used by bugpoint to extract all blocks from the module into their
own functions.</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="preverify">Preliminary module verification</a>
+<h3>
+ <a name="instnamer">-instnamer: Assign names to anonymous instructions</a>
+</h3>
+<div>
+ <p>This is a little utility pass that gives instructions names, this is mostly
+ useful when diffing the effect of an optimization because deleting an
+ unnamed instruction can change all other instruction numbering, making the
+ diff very noisy.
+ </p>
</div>
-<div class="doc_text">
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="preverify">-preverify: Preliminary module verification</a>
+</h3>
+<div>
<p>
Ensures that the module is in the form required by the <a
href="#verifier">Module Verifier</a> pass.
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="verify">Module Verifier</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="verify">-verify: Module Verifier</a>
+</h3>
+<div>
<p>
Verifies an LLVM IR code. This is useful to run after an optimization which is
undergoing testing. Note that <tt>llvm-as</tt> verifies its input before
integrals f.e.</li>
<li>All of the constants in a switch statement are of the correct type.</li>
<li>The code is in valid SSA form.</li>
- <li>It should be illegal to put a label into any other type (like a
- structure) or to return one. [except constant arrays!]</li>
+ <li>It is illegal to put a label into any other type (like a structure) or
+ to return one.</li>
<li>Only phi nodes can be self referential: <tt>%x = add i32 %x, %x</tt> is
invalid.</li>
<li>PHI nodes must have an entry for each predecessor, with no extras.</li>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="view-cfg">View CFG of function</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="view-cfg">-view-cfg: View CFG of function</a>
+</h3>
+<div>
<p>
Displays the control flow graph using the GraphViz tool.
</p>
</div>
<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="view-cfg-only">View CFG of function (with no function bodies)</a>
-</div>
-<div class="doc_text">
+<h3>
+ <a name="view-cfg-only">-view-cfg-only: View CFG of function (with no function bodies)</a>
+</h3>
+<div>
<p>
Displays the control flow graph using the GraphViz tool, but omitting function
bodies.
</p>
</div>
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="view-dom">-view-dom: View dominance tree of function</a>
+</h3>
+<div>
+ <p>
+ Displays the dominator tree using the GraphViz tool.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="view-dom-only">-view-dom-only: View dominance tree of function (with no function bodies)</a>
+</h3>
+<div>
+ <p>
+ Displays the dominator tree using the GraphViz tool, but omitting function
+ bodies.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="view-postdom">-view-postdom: View postdominance tree of function</a>
+</h3>
+<div>
+ <p>
+ Displays the post dominator tree using the GraphViz tool.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<h3>
+ <a name="view-postdom-only">-view-postdom-only: View postdominance tree of function (with no function bodies)</a>
+</h3>
+<div>
+ <p>
+ Displays the post dominator tree using the GraphViz tool, but omitting
+ function bodies.
+ </p>
+</div>
+
+</div>
+
<!-- *********************************************************************** -->
<hr>
src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a>
<a href="mailto:rspencer@x10sys.com">Reid Spencer</a><br>
- <a href="http://llvm.org">LLVM Compiler Infrastructure</a><br>
+ <a href="http://llvm.org/">LLVM Compiler Infrastructure</a><br>
Last modified: $Date$
</address>
projects / oota-llvm.git / blobdiff