+ <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:
+ </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="strip-dead-prototypes">-strip-dead-prototypes: Remove unused function declarations</a>
+</div>
+<div class="doc_text">
+ <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
+ functions for which no implementation is available (i.e., declarations for
+ unused library functions).
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <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:</p>
+ <ul>
+ <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="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:</p>
+ <ul>
+ <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="sretpromotion">-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>
+
+ <p>
+ 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>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="tailcallelim">-tailcallelim: Tail Call Elimination</a>
+</div>
+<div class="doc_text">
+ <p>
+ This file transforms calls of the current function (self recursion) followed
+ by a return instruction with a branch to the entry of the function, creating
+ a loop. This pass also implements the following extensions to the basic
+ algorithm:
+ </p>
+
+ <ul>
+ <li>Trivial instructions between the call and return do not prevent the
+ transformation from taking place, though currently the analysis cannot
+ support moving any really useful instructions (only dead ones).
+ <li>This pass transforms functions that are prevented from being tail
+ recursive by an associative expression to use an accumulator variable,
+ thus compiling the typical naive factorial or <tt>fib</tt> implementation
+ into efficient code.
+ <li>TRE is performed if the function returns void, if the return
+ returns the result returned by the call, or if the function returns a
+ run-time constant on all exits from the function. It is possible, though
+ unlikely, that the return returns something else (like constant 0), and
+ can still be TRE'd. It can be TRE'd if <em>all other</em> return
+ instructions in the function return the exact same value.
+ <li>If it can prove that callees do not access theier caller stack frame,
+ they are marked as eligible for tail call elimination (by the code
+ generator).
+ </ul>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="tailduplicate">-tailduplicate: Tail Duplication</a>
+</div>
+<div class="doc_text">
+ <p>
+ This pass performs a limited form of tail duplication, intended to simplify
+ CFGs by removing some unconditional branches. This pass is necessary to
+ straighten out loops created by the C front-end, but also is capable of
+ making other code nicer. After this pass is run, the CFG simplify pass
+ should be run to clean up the mess.
+ </p>