554 lines
26 KiB
HTML
554 lines
26 KiB
HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
<html>
|
|
<!-- Copyright (C) 1988-2016 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 instruments 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>tree-profile.c</samp> and
|
|
is described by <code>pass_ipa_tree_profile</code>.
|
|
</p>
|
|
</li><li> Static profile estimation
|
|
|
|
<p>This pass implements series of heuristics to guess propababilities
|
|
of branches. The resulting predictions are turned into edge profile
|
|
by propagating branches across the control flow graphs.
|
|
The pass is located in <samp>tree-profile.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>.
|
|
</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>
|