MIPS disassembler support.

[oota-llvm.git] / docs / Passes.html

diff --git a/docs/Passes.html b/docs/Passes.html
index b7f70b91cbf30a606786871e5a0927ece07cc148..840b2eff0647babc7c86c2b969a2e91aae1c666d 100644 (file)
--- a/docs/Passes.html
+++ b/docs/Passes.html
@@ -126,6 +126,7 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 <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>Optimize for code generation</td></tr>
@@ -161,7 +162,6 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 <tr><td><a href="#loop-unswitch">-loop-unswitch</a></td><td>Unswitch loops</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>MemCpy Optimization</td></tr>
@@ -227,11 +227,8 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
   <a name="basicaa">-basicaa: Basic Alias Analysis (stateless AA impl)</a>
 </h3>
 <div>
-  <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>
+  <p>A basic alias analysis pass that implements identities (two different
+  globals cannot alias, etc), but does no stateful analysis.</p>
 </div>
 
 <!-------------------------------------------------------------------------- -->
@@ -528,9 +525,10 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
 </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>
 
@@ -818,6 +816,26 @@ perl -e '$/ = undef; for (split(/\n/, <>)) { s:^ *///? ?::; print "  <p>\n" if !
   </p>
 </div>
 
+<!-------------------------------------------------------------------------- -->
+<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>
+
 <!-------------------------------------------------------------------------- -->
 <h3>
   <a name="block-placement">-block-placement: Profile Guided Basic Block Placement</a>
@@ -1476,35 +1494,6 @@ if (X &lt; 3) {</pre>
   </p>
 </div>
 
-<!-------------------------------------------------------------------------- -->
-<h3>
-  <a name="lowersetjmp">-lowersetjmp: Lower Set Jump</a>
-</h3>
-<div>
-  <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>
-
 <!-------------------------------------------------------------------------- -->
 <h3>
   <a name="lowerswitch">-lowerswitch: Lower SwitchInst's to branches</a>