aarch64-linux-gnu-4.9/share/doc/gccint/Tree-SSA-passes.html - toolchains/linux-x86/gcc - Git at Google

 <!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> &nbsp; [<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&rsquo;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-&gt;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 &ldquo;copy-of&rdquo; 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&rsquo;s
 range propagation algorithm (Accurate Static Branch Prediction by
 Value Range Propagation, J. R. C. Patterson, PLDI &rsquo;95).  In
 contrast to Patterson&rsquo;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&rsquo;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&rsquo;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&rsquo;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&rsquo;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> &nbsp; [<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>