| <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> |
| <html> |
| <!-- Copyright (C) 1988-2015 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "Funding Free Software", the Front-Cover |
| Texts being (a) (see below), and with the Back-Cover Texts being (b) |
| (see below). A copy of the license is included in the section entitled |
| "GNU Free Documentation License". |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU |
| software. Copies published by the Free Software Foundation raise |
| funds for GNU development. --> |
| <!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ --> |
| <head> |
| <title>GNU Compiler Collection (GCC) Internals: Tree SSA passes</title> |
| |
| <meta name="description" content="GNU Compiler Collection (GCC) Internals: Tree SSA passes"> |
| <meta name="keywords" content="GNU Compiler Collection (GCC) Internals: Tree SSA passes"> |
| <meta name="resource-type" content="document"> |
| <meta name="distribution" content="global"> |
| <meta name="Generator" content="makeinfo"> |
| <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> |
| <link href="index.html#Top" rel="start" title="Top"> |
| <link href="Option-Index.html#Option-Index" rel="index" title="Option Index"> |
| <link href="index.html#SEC_Contents" rel="contents" title="Table of Contents"> |
| <link href="Passes.html#Passes" rel="up" title="Passes"> |
| <link href="RTL-passes.html#RTL-passes" rel="next" title="RTL passes"> |
| <link href="Pass-manager.html#Pass-manager" rel="prev" title="Pass manager"> |
| <style type="text/css"> |
| <!-- |
| a.summary-letter {text-decoration: none} |
| blockquote.smallquotation {font-size: smaller} |
| div.display {margin-left: 3.2em} |
| div.example {margin-left: 3.2em} |
| div.indentedblock {margin-left: 3.2em} |
| div.lisp {margin-left: 3.2em} |
| div.smalldisplay {margin-left: 3.2em} |
| div.smallexample {margin-left: 3.2em} |
| div.smallindentedblock {margin-left: 3.2em; font-size: smaller} |
| div.smalllisp {margin-left: 3.2em} |
| kbd {font-style:oblique} |
| pre.display {font-family: inherit} |
| pre.format {font-family: inherit} |
| pre.menu-comment {font-family: serif} |
| pre.menu-preformatted {font-family: serif} |
| pre.smalldisplay {font-family: inherit; font-size: smaller} |
| pre.smallexample {font-size: smaller} |
| pre.smallformat {font-family: inherit; font-size: smaller} |
| pre.smalllisp {font-size: smaller} |
| span.nocodebreak {white-space:nowrap} |
| span.nolinebreak {white-space:nowrap} |
| span.roman {font-family:serif; font-weight:normal} |
| span.sansserif {font-family:sans-serif; font-weight:normal} |
| ul.no-bullet {list-style: none} |
| --> |
| </style> |
| |
| |
| </head> |
| |
| <body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000"> |
| <a name="Tree-SSA-passes"></a> |
| <div class="header"> |
| <p> |
| Next: <a href="RTL-passes.html#RTL-passes" accesskey="n" rel="next">RTL passes</a>, Previous: <a href="Pass-manager.html#Pass-manager" accesskey="p" rel="prev">Pass manager</a>, Up: <a href="Passes.html#Passes" accesskey="u" rel="up">Passes</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p> |
| </div> |
| <hr> |
| <a name="Tree-SSA-passes-1"></a> |
| <h3 class="section">9.5 Tree SSA passes</h3> |
| |
| <p>The following briefly describes the Tree optimization passes that are |
| run after gimplification and what source files they are located in. |
| </p> |
| <ul> |
| <li> Remove useless statements |
| |
| <p>This pass is an extremely simple sweep across the gimple code in which |
| we identify obviously dead code and remove it. Here we do things like |
| simplify <code>if</code> statements with constant conditions, remove |
| exception handling constructs surrounding code that obviously cannot |
| throw, remove lexical bindings that contain no variables, and other |
| assorted simplistic cleanups. The idea is to get rid of the obvious |
| stuff quickly rather than wait until later when it’s more work to get |
| rid of it. This pass is located in <samp>tree-cfg.c</samp> and described by |
| <code>pass_remove_useless_stmts</code>. |
| </p> |
| </li><li> OpenMP lowering |
| |
| <p>If OpenMP generation (<samp>-fopenmp</samp>) is enabled, this pass lowers |
| OpenMP constructs into GIMPLE. |
| </p> |
| <p>Lowering of OpenMP constructs involves creating replacement |
| expressions for local variables that have been mapped using data |
| sharing clauses, exposing the control flow of most synchronization |
| directives and adding region markers to facilitate the creation of the |
| control flow graph. The pass is located in <samp>omp-low.c</samp> and is |
| described by <code>pass_lower_omp</code>. |
| </p> |
| </li><li> OpenMP expansion |
| |
| <p>If OpenMP generation (<samp>-fopenmp</samp>) is enabled, this pass expands |
| parallel regions into their own functions to be invoked by the thread |
| library. The pass is located in <samp>omp-low.c</samp> and is described by |
| <code>pass_expand_omp</code>. |
| </p> |
| </li><li> Lower control flow |
| |
| <p>This pass flattens <code>if</code> statements (<code>COND_EXPR</code>) |
| and moves lexical bindings (<code>BIND_EXPR</code>) out of line. After |
| this pass, all <code>if</code> statements will have exactly two <code>goto</code> |
| statements in its <code>then</code> and <code>else</code> arms. Lexical binding |
| information for each statement will be found in <code>TREE_BLOCK</code> rather |
| than being inferred from its position under a <code>BIND_EXPR</code>. This |
| pass is found in <samp>gimple-low.c</samp> and is described by |
| <code>pass_lower_cf</code>. |
| </p> |
| </li><li> Lower exception handling control flow |
| |
| <p>This pass decomposes high-level exception handling constructs |
| (<code>TRY_FINALLY_EXPR</code> and <code>TRY_CATCH_EXPR</code>) into a form |
| that explicitly represents the control flow involved. After this |
| pass, <code>lookup_stmt_eh_region</code> will return a non-negative |
| number for any statement that may have EH control flow semantics; |
| examine <code>tree_can_throw_internal</code> or <code>tree_can_throw_external</code> |
| for exact semantics. Exact control flow may be extracted from |
| <code>foreach_reachable_handler</code>. The EH region nesting tree is defined |
| in <samp>except.h</samp> and built in <samp>except.c</samp>. The lowering pass |
| itself is in <samp>tree-eh.c</samp> and is described by <code>pass_lower_eh</code>. |
| </p> |
| </li><li> Build the control flow graph |
| |
| <p>This pass decomposes a function into basic blocks and creates all of |
| the edges that connect them. It is located in <samp>tree-cfg.c</samp> and |
| is described by <code>pass_build_cfg</code>. |
| </p> |
| </li><li> Find all referenced variables |
| |
| <p>This pass walks the entire function and collects an array of all |
| variables referenced in the function, <code>referenced_vars</code>. The |
| index at which a variable is found in the array is used as a UID |
| for the variable within this function. This data is needed by the |
| SSA rewriting routines. The pass is located in <samp>tree-dfa.c</samp> |
| and is described by <code>pass_referenced_vars</code>. |
| </p> |
| </li><li> Enter static single assignment form |
| |
| <p>This pass rewrites the function such that it is in SSA form. After |
| this pass, all <code>is_gimple_reg</code> variables will be referenced by |
| <code>SSA_NAME</code>, and all occurrences of other variables will be |
| annotated with <code>VDEFS</code> and <code>VUSES</code>; PHI nodes will have |
| been inserted as necessary for each basic block. This pass is |
| located in <samp>tree-ssa.c</samp> and is described by <code>pass_build_ssa</code>. |
| </p> |
| </li><li> Warn for uninitialized variables |
| |
| <p>This pass scans the function for uses of <code>SSA_NAME</code>s that |
| are fed by default definition. For non-parameter variables, such |
| uses are uninitialized. The pass is run twice, before and after |
| optimization (if turned on). In the first pass we only warn for uses that are |
| positively uninitialized; in the second pass we warn for uses that |
| are possibly uninitialized. The pass is located in <samp>tree-ssa.c</samp> |
| and is defined by <code>pass_early_warn_uninitialized</code> and |
| <code>pass_late_warn_uninitialized</code>. |
| </p> |
| </li><li> Dead code elimination |
| |
| <p>This pass scans the function for statements without side effects whose |
| result is unused. It does not do memory life analysis, so any value |
| that is stored in memory is considered used. The pass is run multiple |
| times throughout the optimization process. It is located in |
| <samp>tree-ssa-dce.c</samp> and is described by <code>pass_dce</code>. |
| </p> |
| </li><li> Dominator optimizations |
| |
| <p>This pass performs trivial dominator-based copy and constant propagation, |
| expression simplification, and jump threading. It is run multiple times |
| throughout the optimization process. It is located in <samp>tree-ssa-dom.c</samp> |
| and is described by <code>pass_dominator</code>. |
| </p> |
| </li><li> Forward propagation of single-use variables |
| |
| <p>This pass attempts to remove redundant computation by substituting |
| variables that are used once into the expression that uses them and |
| seeing if the result can be simplified. It is located in |
| <samp>tree-ssa-forwprop.c</samp> and is described by <code>pass_forwprop</code>. |
| </p> |
| </li><li> Copy Renaming |
| |
| <p>This pass attempts to change the name of compiler temporaries involved in |
| copy operations such that SSA->normal can coalesce the copy away. When compiler |
| temporaries are copies of user variables, it also renames the compiler |
| temporary to the user variable resulting in better use of user symbols. It is |
| located in <samp>tree-ssa-copyrename.c</samp> and is described by |
| <code>pass_copyrename</code>. |
| </p> |
| </li><li> PHI node optimizations |
| |
| <p>This pass recognizes forms of PHI inputs that can be represented as |
| conditional expressions and rewrites them into straight line code. |
| It is located in <samp>tree-ssa-phiopt.c</samp> and is described by |
| <code>pass_phiopt</code>. |
| </p> |
| </li><li> May-alias optimization |
| |
| <p>This pass performs a flow sensitive SSA-based points-to analysis. |
| The resulting may-alias, must-alias, and escape analysis information |
| is used to promote variables from in-memory addressable objects to |
| non-aliased variables that can be renamed into SSA form. We also |
| update the <code>VDEF</code>/<code>VUSE</code> memory tags for non-renameable |
| aggregates so that we get fewer false kills. The pass is located |
| in <samp>tree-ssa-alias.c</samp> and is described by <code>pass_may_alias</code>. |
| </p> |
| <p>Interprocedural points-to information is located in |
| <samp>tree-ssa-structalias.c</samp> and described by <code>pass_ipa_pta</code>. |
| </p> |
| </li><li> Profiling |
| |
| <p>This pass rewrites the function in order to collect runtime block |
| and value profiling data. Such data may be fed back into the compiler |
| on a subsequent run so as to allow optimization based on expected |
| execution frequencies. The pass is located in <samp>predict.c</samp> and |
| is described by <code>pass_profile</code>. |
| </p> |
| </li><li> Lower complex arithmetic |
| |
| <p>This pass rewrites complex arithmetic operations into their component |
| scalar arithmetic operations. The pass is located in <samp>tree-complex.c</samp> |
| and is described by <code>pass_lower_complex</code>. |
| </p> |
| </li><li> Scalar replacement of aggregates |
| |
| <p>This pass rewrites suitable non-aliased local aggregate variables into |
| a set of scalar variables. The resulting scalar variables are |
| rewritten into SSA form, which allows subsequent optimization passes |
| to do a significantly better job with them. The pass is located in |
| <samp>tree-sra.c</samp> and is described by <code>pass_sra</code>. |
| </p> |
| </li><li> Dead store elimination |
| |
| <p>This pass eliminates stores to memory that are subsequently overwritten |
| by another store, without any intervening loads. The pass is located |
| in <samp>tree-ssa-dse.c</samp> and is described by <code>pass_dse</code>. |
| </p> |
| </li><li> Tail recursion elimination |
| |
| <p>This pass transforms tail recursion into a loop. It is located in |
| <samp>tree-tailcall.c</samp> and is described by <code>pass_tail_recursion</code>. |
| </p> |
| </li><li> Forward store motion |
| |
| <p>This pass sinks stores and assignments down the flowgraph closer to their |
| use point. The pass is located in <samp>tree-ssa-sink.c</samp> and is |
| described by <code>pass_sink_code</code>. |
| </p> |
| </li><li> Partial redundancy elimination |
| |
| <p>This pass eliminates partially redundant computations, as well as |
| performing load motion. The pass is located in <samp>tree-ssa-pre.c</samp> |
| and is described by <code>pass_pre</code>. |
| </p> |
| <p>Just before partial redundancy elimination, if |
| <samp>-funsafe-math-optimizations</samp> is on, GCC tries to convert |
| divisions to multiplications by the reciprocal. The pass is located |
| in <samp>tree-ssa-math-opts.c</samp> and is described by |
| <code>pass_cse_reciprocal</code>. |
| </p> |
| </li><li> Full redundancy elimination |
| |
| <p>This is a simpler form of PRE that only eliminates redundancies that |
| occur on all paths. It is located in <samp>tree-ssa-pre.c</samp> and |
| described by <code>pass_fre</code>. |
| </p> |
| </li><li> Loop optimization |
| |
| <p>The main driver of the pass is placed in <samp>tree-ssa-loop.c</samp> |
| and described by <code>pass_loop</code>. |
| </p> |
| <p>The optimizations performed by this pass are: |
| </p> |
| <p>Loop invariant motion. This pass moves only invariants that |
| would be hard to handle on RTL level (function calls, operations that expand to |
| nontrivial sequences of insns). With <samp>-funswitch-loops</samp> it also moves |
| operands of conditions that are invariant out of the loop, so that we can use |
| just trivial invariantness analysis in loop unswitching. The pass also includes |
| store motion. The pass is implemented in <samp>tree-ssa-loop-im.c</samp>. |
| </p> |
| <p>Canonical induction variable creation. This pass creates a simple counter |
| for number of iterations of the loop and replaces the exit condition of the |
| loop using it, in case when a complicated analysis is necessary to determine |
| the number of iterations. Later optimizations then may determine the number |
| easily. The pass is implemented in <samp>tree-ssa-loop-ivcanon.c</samp>. |
| </p> |
| <p>Induction variable optimizations. This pass performs standard induction |
| variable optimizations, including strength reduction, induction variable |
| merging and induction variable elimination. The pass is implemented in |
| <samp>tree-ssa-loop-ivopts.c</samp>. |
| </p> |
| <p>Loop unswitching. This pass moves the conditional jumps that are invariant |
| out of the loops. To achieve this, a duplicate of the loop is created for |
| each possible outcome of conditional jump(s). The pass is implemented in |
| <samp>tree-ssa-loop-unswitch.c</samp>. This pass should eventually replace the |
| RTL level loop unswitching in <samp>loop-unswitch.c</samp>, but currently |
| the RTL level pass is not completely redundant yet due to deficiencies |
| in tree level alias analysis. |
| </p> |
| <p>The optimizations also use various utility functions contained in |
| <samp>tree-ssa-loop-manip.c</samp>, <samp>cfgloop.c</samp>, <samp>cfgloopanal.c</samp> and |
| <samp>cfgloopmanip.c</samp>. |
| </p> |
| <p>Vectorization. This pass transforms loops to operate on vector types |
| instead of scalar types. Data parallelism across loop iterations is exploited |
| to group data elements from consecutive iterations into a vector and operate |
| on them in parallel. Depending on available target support the loop is |
| conceptually unrolled by a factor <code>VF</code> (vectorization factor), which is |
| the number of elements operated upon in parallel in each iteration, and the |
| <code>VF</code> copies of each scalar operation are fused to form a vector operation. |
| Additional loop transformations such as peeling and versioning may take place |
| to align the number of iterations, and to align the memory accesses in the |
| loop. |
| The pass is implemented in <samp>tree-vectorizer.c</samp> (the main driver), |
| <samp>tree-vect-loop.c</samp> and <samp>tree-vect-loop-manip.c</samp> (loop specific parts |
| and general loop utilities), <samp>tree-vect-slp</samp> (loop-aware SLP |
| functionality), <samp>tree-vect-stmts.c</samp> and <samp>tree-vect-data-refs.c</samp>. |
| Analysis of data references is in <samp>tree-data-ref.c</samp>. |
| </p> |
| <p>SLP Vectorization. This pass performs vectorization of straight-line code. The |
| pass is implemented in <samp>tree-vectorizer.c</samp> (the main driver), |
| <samp>tree-vect-slp.c</samp>, <samp>tree-vect-stmts.c</samp> and |
| <samp>tree-vect-data-refs.c</samp>. |
| </p> |
| <p>Autoparallelization. This pass splits the loop iteration space to run |
| into several threads. The pass is implemented in <samp>tree-parloops.c</samp>. |
| </p> |
| <p>Graphite is a loop transformation framework based on the polyhedral |
| model. Graphite stands for Gimple Represented as Polyhedra. The |
| internals of this infrastructure are documented in |
| <a href="http://gcc.gnu.org/wiki/Graphite">http://gcc.gnu.org/wiki/Graphite</a><!-- /@w -->. The passes working on |
| this representation are implemented in the various <samp>graphite-*</samp> |
| files. |
| </p> |
| </li><li> Tree level if-conversion for vectorizer |
| |
| <p>This pass applies if-conversion to simple loops to help vectorizer. |
| We identify if convertible loops, if-convert statements and merge |
| basic blocks in one big block. The idea is to present loop in such |
| form so that vectorizer can have one to one mapping between statements |
| and available vector operations. This pass is located in |
| <samp>tree-if-conv.c</samp> and is described by <code>pass_if_conversion</code>. |
| </p> |
| </li><li> Conditional constant propagation |
| |
| <p>This pass relaxes a lattice of values in order to identify those |
| that must be constant even in the presence of conditional branches. |
| The pass is located in <samp>tree-ssa-ccp.c</samp> and is described |
| by <code>pass_ccp</code>. |
| </p> |
| <p>A related pass that works on memory loads and stores, and not just |
| register values, is located in <samp>tree-ssa-ccp.c</samp> and described by |
| <code>pass_store_ccp</code>. |
| </p> |
| </li><li> Conditional copy propagation |
| |
| <p>This is similar to constant propagation but the lattice of values is |
| the “copy-of” relation. It eliminates redundant copies from the |
| code. The pass is located in <samp>tree-ssa-copy.c</samp> and described by |
| <code>pass_copy_prop</code>. |
| </p> |
| <p>A related pass that works on memory copies, and not just register |
| copies, is located in <samp>tree-ssa-copy.c</samp> and described by |
| <code>pass_store_copy_prop</code>. |
| </p> |
| </li><li> Value range propagation |
| |
| <p>This transformation is similar to constant propagation but |
| instead of propagating single constant values, it propagates |
| known value ranges. The implementation is based on Patterson’s |
| range propagation algorithm (Accurate Static Branch Prediction by |
| Value Range Propagation, J. R. C. Patterson, PLDI ’95). In |
| contrast to Patterson’s algorithm, this implementation does not |
| propagate branch probabilities nor it uses more than a single |
| range per SSA name. This means that the current implementation |
| cannot be used for branch prediction (though adapting it would |
| not be difficult). The pass is located in <samp>tree-vrp.c</samp> and is |
| described by <code>pass_vrp</code>. |
| </p> |
| </li><li> Folding built-in functions |
| |
| <p>This pass simplifies built-in functions, as applicable, with constant |
| arguments or with inferable string lengths. It is located in |
| <samp>tree-ssa-ccp.c</samp> and is described by <code>pass_fold_builtins</code>. |
| </p> |
| </li><li> Split critical edges |
| |
| <p>This pass identifies critical edges and inserts empty basic blocks |
| such that the edge is no longer critical. The pass is located in |
| <samp>tree-cfg.c</samp> and is described by <code>pass_split_crit_edges</code>. |
| </p> |
| </li><li> Control dependence dead code elimination |
| |
| <p>This pass is a stronger form of dead code elimination that can |
| eliminate unnecessary control flow statements. It is located |
| in <samp>tree-ssa-dce.c</samp> and is described by <code>pass_cd_dce</code>. |
| </p> |
| </li><li> Tail call elimination |
| |
| <p>This pass identifies function calls that may be rewritten into |
| jumps. No code transformation is actually applied here, but the |
| data and control flow problem is solved. The code transformation |
| requires target support, and so is delayed until RTL. In the |
| meantime <code>CALL_EXPR_TAILCALL</code> is set indicating the possibility. |
| The pass is located in <samp>tree-tailcall.c</samp> and is described by |
| <code>pass_tail_calls</code>. The RTL transformation is handled by |
| <code>fixup_tail_calls</code> in <samp>calls.c</samp>. |
| </p> |
| </li><li> Warn for function return without value |
| |
| <p>For non-void functions, this pass locates return statements that do |
| not specify a value and issues a warning. Such a statement may have |
| been injected by falling off the end of the function. This pass is |
| run last so that we have as much time as possible to prove that the |
| statement is not reachable. It is located in <samp>tree-cfg.c</samp> and |
| is described by <code>pass_warn_function_return</code>. |
| </p> |
| </li><li> Leave static single assignment form |
| |
| <p>This pass rewrites the function such that it is in normal form. At |
| the same time, we eliminate as many single-use temporaries as possible, |
| so the intermediate language is no longer GIMPLE, but GENERIC. The |
| pass is located in <samp>tree-outof-ssa.c</samp> and is described by |
| <code>pass_del_ssa</code>. |
| </p> |
| </li><li> Merge PHI nodes that feed into one another |
| |
| <p>This is part of the CFG cleanup passes. It attempts to join PHI nodes |
| from a forwarder CFG block into another block with PHI nodes. The |
| pass is located in <samp>tree-cfgcleanup.c</samp> and is described by |
| <code>pass_merge_phi</code>. |
| </p> |
| </li><li> Return value optimization |
| |
| <p>If a function always returns the same local variable, and that local |
| variable is an aggregate type, then the variable is replaced with the |
| return value for the function (i.e., the function’s DECL_RESULT). This |
| is equivalent to the C++ named return value optimization applied to |
| GIMPLE. The pass is located in <samp>tree-nrv.c</samp> and is described by |
| <code>pass_nrv</code>. |
| </p> |
| </li><li> Return slot optimization |
| |
| <p>If a function returns a memory object and is called as <code>var = |
| foo()</code>, this pass tries to change the call so that the address of |
| <code>var</code> is sent to the caller to avoid an extra memory copy. This |
| pass is located in <code>tree-nrv.c</code> and is described by |
| <code>pass_return_slot</code>. |
| </p> |
| </li><li> Optimize calls to <code>__builtin_object_size</code> |
| |
| <p>This is a propagation pass similar to CCP that tries to remove calls |
| to <code>__builtin_object_size</code> when the size of the object can be |
| computed at compile-time. This pass is located in |
| <samp>tree-object-size.c</samp> and is described by |
| <code>pass_object_sizes</code>. |
| </p> |
| </li><li> Loop invariant motion |
| |
| <p>This pass removes expensive loop-invariant computations out of loops. |
| The pass is located in <samp>tree-ssa-loop.c</samp> and described by |
| <code>pass_lim</code>. |
| </p> |
| </li><li> Loop nest optimizations |
| |
| <p>This is a family of loop transformations that works on loop nests. It |
| includes loop interchange, scaling, skewing and reversal and they are |
| all geared to the optimization of data locality in array traversals |
| and the removal of dependencies that hamper optimizations such as loop |
| parallelization and vectorization. The pass is located in |
| <samp>tree-loop-linear.c</samp> and described by |
| <code>pass_linear_transform</code>. |
| </p> |
| </li><li> Removal of empty loops |
| |
| <p>This pass removes loops with no code in them. The pass is located in |
| <samp>tree-ssa-loop-ivcanon.c</samp> and described by |
| <code>pass_empty_loop</code>. |
| </p> |
| </li><li> Unrolling of small loops |
| |
| <p>This pass completely unrolls loops with few iterations. The pass |
| is located in <samp>tree-ssa-loop-ivcanon.c</samp> and described by |
| <code>pass_complete_unroll</code>. |
| </p> |
| </li><li> Predictive commoning |
| |
| <p>This pass makes the code reuse the computations from the previous |
| iterations of the loops, especially loads and stores to memory. |
| It does so by storing the values of these computations to a bank |
| of temporary variables that are rotated at the end of loop. To avoid |
| the need for this rotation, the loop is then unrolled and the copies |
| of the loop body are rewritten to use the appropriate version of |
| the temporary variable. This pass is located in <samp>tree-predcom.c</samp> |
| and described by <code>pass_predcom</code>. |
| </p> |
| </li><li> Array prefetching |
| |
| <p>This pass issues prefetch instructions for array references inside |
| loops. The pass is located in <samp>tree-ssa-loop-prefetch.c</samp> and |
| described by <code>pass_loop_prefetch</code>. |
| </p> |
| </li><li> Reassociation |
| |
| <p>This pass rewrites arithmetic expressions to enable optimizations that |
| operate on them, like redundancy elimination and vectorization. The |
| pass is located in <samp>tree-ssa-reassoc.c</samp> and described by |
| <code>pass_reassoc</code>. |
| </p> |
| </li><li> Optimization of <code>stdarg</code> functions |
| |
| <p>This pass tries to avoid the saving of register arguments into the |
| stack on entry to <code>stdarg</code> functions. If the function doesn’t |
| use any <code>va_start</code> macros, no registers need to be saved. If |
| <code>va_start</code> macros are used, the <code>va_list</code> variables don’t |
| escape the function, it is only necessary to save registers that will |
| be used in <code>va_arg</code> macros. For instance, if <code>va_arg</code> is |
| only used with integral types in the function, floating point |
| registers don’t need to be saved. This pass is located in |
| <code>tree-stdarg.c</code> and described by <code>pass_stdarg</code>. |
| </p> |
| </li></ul> |
| |
| <hr> |
| <div class="header"> |
| <p> |
| Next: <a href="RTL-passes.html#RTL-passes" accesskey="n" rel="next">RTL passes</a>, Previous: <a href="Pass-manager.html#Pass-manager" accesskey="p" rel="prev">Pass manager</a>, Up: <a href="Passes.html#Passes" accesskey="u" rel="up">Passes</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p> |
| </div> |
| |
| |
| |
| </body> |
| </html> |