<tr><td><a href="#basicaa">-basicaa</a></td><td>Basic Alias Analysis (default 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="#callgraph">-callgraph</a></td><td>Print a call graph</td></tr>
-<tr><td><a href="#callscc">-callscc</a></td><td>Print SCCs of the Call Graph</td></tr>
-<tr><td><a href="#cfgscc">-cfgscc</a></td><td>Print SCCs of each function CFG</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="#domtree">-domtree</a></td><td>Dominator Tree Construction</td></tr>
-<tr><td><a href="#externalfnconstants">-externalfnconstants</a></td><td>Print external fn callsites passed constants</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="#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="#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="#postdomtree">-postdomtree</a></td><td>Post-Dominator Tree Construction</td></tr>
-<tr><td><a href="#print">-print</a></td><td>Print function to stderr</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 Call Graph to 'dot' file</td></tr>
-<tr><td><a href="#print-cfg">-print-cfg</a></td><td>Print CFG of function to 'dot' file</td></tr>
-<tr><td><a href="#print-cfg-only">-print-cfg-only</a></td><td>Print CFG of function to 'dot' file (with no function bodies)</td></tr>
-<tr><td><a href="#printm">-printm</a></td><td>Print module to stderr</td></tr>
-<tr><td><a href="#printusedtypes">-printusedtypes</a></td><td>Find Used Types</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-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-loader">-profile-loader</a></td><td>Load profile information from llvmprof.out</td></tr>
<tr><td><a href="#scalar-evolution">-scalar-evolution</a></td><td>Scalar Evolution Analysis</td></tr>
<tr><td><a href="#targetdata">-targetdata</a></td><td>Target Data Layout</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>
-<tr><td><a href="#cee">-cee</a></td><td>Correlated Expression Elimination</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="#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="#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="#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-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-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="#lower-packed">-lower-packed</a></td><td>lowers packed operations to operations on smaller packed datatypes</td></tr>
<tr><td><a href="#lowerallocs">-lowerallocs</a></td><td>Lower allocations from instructions to calls</td></tr>
-<tr><td><a href="#lowergc">-lowergc</a></td><td>Lower GC intrinsics, for GCless code generators</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="#lowerselect">-lowerselect</a></td><td>Lower select instructions to branches</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="#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="#prune-eh">-prune-eh</a></td><td>Remove unused exception handling info</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="#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="#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="#emitbitcode">-emitbitcode</a></td><td>Bitcode Writer</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>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="basicvn">Basic Value Numbering (default GVN impl)</a>
+ <a name="basicvn">Basic Value Numbering (default Value Numbering impl)</a>
</div>
<div class="doc_text">
<p>
lexically identical expressions. This does not require any ahead of time
analysis, so it is a very fast default implementation.
</p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="callgraph">Print a call graph</a>
-</div>
-<div class="doc_text">
- <p>
- This pass, only available in <code>opt</code>, prints the call graph to
- standard output in a human-readable form.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="callscc">Print SCCs of the Call Graph</a>
-</div>
-<div class="doc_text">
- <p>
- This pass, only available in <code>opt</code>, prints the SCCs of the call
- graph to standard output in a human-readable form.
- </p>
-</div>
-
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="cfgscc">Print SCCs of each function CFG</a>
-</div>
-<div class="doc_text">
<p>
- This pass, only available in <code>opt</code>, prints the SCCs of each
- function CFG to standard output in a human-readable form.
+ 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="externalfnconstants">Print external fn callsites passed constants</a>
+ <a name="dot-callgraph">Print Call Graph to 'dot' file</a>
</div>
<div class="doc_text">
<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
- useful when looking for standard library functions we should constant fold
- or handle in alias analyses.
+ 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
+ to convert it to postscript or some other suitable format.
+ </p>
+</div>
+
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="dot-cfg">Print CFG of function to 'dot' file</a>
+</div>
+<div class="doc_text">
+ <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
+ "dot" tool to convert it to postscript or some other suitable format.
+ </p>
+</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">
+ <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
+ then be processed with the "dot" tool to convert it to postscript or some
+ other suitable format.
</p>
</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="print">Print function to stderr</a>
+ <a name="print-alias-sets">Alias Set Printer</a>
+</div>
+<div class="doc_text">
+ <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">
<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
- as they are processed.
+ This pass, only available in <code>opt</code>, prints the call graph to
+ standard output in a human-readable form.
</p>
</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="print-alias-sets">Alias Set Printer</a>
+ <a name="print-callgraph-sccs">Print SCCs of the Call Graph</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ This pass, only available in <code>opt</code>, prints the SCCs of the call
+ graph to standard output in a human-readable form.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="print-callgraph">Print Call Graph to 'dot' file</a>
+ <a name="print-cfg-sccs">Print SCCs of each function CFG</a>
</div>
<div class="doc_text">
<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
- to convert it to postscript or some other suitable format.
+ This pass, only available in <code>opt</code>, prints the SCCs of each
+ function CFG to standard output in a human-readable form.
</p>
</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="print-cfg">Print CFG of function to 'dot' file</a>
+ <a name="print-externalfnconstants">Print external fn callsites passed constants</a>
</div>
<div class="doc_text">
<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
- "dot" tool to convert it to postscript or some other suitable format.
+ This pass, only available in <code>opt</code>, prints out call sites to
+ external functions that are called with constant arguments. This can be
+ useful when looking for standard library functions we should constant fold
+ or handle in alias analyses.
</p>
</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="print-cfg-only">Print CFG of function to 'dot' file (with no function bodies)</a>
+ <a name="print-function">Print function to stderr</a>
</div>
<div class="doc_text">
<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
- then be processed with the "dot" tool to convert it to postscript or some
- other suitable format.
+ The <code>PrintFunctionPass</code> class is designed to be pipelined with
+ other <code>FunctionPass</code>es, and prints out the functions of the module
+ as they are processed.
</p>
</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="printm">Print module to stderr</a>
+ <a name="print-module">Print module to stderr</a>
</div>
<div class="doc_text">
<p>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="printusedtypes">Find Used Types</a>
+ <a name="print-used-types">Find Used Types</a>
</div>
<div class="doc_text">
<p>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="cee">Correlated Expression Elimination</a>
+ <a name="codegenprepare">Prepare a function for code generation</a>
</div>
<div class="doc_text">
- <p>Correlated Expression Elimination propagates information from conditional
- branches to blocks dominated by destinations of the branch. It propagates
- information from the condition check itself into the body of the branch,
- allowing transformations like these for example:</p>
-
-<blockquote><pre>
-if (i == 7)
- ... 4*i; // constant propagation
-
-M = i+1; N = j+1;
-if (i == j)
- X = M-N; // = M-M == 0;
-</pre></blockquote>
-
- <p>This is called Correlated Expression Elimination because we eliminate or
- simplify expressions that are correlated with the direction of a branch. In
- this way we use static information to give us some information about the
- dynamic value of a variable.</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.
</div>
<!-------------------------------------------------------------------------- -->
<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 implementation to identify the common
+ 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).
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
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>
<!-------------------------------------------------------------------------- -->
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>
<!-------------------------------------------------------------------------- -->
</p>
</div>
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="jump-threading">Thread control through conditional blocks</a>
+</div>
+<div class="doc_text">
+ <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
+ multiple successors. If one or more of the predecessors of the block can be
+ proven to always cause a jump to one of the successors, we forward the edge
+ from the predecessor to the successor by duplicating the contents of this
+ block.
+ </p>
+ <p>
+ An example of when this can occur is code like this:
+ </p>
+
+ <pre
+>if () { ...
+ X = 4;
+}
+if (X < 3) {</pre>
+
+ <p>
+ In this case, the unconditional branch at the end of the first if can be
+ revectored to the false side of the second if.
+ </p>
+</div>
+
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
<a name="lcssa">Loop-Closed SSA Form Pass</a>
variable.</li>
</ul>
</div>
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="loop-deletion">Dead Loop Deletion Pass</a>
+</div>
+<div class="doc_text">
+ <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
+ side effects or volatile instructions, and do not contribute to the
+ computation of the function's return value.
+ </p>
+</div>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
</p>
</div>
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lower-packed">lowers packed operations to operations on smaller packed datatypes</a>
-</div>
-<div class="doc_text">
- <p>
- Lowers operations on vector datatypes into operations on more primitive vector
- datatypes, and finally to scalar operations.
- </p>
-</div>
-
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
<a name="lowerallocs">Lower allocations from instructions to calls</a>
</p>
</div>
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lowergc">Lower GC intrinsics, for GCless code generators</a>
-</div>
-<div class="doc_text">
- <p>
- This file implements lowering for the <tt>llvm.gc*</tt> intrinsics for targets
- that do not natively support them (which includes the C backend). Note that
- the code generated is not as efficient as it would be for targets that
- natively support the GC intrinsics, but it is useful for getting new targets
- up-and-running quickly.
- </p>
-
- <p>
- This pass implements the code transformation described in this paper:
- </p>
-
- <blockquote><p>
- "Accurate Garbage Collection in an Uncooperative Environment"
- Fergus Henderson, ISMM, 2002
- </p></blockquote>
-</div>
-
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
<a name="lowerinvoke">Lower invoke and unwind, for unwindless code generators</a>
</p>
</div>
-<!-------------------------------------------------------------------------- -->
-<div class="doc_subsection">
- <a name="lowerselect">Lower select instructions to branches</a>
-</div>
-<div class="doc_text">
- <p>
- Lowers select instructions into conditional branches for targets that do not
- have conditional moves or that have not implemented the select instruction
- yet.
- </p>
-
- <p>
- Note that this pass could be improved. In particular it turns every select
- instruction into a new conditional branch, even though some common cases have
- select instructions on the same predicate next to each other. It would be
- better to use the same branch for the whole group of selects.
- </p>
-</div>
-
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
<a name="lowersetjmp">Lower Set Jump</a>
</p>
</div>
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="memcpyopt">Optimize use of memcpy and friend</a>
+</div>
+<div class="doc_text">
+ <p>
+ This pass performs various transformations related to eliminating memcpy
+ calls, or transforming sets of stores into memset's.
+ </p>
+</div>
+
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
<a name="mergereturn">Unify function exit nodes</a>
</p>
</div>
+<!-------------------------------------------------------------------------- -->
+<div class="doc_subsection">
+ <a name="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="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">Tail Call Elimination</a>
<!-------------------------------------------------------------------------- -->
<div class="doc_subsection">
- <a name="emitbitcode">Bitcode Writer</a>
+ <a name="preverify">Preliminary module verification</a>
</div>
<div class="doc_text">
- <p>Yet to be written.</p>
+ <p>
+ Ensures that the module is in the form required by the <a
+ href="#verifier">Module Verifier</a> pass.
+ </p>
+
+ <p>
+ Running the verifier runs this pass automatically, so there should be no need
+ to use it directly.
+ </p>
</div>
<!-------------------------------------------------------------------------- -->
before performing optimizing transformations.
</p>
- <p>
+ <ul>
<li>Both of a binary operator's parameters are of the same type.</li>
<li>Verify that the indices of mem access instructions match other
operands.</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>Only phi nodes can be self referential: 'add int %0, %0 ; <int>:0' is
- bad.</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>
<li>PHI nodes must be the first thing in a basic block, all grouped
together.</li>
not agree with the function return value type.</li>
<li>Function call argument types match the function prototype.</li>
<li>All other things that are tested by asserts spread about the code.</li>
- </p>
+ </ul>
<p>
Note that this does not provide full security verification (like Java), but
<hr>
<address>
<a href="http://jigsaw.w3.org/css-validator/check/referer"><img
- src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
+ src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a>
<a href="http://validator.w3.org/check/referer"><img
- src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!"></a>
+ 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>
projects / oota-llvm.git / blobdiff