Bring the list of passes and their descriptions up to date.
authorDuncan Sands <baldrick@free.fr>
Tue, 6 Jul 2010 15:52:15 +0000 (15:52 +0000)
committerDuncan Sands <baldrick@free.fr>
Tue, 6 Jul 2010 15:52:15 +0000 (15:52 +0000)
Patch by Kenneth Hoste.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@107669 91177308-0d34-0410-b5e6-96231b3b80d8

docs/Passes.html

index 8b9bd07..fb3bc94 100644 (file)
@@ -27,7 +27,7 @@ while (<HELP>) {
   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;
@@ -91,29 +91,46 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 <tr><td><a href="#dot-postdom-only">-dot-postdom-only</a></td><td>Print post dominator 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="#interprocedural-aa-eval">-interprocedural-aa-eval</a></td><td>Exhaustive Interprocedural Alias Analysis Precision Evaluator</td></tr>
+<tr><td><a href="#interprocedural-basic-aa">-interprocedural-basic-aa</a></td><td>Interprocedural Basic Alias Analysis</td></tr>
 <tr><td><a href="#intervals">-intervals</a></td><td>Interval Partition Construction</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>Check for common errors in LLVM IR</td></tr>
+<tr><td><a href="#live-values">-live-values</a></td><td>Value Liveness Analysis</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>Prints module debug info metadata</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="#pointertracking">-pointertracking</a></td><td>Track pointer bounds</td></tr>
 <tr><td><a href="#postdomfrontier">-postdomfrontier</a></td><td>Post-Dominance Frontier Construction</td></tr>
 <tr><td><a href="#postdomtree">-postdomtree</a></td><td>Post-Dominator Tree Construction</td></tr>
 <tr><td><a href="#print-alias-sets">-print-alias-sets</a></td><td>Alias Set Printer</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="#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="#abcd">-abcd</a></td><td>Remove redundant conditional branches</td></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="#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>
@@ -125,16 +142,14 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 <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="#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="#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>
@@ -156,16 +171,27 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 <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="#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="#partial-inliner">-partial-inliner</a></td><td>Partial Inliner</td></tr>
+<tr><td><a href="#partialspecialization">-partialspecialization</a></td><td>Partial Specialization</td></tr>
 <tr><td><a href="#prune-eh">-prune-eh</a></td><td>Remove unused exception handling info</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="#sccp">-sccp</a></td><td>Sparse Conditional Constant Propagation</td></tr>
+<tr><td><a href="#sink">-sink</a></td><td>Code Sinking</td></tr>
 <tr><td><a href="#simplify-libcalls">-simplify-libcalls</a></td><td>Simplify well-known library calls</td></tr>
+<tr><td><a href="#simplify-libcalls-halfpowr">-simplify-libcalls-halfpowr</a></td><td>Simplify half_powr library calls</td></tr>
 <tr><td><a href="#simplifycfg">-simplifycfg</a></td><td>Simplify the CFG</td></tr>
+<tr><td><a href="#split-geps">-split-geps</a></td><td>Split complex GEPs into simple GEPs</td></tr>
+<tr><td><a href="#ssi">-ssi</a></td><td>Static Single Information Construction</td></tr>
+<tr><td><a href="#ssi-everything">-ssi-everything</a></td><td>Static Single Information Construction (everything, intended for debugging)</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-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>Remove unused function declarations</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="#sretpromotion">-sretpromotion</a></td><td>Promote sret arguments</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>
@@ -175,6 +201,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 <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>
@@ -194,7 +221,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="aa-eval">Exhaustive Alias Analysis Precision Evaluator</a>
+  <a name="aa-eval">-aa-eval: Exhaustive Alias Analysis Precision Evaluator</a>
 </div>
 <div class="doc_text">
   <p>This is a simple N^2 alias analysis accuracy evaluator.
@@ -208,7 +235,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="basicaa">Basic Alias Analysis (default AA impl)</a>
+  <a name="basicaa">-basicaa: Basic Alias Analysis (default AA impl)</a>
 </div>
 <div class="doc_text">
   <p>
@@ -220,7 +247,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="basiccg">Basic CallGraph Construction</a>
+  <a name="basiccg">-basiccg: Basic CallGraph Construction</a>
 </div>
 <div class="doc_text">
   <p>Yet to be written.</p>
@@ -228,7 +255,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="codegenprepare">Optimize for code generation</a>
+  <a name="codegenprepare">-codegenprepare: Optimize for code generation</a>
 </div>
 <div class="doc_text">
   <p>
@@ -240,7 +267,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="count-aa">Count Alias Analysis Query Responses</a>
+  <a name="count-aa">-count-aa: Count Alias Analysis Query Responses</a>
 </div>
 <div class="doc_text">
   <p>
@@ -251,7 +278,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="debug-aa">AA use debugger</a>
+  <a name="debug-aa">-debug-aa: AA use debugger</a>
 </div>
 <div class="doc_text">
   <p>
@@ -268,7 +295,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="domfrontier">Dominance Frontier Construction</a>
+  <a name="domfrontier">-domfrontier: Dominance Frontier Construction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -279,7 +306,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="domtree">Dominator Tree Construction</a>
+  <a name="domtree">-domtree: Dominator Tree Construction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -290,7 +317,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-callgraph">Print Call Graph to 'dot' file</a>
+  <a name="dot-callgraph">-dot-callgraph: Print Call Graph to 'dot' file</a>
 </div>
 <div class="doc_text">
   <p>
@@ -302,7 +329,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-cfg">Print CFG of function to 'dot' file</a>
+  <a name="dot-cfg">-dot-cfg: Print CFG of function to 'dot' file</a>
 </div>
 <div class="doc_text">
   <p>
@@ -314,7 +341,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-cfg-only">Print CFG of function to 'dot' file (with no function bodies)</a>
+  <a name="dot-cfg-only">-dot-cfg-only: Print CFG of function to 'dot' file (with no function bodies)</a>
 </div>
 <div class="doc_text">
   <p>
@@ -327,7 +354,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-dom">Print dominator tree of function to 'dot' file</a>
+  <a name="dot-dom">-dot-dom: Print dominator tree of function to 'dot' file</a>
 </div>
 <div class="doc_text">
   <p>
@@ -339,7 +366,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-dom-only">Print dominator tree of function to 'dot' file (with no
+  <a name="dot-dom-only">-dot-dom-only: Print dominator tree of function to 'dot' file (with no
   function bodies)</a>
 </div>
 <div class="doc_text">
@@ -353,7 +380,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-postdom">Print post dominator tree of function to 'dot' file</a>
+  <a name="dot-postdom">dot-postdom: Print post dominator tree of function to 'dot' file</a>
 </div>
 <div class="doc_text">
   <p>
@@ -365,7 +392,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dot-postdom-only">Print post dominator tree of function to 'dot' file
+  <a name="dot-postdom-only">dot-postdom-only: Print post dominator tree of function to 'dot' file
   (with no function bodies)</a>
 </div>
 <div class="doc_text">
@@ -379,7 +406,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="globalsmodref-aa">Simple mod/ref analysis for globals</a>
+  <a name="globalsmodref-aa">-globalsmodref-aa: Simple mod/ref analysis for globals</a>
 </div>
 <div class="doc_text">
   <p>
@@ -392,7 +419,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="instcount">Counts the various types of Instructions</a>
+  <a name="instcount">-instcount: Counts the various types of Instructions</a>
 </div>
 <div class="doc_text">
   <p>
@@ -402,7 +429,30 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="intervals">Interval Partition Construction</a>
+  <a name="interprocedural-aa-eval">-interprocedural-aa-eval: Exhaustive Interprocedural Alias Analysis Precision Evaluator</a>
+</div>
+<div class="doc_text">
+  <p>This pass implements 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
+  pointers in the function.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="interprocedural-basic-aa">-interprocedural-basic-aa: Interprocedural Basic Alias Analysis</a>
+</div>
+<div class="doc_text">
+  <p>This pass defines 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>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="intervals">-intervals: Interval Partition Construction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -418,7 +468,80 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loops">Natural Loop Construction</a>
+  <a name="iv-users">-iv-users: Induction Variable Users</a>
+</div>
+<div class="doc_text">
+  <p>Bookkeeping for "interesting" users of expressions computed from 
+  induction variables.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="lazy-value-info">-lazy-value-info: Lazy Value Information Analysis</a>
+</div>
+<div class="doc_text">
+  <p>Interface for lazy computation of value constraint information.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="lda">-lda: Loop Dependence Analysis</a>
+</div>
+<div class="doc_text">
+  <p>Loop dependence analysis framework, which is used to detect dependences in
+  memory accesses in loops.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="libcall-aa">-libcall-aa: LibCall Alias Analysis</a>
+</div>
+<div class="doc_text">
+  <p>LibCall Alias Analysis.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="lint">-lint: Check for common errors in LLVM IR</a>
+</div>
+<div class="doc_text">
+  <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>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="live-values">-live-values: Values Liveness Analysis</a>
+</div>
+<div class="doc_text">
+  <p>LLVM IR Value liveness analysis pass.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="loops">-loops: Natural Loop Construction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -431,7 +554,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="memdep">Memory Dependence Analysis</a>
+  <a name="memdep">-memdep: Memory Dependence Analysis</a>
 </div>
 <div class="doc_text">
   <p>
@@ -444,7 +567,20 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="no-aa">No Alias Analysis (always returns 'may' alias)</a>
+  <a name="module-debuginfo">-module-debuginfo: Prints module debug info metadata</a>
+</div>
+<div class="doc_text">
+  <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_subsection">
+  <a name="no-aa">-no-aa: No Alias Analysis (always returns 'may' alias)</a>
 </div>
 <div class="doc_text">
   <p>
@@ -456,7 +592,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="no-profile">No Profile Information</a>
+  <a name="no-profile">-no-profile: No Profile Information</a>
 </div>
 <div class="doc_text">
   <p>
@@ -467,7 +603,16 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="postdomfrontier">Post-Dominance Frontier Construction</a>
+  <a name="pointertracking">-pointertracking: Track pointer bounds.</a>
+</div>
+<div class="doc_text">
+  <p>Tracking of pointer bounds.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="postdomfrontier">-postdomfrontier: Post-Dominance Frontier Construction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -478,7 +623,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="postdomtree">Post-Dominator Tree Construction</a>
+  <a name="postdomtree">-postdomtree: Post-Dominator Tree Construction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -489,7 +634,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-alias-sets">Alias Set Printer</a>
+  <a name="print-alias-sets">-print-alias-sets: Alias Set Printer</a>
 </div>
 <div class="doc_text">
   <p>Yet to be written.</p>
@@ -497,7 +642,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-callgraph">Print a call graph</a>
+  <a name="print-callgraph">-print-callgraph: Print a call graph</a>
 </div>
 <div class="doc_text">
   <p>
@@ -508,7 +653,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-callgraph-sccs">Print SCCs of the Call Graph</a>
+  <a name="print-callgraph-sccs">-print-callgraph-sccs: Print SCCs of the Call Graph</a>
 </div>
 <div class="doc_text">
   <p>
@@ -519,7 +664,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-cfg-sccs">Print SCCs of each function CFG</a>
+  <a name="print-cfg-sccs">-print-cfg-sccs: Print SCCs of each function CFG</a>
 </div>
 <div class="doc_text">
   <p>
@@ -530,7 +675,31 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-externalfnconstants">Print external fn callsites passed constants</a>
+  <a name="print-dbginfo">-print-dbginfo: Print debug info in human readable form</a>
+</div>
+<div class="doc_text">
+  <p>Pass that prints instructions, and associated debug info:
+  <ul>
+  
+  <li>source/line/col information</li>
+  <li>original variable name</li>
+  <li>original type name</li>
+  </ul>
+
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="print-dom-info">-print-dom-info: Dominator Info Printer</a>
+</div>
+<div class="doc_text">
+  <p>Dominator Info Printer.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="print-externalfnconstants">-print-externalfnconstants: Print external fn callsites passed constants</a>
 </div>
 <div class="doc_text">
   <p>
@@ -543,7 +712,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-function">Print function to stderr</a>
+  <a name="print-function">-print-function: Print function to stderr</a>
 </div>
 <div class="doc_text">
   <p>
@@ -555,7 +724,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-module">Print module to stderr</a>
+  <a name="print-module">-print-module: Print module to stderr</a>
 </div>
 <div class="doc_text">
   <p>
@@ -565,7 +734,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="print-used-types">Find Used Types</a>
+  <a name="print-used-types">-print-used-types: Find Used Types</a>
 </div>
 <div class="doc_text">
   <p>
@@ -576,7 +745,17 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="profile-loader">Load profile information from llvmprof.out</a>
+  <a name="profile-estimator">-profile-estimator: Estimate profiling information</a>
+</div>
+<div class="doc_text">
+  <p>Profiling information that estimates the profiling information 
+  in a very crude and unimaginative way.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="profile-loader">-profile-loader: Load profile information from llvmprof.out</a>
 </div>
 <div class="doc_text">
   <p>
@@ -587,7 +766,15 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="scalar-evolution">Scalar Evolution Analysis</a>
+  <a name="profile-verifier">-profile-verifier: Verify profiling information</a>
+</div>
+<div class="doc_text">
+  <p>Pass that checks profiling information for plausibility.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="scalar-evolution">-scalar-evolution: Scalar Evolution Analysis</a>
 </div>
 <div class="doc_text">
   <p>
@@ -606,7 +793,45 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="targetdata">Target Data Layout</a>
+  <a name="scev-aa">-scev-aa: </a>
+</div>
+<div class="doc_text">
+  <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_subsection">
+  <a name="strip-dead-debug-info">-strip-dead-debug-info: Strip debug info for unused symbols</a>
+</div>
+<div class="doc_text">
+  <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_subsection">
+  <a name="targetdata">-targetdata: Target Data Layout</a>
 </div>
 <div class="doc_text">
   <p>Provides other passes access to information on how the size and alignment
@@ -621,7 +846,22 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="adce">Aggressive Dead Code Elimination</a>
+  <a name="abcd">-abcd: Remove redundant conditional branches</a>
+</div>
+<div class="doc_text">
+  <p>ABCD removes conditional branch instructions that can be proved redundant.
+  With the SSI representation, each variable has a constraint. By analyzing these 
+  constraints we can prove that a branch is redundant. When a branch is proved 
+  redundant it means that one direction will always be taken; thus, we can change 
+  this branch into an unconditional jump.</p>
+  <p>It is advisable to run <a href="#simplifycfg">SimplifyCFG</a> and 
+  <a href="#adce">Aggressive Dead Code Elimination</a> after ABCD 
+  to clean up the code.</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="adce">-adce: Aggressive Dead Code Elimination</a>
 </div>
 <div class="doc_text">
   <p>ADCE aggressively tries to eliminate code. This pass is similar to
@@ -632,7 +872,16 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="argpromotion">Promote 'by reference' arguments to scalars</a>
+  <a name="always-inline">-always-inline: Inliner for always_inline functions</a>
+</div>
+<div class="doc_text">
+  <p>A custom inliner that handles only functions that are marked as 
+  "always inline".</p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="argpromotion">-argpromotion: Promote 'by reference' arguments to scalars</a>
 </div>
 <div class="doc_text">
   <p>
@@ -663,7 +912,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="block-placement">Profile Guided Basic Block Placement</a>
+  <a name="block-placement">-block-placement: Profile Guided Basic Block Placement</a>
 </div>
 <div class="doc_text">
   <p>This pass is a very simple profile guided basic block placement algorithm.
@@ -675,7 +924,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="break-crit-edges">Break critical edges in CFG</a>
+  <a name="break-crit-edges">-break-crit-edges: Break critical edges in CFG</a>
 </div>
 <div class="doc_text">
   <p>
@@ -688,7 +937,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="codegenprepare">Prepare a function for code generation</a>
+  <a name="codegenprepare">-codegenprepare: Prepare a function for code generation</a>
 </div>
 <div class="doc_text">
   This pass munges the code in the input function to better prepare it for
@@ -698,7 +947,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="constmerge">Merge Duplicate Global Constants</a>
+  <a name="constmerge">-constmerge: Merge Duplicate Global Constants</a>
 </div>
 <div class="doc_text">
   <p>
@@ -711,7 +960,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="constprop">Simple constant propagation</a>
+  <a name="constprop">-constprop: Simple constant propagation</a>
 </div>
 <div class="doc_text">
   <p>This file implements constant propagation and merging. It looks for
@@ -727,7 +976,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dce">Dead Code Elimination</a>
+  <a name="dce">-dce: Dead Code Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -739,7 +988,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="deadargelim">Dead Argument Elimination</a>
+  <a name="deadargelim">-deadargelim: Dead Argument Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -757,7 +1006,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="deadtypeelim">Dead Type Elimination</a>
+  <a name="deadtypeelim">-deadtypeelim: Dead Type Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -769,7 +1018,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="die">Dead Instruction Elimination</a>
+  <a name="die">-die: Dead Instruction Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -780,7 +1029,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="dse">Dead Store Elimination</a>
+  <a name="dse">-dse: Dead Store Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -791,7 +1040,22 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="globaldce">Dead Global Elimination</a>
+  <a name="functionattrs">-functionattrs: Deduce function attributes</a>
+</div>
+<div class="doc_text">
+  <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">-globaldce: Dead Global Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -805,7 +1069,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="globalopt">Global Variable Optimizer</a>
+  <a name="globalopt">-globalopt: Global Variable Optimizer</a>
 </div>
 <div class="doc_text">
   <p>
@@ -817,7 +1081,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="gvn">Global Value Numbering</a>
+  <a name="gvn">-gvn: Global Value Numbering</a>
 </div>
 <div class="doc_text">
   <p>
@@ -826,10 +1090,9 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
   </p>
 </div>
 
-
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="indvars">Canonicalize Induction Variables</a>
+  <a name="indvars">-indvars: Canonicalize Induction Variables</a>
 </div>
 <div class="doc_text">
   <p>
@@ -880,7 +1143,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="inline">Function Integration/Inlining</a>
+  <a name="inline">-inline: Function Integration/Inlining</a>
 </div>
 <div class="doc_text">
   <p>
@@ -890,26 +1153,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <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>
+  <a name="insert-edge-profiling">-insert-edge-profiling: Insert instrumentation for edge profiling</a>
 </div>
 <div class="doc_text">
   <p>
@@ -927,51 +1171,18 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="insert-function-profiling">Insert instrumentation for function profiling</a>
+  <a name="insert-optimal-edge-profiling">-insert-optimal-edge-profiling: Insert optimal instrumentation for edge 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.
+  <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>
+  <a name="instcombine">-instcombine: Combine redundant instructions</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1025,7 +1236,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="internalize">Internalize Global Symbols</a>
+  <a name="internalize">-internalize: Internalize Global Symbols</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1037,7 +1248,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="ipconstprop">Interprocedural constant propagation</a>
+  <a name="ipconstprop">-ipconstprop: Interprocedural constant propagation</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1051,7 +1262,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="ipsccp">Interprocedural Sparse Conditional Constant Propagation</a>
+  <a name="ipsccp">-ipsccp: Interprocedural Sparse Conditional Constant Propagation</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1062,7 +1273,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="jump-threading">Thread control through conditional blocks</a>
+  <a name="jump-threading">-jump-threading: Thread control through conditional blocks</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1091,7 +1302,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="lcssa">Loop-Closed SSA Form Pass</a>
+  <a name="lcssa">-lcssa: Loop-Closed SSA Form Pass</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1120,7 +1331,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="licm">Loop Invariant Code Motion</a>
+  <a name="licm">-licm: Loop Invariant Code Motion</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1156,7 +1367,7 @@ if (X &lt; 3) {</pre>
 </div>
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-deletion">Dead Loop Deletion Pass</a>
+  <a name="loop-deletion">-loop-deletion: Dead Loop Deletion Pass</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1169,7 +1380,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-extract">Extract loops into new functions</a>
+  <a name="loop-extract">-loop-extract: Extract loops into new functions</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1182,7 +1393,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-extract-single">Extract at most one loop into a new function</a>
+  <a name="loop-extract-single">-loop-extract-single: Extract at most one loop into a new function</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1194,7 +1405,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-index-split">Index Split Loops</a>
+  <a name="loop-index-split">-loop-index-split: Index Split Loops</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1205,7 +1416,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-reduce">Loop Strength Reduction</a>
+  <a name="loop-reduce">-loop-reduce: Loop Strength Reduction</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1219,7 +1430,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-rotate">Rotate Loops</a>
+  <a name="loop-rotate">-loop-rotate: Rotate Loops</a>
 </div>
 <div class="doc_text">
   <p>A simple loop rotation transformation.</p>
@@ -1227,7 +1438,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-unroll">Unroll loops</a>
+  <a name="loop-unroll">-loop-unroll: Unroll loops</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1239,7 +1450,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loop-unswitch">Unswitch loops</a>
+  <a name="loop-unswitch">-loop-unswitch: Unswitch loops</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1269,7 +1480,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="loopsimplify">Canonicalize natural loops</a>
+  <a name="loopsimplify">-loopsimplify: Canonicalize natural loops</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1310,7 +1521,23 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="lowerinvoke">Lower invoke and unwind, for unwindless code generators</a>
+  <a name="lowerallocs">-lowerallocs: Lower allocations from instructions to calls</a>
+</div>
+<div class="doc_text">
+  <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>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="lowerinvoke">-lowerinvoke: Lower invoke and unwind, for unwindless code generators</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1351,7 +1578,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="lowersetjmp">Lower Set Jump</a>
+  <a name="lowersetjmp">-lowersetjmp: Lower Set Jump</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1380,7 +1607,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="lowerswitch">Lower SwitchInst's to branches</a>
+  <a name="lowerswitch">-lowerswitch: Lower SwitchInst's to branches</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1392,7 +1619,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="mem2reg">Promote Memory to Register</a>
+  <a name="mem2reg">-mem2reg: Promote Memory to Register</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1408,7 +1635,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="memcpyopt">Optimize use of memcpy and friend</a>
+  <a name="memcpyopt">-memcpyopt: Optimize use of memcpy and friend</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1419,7 +1646,28 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="mergereturn">Unify function exit nodes</a>
+  <a name="mergefunc">-mergefunc: Merge Functions</a>
+</div>
+<div class="doc_text">
+  <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_subsection">
+  <a name="mergereturn">-mergereturn: Unify function exit nodes</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1430,7 +1678,33 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="prune-eh">Remove unused exception handling info</a>
+  <a name="partial-inliner">-partial-inliner: Partial Inliner</a>
+</div>
+<div class="doc_text">
+  <p>This pass performs partial inlining, typically by inlining an if 
+  statement that surrounds the body of the function.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="partialspecialization">-partialspecialization: Partial Specialization</a>
+</div>
+<div class="doc_text">
+  <p>This pass finds function arguments that are often a common constant and 
+  specializes a version of the called function for that constant.
+  This pass simply does the cloning for functions it specializes.  It depends
+  on <a href="#ipsccp">IPSCCP</a> and <a href="#deadargelim">DAE</a> to clean up the results.
+  The initial heuristic favors constant arguments that are used in control 
+  flow.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="prune-eh">-prune-eh: Remove unused exception handling info</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1443,7 +1717,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="reassociate">Reassociate expressions</a>
+  <a name="reassociate">-reassociate: Reassociate expressions</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1466,7 +1740,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="reg2mem">Demote all values to stack slots</a>
+  <a name="reg2mem">-reg2mem: Demote all values to stack slots</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1483,7 +1757,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="scalarrepl">Scalar Replacement of Aggregates</a>
+  <a name="scalarrepl">-scalarrepl: Scalar Replacement of Aggregates</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1505,7 +1779,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="sccp">Sparse Conditional Constant Propagation</a>
+  <a name="sccp">-sccp: Sparse Conditional Constant Propagation</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1528,7 +1802,17 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="simplify-libcalls">Simplify well-known library calls</a>
+  <a name="sink">-sink: Code Sinking</a>
+</div>
+<div class="doc_text">
+  <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_subsection">
+  <a name="simplify-libcalls">-simplify-libcalls: Simplify well-known library calls</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1541,7 +1825,17 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="simplifycfg">Simplify the CFG</a>
+  <a name="simplify-libcalls-halfpowr">-simplify-libcalls-halfpowr: Simplify half_powr library calls</a>
+</div>
+<div class="doc_text">
+  <p>Simple pass that applies an experimental transformation on calls 
+  to specific functions.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="simplifycfg">-simplifycfg: Simplify the CFG</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1560,11 +1854,48 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="strip">Strip all symbols from a module</a>
+  <a name="split-geps">-split-geps: Split complex GEPs into simple GEPs</a>
+</div>
+<div class="doc_text">
+  <p>This function breaks GEPs with more than 2 non-zero operands into smaller
+  GEPs each with no more than 2 non-zero operands. This exposes redundancy
+  between GEPs with common initial operand sequences.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="ssi">-ssi: Static Single Information Construction</a>
+</div>
+<div class="doc_text">
+  <p>This pass converts a list of variables to the Static Single Information
+  form. 
+  We are building an on-demand representation, that is, we do not convert
+  every single variable in the target function to SSI form. Rather, we receive
+  a list of target variables that must be converted. We also do not
+  completely convert a target variable to the SSI format. Instead, we only
+  change the variable in the points where new information can be attached
+  to its live range, that is, at branch points.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="ssi-everything">-ssi-everything: Static Single Information Construction (everything, intended for debugging)</a>
+</div>
+<div class="doc_text">
+  <p>A pass that runs <a href="#ssi">SSI</a> on every non-void variable, intended for debugging.
+  </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+  <a name="strip">-strip: Strip all symbols from a module</a>
 </div>
 <div class="doc_text">
   <p>
-  Performs code stripping. This transformation can delete:
+  performs code stripping. this transformation can delete:
   </p>
   
   <ol>
@@ -1574,7 +1905,7 @@ if (X &lt; 3) {</pre>
   </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>
@@ -1582,7 +1913,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="strip-dead-prototypes">Remove unused function declarations</a>
+  <a name="strip-dead-prototypes">-strip-dead-prototypes: Remove unused function declarations</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1595,7 +1926,41 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="sretpromotion">Promote sret arguments</a>
+  <a name="strip-debug-declare">-strip-debug-declare: Strip all llvm.dbg.declare intrinsics</a>
+</div>
+<div class="doc_text">
+  <p>This pass implements code stripping. Specifically, it can delete:
+  <ul>
+  <li>names for virtual registers</li>
+  <li>symbols for internal globals and functions</li>
+  <li>debug information</li>
+  </ul>
+  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="strip-nondebug">-strip-nondebug: Strip all symbols, except dbg symbols, from a module</a>
+</div>
+<div class="doc_text">
+  <p>This pass implements code stripping. Specifically, it can delete:
+  <ul>
+  <li>names for virtual registers</li>
+  <li>symbols for internal globals and functions</li>
+  <li>debug information</li>
+  </ul>
+  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="sretpromotion">-sretpromotion: Promote sret arguments</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1618,7 +1983,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="tailcallelim">Tail Call Elimination</a>
+  <a name="tailcallelim">-tailcallelim: Tail Call Elimination</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1650,7 +2015,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="tailduplicate">Tail Duplication</a>
+  <a name="tailduplicate">-tailduplicate: Tail Duplication</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1670,7 +2035,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="deadarghaX0r">Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)</a>
+  <a name="deadarghaX0r">-deadarghaX0r: Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1681,7 +2046,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="extract-blocks">Extract Basic Blocks From Module (for bugpoint use)</a>
+  <a name="extract-blocks">-extract-blocks: Extract Basic Blocks From Module (for bugpoint use)</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1691,7 +2056,19 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="preverify">Preliminary module verification</a>
+  <a name="instnamer">-instnamer: Assign names to anonymous instructions</a>
+</div>
+<div class="doc_text">
+  <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_subsection">
+  <a name="preverify">-preverify: Preliminary module verification</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1707,7 +2084,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="verify">Module Verifier</a>
+  <a name="verify">-verify: Module Verifier</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1758,7 +2135,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="view-cfg">View CFG of function</a>
+  <a name="view-cfg">-view-cfg: View CFG of function</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1768,7 +2145,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="view-cfg-only">View CFG of function (with no function bodies)</a>
+  <a name="view-cfg-only">-view-cfg-only: View CFG of function (with no function bodies)</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1779,7 +2156,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="view-dom">View dominator tree of function</a>
+  <a name="view-dom">-view-dom: View dominator tree of function</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1789,7 +2166,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="view-dom-only">View dominator tree of function (with no function
+  <a name="view-dom-only">-view-dom-only: View dominator tree of function (with no function
   bodies)
   </a>
 </div>
@@ -1802,7 +2179,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="view-postdom">View post dominator tree of function</a>
+  <a name="view-postdom">-view-postdom: View post dominator tree of function</a>
 </div>
 <div class="doc_text">
   <p>
@@ -1812,7 +2189,7 @@ if (X &lt; 3) {</pre>
 
 <!-------------------------------------------------------------------------- -->
 <div class="doc_subsection">
-  <a name="view-postdom-only">View post dominator tree of function (with no
+  <a name="view-postdom-only">-view-postdom-only: View post dominator tree of function (with no
   function bodies)
   </a>
 </div>