Lines Matching full:pass
163 RTL-generation pass, it is often necessary to have multiple strategies
194 hook `TARGET_STRUCT_VALUE_RTX' tells GCC where to pass this address.
204 standard system convention is to pass to the subroutine the address of
5172 * Parsing pass:: The language front end turns text into bits.
5173 * Gimplification pass:: The bits are turned into something we can optimize.
5174 * Pass manager:: Sequencing the optimization passes.
5179 File: gccint.info, Node: Parsing pass, Next: Gimplification pass, Up: Passes
5181 8.1 Parsing pass
5219 The front end needs to pass all function definitions and top level
5248 File: gccint.info, Node: Gimplification pass, Next: Pass manager, Prev: Parsing pass, Up: Passes
5250 8.2 Gimplification pass
5265 The main entry point to this pass is `gimplify_function_tree' located
5267 each statement in turn. The main workhorse for this pass is
5284 File: gccint.info, Node: Pass manager, Next: Tree-SSA passes, Prev: Gimplification pass, Up: Passes
5286 8.3 Pass manager
5289 The pass manager is located in `passes.c', `tree-optimize.c' and
5290 `tree-pass.h'. Its job is to run all of the individual passes in the
5292 every pass.
5294 The theory of operation is that each pass defines a structure that
5295 represents everything we need to know about that pass--when it should
5297 on-the-side data structures it needs. We register the pass to be run
5298 in some particular order, and the pass manager arranges for everything
5303 defined elsewhere. The pass manager validates constraints but does not
5305 form based on the requirements of the next pass. Nevertheless, what is
5308 Each pass may have its own dump file (for GCC debugging purposes).
5312 TODO: describe the global variables set up by the pass manager, and a
5313 brief description of how a new pass should use it. I need to look at
5317 File: gccint.info, Node: Tree-SSA passes, Next: RTL passes, Prev: Pass manager, Up: Passes
5327 This pass is an extremely simple sweep across the gimple code in
5334 when it's more work to get rid of it. This pass is located in
5344 (`extern'). This pass generates new exception handling constructs
5346 addition, the pass enqueues declarations of static variables whose
5347 lifetimes extend to the entire program. The pass is located in
5352 If OpenMP generation (`-fopenmp') is enabled, this pass lowers
5359 the control flow graph. The pass is located in `omp-low.c' and is
5364 If OpenMP generation (`-fopenmp') is enabled, this pass expands
5366 thread library. The pass is located in `omp-low.c' and is
5371 This pass flattens `if' statements (`COND_EXPR') and moves lexical
5372 bindings (`BIND_EXPR') out of line. After this pass, all `if'
5376 position under a `BIND_EXPR'. This pass is found in
5381 This pass decomposes high-level exception handling constructs
5383 explicitly represents the control flow involved. After this pass,
5389 in `except.h' and built in `except.c'. The lowering pass itself
5394 This pass decomposes a function into basic blocks and creates all
5400 This pass walks the entire function and collects an array of all
5404 SSA rewriting routines. The pass is located in `tree-dfa.c' and
5409 This pass rewrites the function such that it is in SSA form. After
5410 this pass, all `is_gimple_reg' variables will be referenced by
5413 inserted as necessary for each basic block. This pass is located
5418 This pass scans the function for uses of `SSA_NAME's that are fed
5420 uninitialized. The pass is run twice, before and after
5421 optimization (if turned on). In the first pass we only warn for
5422 uses that are positively uninitialized; in the second pass we warn
5423 for uses that are possibly uninitialized. The pass is located in
5429 This pass scans the function for statements without side effects
5431 any value that is stored in memory is considered used. The pass
5437 This pass performs trivial dominator-based copy and constant
5444 This pass attempts to remove redundant computation by substituting
5451 This pass attempts to change the name of compiler temporaries
5460 This pass recognizes forms of PHI inputs that can be represented as
5467 This pass performs a flow sensitive SSA-based points-to analysis.
5473 pass is located in `tree-ssa-alias.c' and is described by
5481 This pass rewrites the function in order to collect runtime block
5484 expected execution frequencies. The pass is located in
5489 This pass rewrites complex arithmetic operations into their
5490 component scalar arithmetic operations. The pass is located in
5495 This pass rewrites suitable non-aliased local aggregate variables
5498 passes to do a significantly better job with them. The pass is
5503 This pass eliminates stores to memory that are subsequently
5505 pass is located in `tree-ssa-dse.c' and is described by `pass_dse'.
5509 This pass transforms tail recursion into a loop. It is located in
5514 This pass sinks stores and assignments down the flowgraph closer
5515 to their use point. The pass is located in `tree-ssa-sink.c' and
5520 This pass eliminates partially redundant computations, as well as
5521 performing load motion. The pass is located in `tree-ssa-pre.c'
5526 divisions to multiplications by the reciprocal. The pass is
5538 The main driver of the pass is placed in `tree-ssa-loop.c' and
5541 The optimizations performed by this pass are:
5543 Loop invariant motion. This pass moves only invariants that would
5548 loop unswitching. The pass also includes store motion. The pass
5551 Canonical induction variable creation. This pass creates a simple
5556 pass is implemented in `tree-ssa-loop-ivcanon.c'.
5558 Induction variable optimizations. This pass performs standard
5561 The pass is implemented in `tree-ssa-loop-ivopts.c'.
5563 Loop unswitching. This pass moves the conditional jumps that are
5566 The pass is implemented in `tree-ssa-loop-unswitch.c'. This pass
5568 `loop-unswitch.c', but currently the rtl-level pass is not
5576 Vectorization. This pass transforms loops to operate on vector
5586 and to align the memory accesses in the loop. The pass is
5591 Autoparallelization. This pass splits the loop iteration space to
5592 run into several threads. The pass is implemented in
5597 This pass applies if-conversion to simple loops to help vectorizer.
5602 re-introduces COND_EXPR at GIMPLE level. This pass is located in
5607 This pass relaxes a lattice of values in order to identify those
5609 The pass is located in `tree-ssa-ccp.c' and is described by
5612 A related pass that works on memory loads and stores, and not just
5620 code. The pass is located in `tree-ssa-copy.c' and described by
5623 A related pass that works on memory copies, and not just register
5638 The pass is located in `tree-vrp.c' and is described by
5643 This pass simplifies built-in functions, as applicable, with
5650 This pass identifies critical edges and inserts empty basic blocks
5651 such that the edge is no longer critical. The pass is located in
5656 This pass is a stronger form of dead code elimination that can
5662 This pass identifies function calls that may be rewritten into
5667 The pass is located in `tree-tailcall.c' and is described by
5673 For non-void functions, this pass locates return statements that do
5676 pass is run last so that we have as much time as possible to prove
5689 value, with a fallback function call into the runtime. The pass
5695 This pass rewrites the function such that it is in normal form. At
5698 GENERIC. The pass is located in `tree-outof-ssa.c' and is
5705 nodes. The pass is located in `tree-cfgcleanup.c' and is
5714 optimization applied to GIMPLE. The pass is located in
5720 foo()', this pass tries to change the call so that the address of
5722 pass is located in `tree-nrv.c' and is described by
5727 This is a propagation pass similar to CCP that tries to remove
5729 computed at compile-time. This pass is located in
5734 This pass removes expensive loop-invariant computations out of
5735 loops. The pass is located in `tree-ssa-loop.c' and described by
5745 pass is located in `tree-loop-linear.c' and described by
5750 This pass removes loops with no code in them. The pass is located
5755 This pass completely unrolls loops with few iterations. The pass
5761 This pass makes the code reuse the computations from the previous
5767 version of the temporary variable. This pass is located in
5772 This pass issues prefetch instructions for array references inside
5773 loops. The pass is located in `tree-ssa-loop-prefetch.c' and
5778 This pass rewrites arithmetic expressions to enable optimizations
5780 vectorization. The pass is located in `tree-ssa-reassoc.c' and
5785 This pass tries to avoid the saving of register arguments into the
5792 don't need to be saved. This pass is located in `tree-stdarg.c'
5811 pass. The header file `expr.h' is used for communication within
5812 this pass.
5816 tell this pass which standard names are available for use and
5821 This pass generates the glue that handles communication between the
5825 pads". The code for this pass is located within `except.c'.
5829 This pass removes unreachable code, simplifies jumps to next,
5830 jumps to jump, jumps across jumps, etc. The pass is run multiple
5832 the "jump optimization pass". The bulk of the code for this pass
5838 This pass attempts to remove redundant computation by substituting
5841 addressing mode selection. The pass is run twice, with values
5847 This pass removes redundant computation within basic blocks, and
5848 optimizes addressing modes based on cost. The pass is run twice.
5853 This pass performs two different types of GCSE depending on
5859 loops--that is left to the loop optimization pass. If MR PRE
5866 the GCSE pass also performs global constant and copy propagation.
5867 The source file for this pass is `gcse.c', and the LCM routines
5872 This pass performs several loop related optimizations. The source
5876 motion pass is implemented in `loop-invariant.c'. Basic block
5884 This pass is an aggressive form of GCSE that transforms the control
5886 branch instructions. The source file for this pass is `gcse.c'.
5890 This pass attempts to replace conditional branches and surrounding
5894 when supported by the target. The pass is located in `ifcvt.c'.
5898 This pass splits independent uses of each pseudo-register. This
5904 This pass computes which pseudo-registers are live at each point in
5909 or autodecrement addressing. The pass is located in `flow.c'.
5913 This pass attempts to combine groups of two or three instructions
5917 the result against the machine description. The pass is located
5922 This pass looks for cases where matching constraints would force an
5926 The pass is located in `regmove.c'.
5930 This pass looks for instructions that require the processor to be
5938 This pass looks at innermost loops and reorders their instructions
5940 performed immediately before instruction scheduling. The pass is
5945 This pass looks for instructions whose output will not be
5950 that otherwise would cause pipeline stalls. This pass is
5951 performed twice, before and after register allocation. The pass
5962 * Register move optimizations. This pass makes some simple RTL
5970 pass. Pseudo-registers spilled by the allocator or the
5987 * Reloading. This pass renumbers pseudo registers with the
5997 The reload pass also optionally eliminates the frame pointer
6006 This pass implements profile guided code positioning. If profile
6015 This pass computes where the variables are stored at each position
6023 This optional pass attempts to find instructions that can go into
6031 branches. In this pass, the compiler figures out what how far
6045 This pass outputs the assembler code for the function. The source
6410 type system is miscomparing types, pass `--param
8337 function to call and the arguments to pass.
9236 scheduling pass, for example, `use' insns before a `call_insn' may
9361 be returned by the current function. On machines that pass
10015 and are still supported. During the reload pass these are
10028 The use of `subreg's of `mem' after the reload pass is an area
10205 the reload pass.
10573 pass will try to merge the operations to produce the `eq' shown in case
10980 clobber, the register allocator and the reload pass do not assign
11220 Instruction patterns may not use them. Until the `flow' pass of the
11222 `flow' pass finds cases where registers are incremented or decremented
11511 The common subexpression elimination pass sets the mode of an insn to
11515 The second Haifa scheduling pass, for targets that can multiple issue,
11573 This list is originally set up by the flow analysis pass; it is a null
11576 analysis pass adds a link to insns which store into registers values
11911 * During the combiner pass, shared structure within an insn can exist
12108 pass which runs before most of the optimization passes eliminates these
12131 The compiler pass which converts GENERIC into GIMPLE is referred to as
12155 of the IL before the pass `pass_lower_cf'. High GIMPLE contains some
12165 work done on a genericization pass which would run first, but the
12169 in the future if someone writes an optimization pass which would work
12243 each pass when needed.
12250 * `plf' Pass Local Flags. This 2-bit mask can be used as general
12251 purpose markers by any pass. Passes are responsible for clearing
12268 by each pass.
12582 The GIMPLE level if-conversion pass re-introduces `?:' expression, if
12682 using `gimple_op'(), if this becomes a bottleneck, a pass can
12804 Set pass local flag `PLF' on statement `STMT' to `VAL_P'.
12808 Return the value of pass local flag `PLF' on statement `STMT'.
13015 `DST'/`SRC' are the destination and source respectively. You can pass
14868 the SSA property. This can happen when a pass has added new symbols or
14925 Updating the SSA form is a two step process. First, the pass has to
14930 `register_new_name_mapping' (note that if your pass creates new code by
14932 the necessary mappings automatically). On the other hand, if your pass
14939 flags in the `tree_opt_pass' structure for your pass. There are
14962 WARNING: If you need to use this flag, chances are that your pass
14999 Additionally, if the pass discovers that it did not need to make
15162 This pass will compare the alias set of every symbol memory tag and
15336 middle of an optimization pass, you must be able to deal with the new
15747 There are also functions that pass through all the exits of a loop and
15931 dependence check pass has been implemented based on two different
16343 issue in each pass that modifies the CFG.
16357 An important task of each compiler pass is to keep both the control
16359 the control flow graph after each pass is not an option, since it may be
16444 Usually a code manipulating pass simplifies the instruction stream and
16449 not transparent and each optimization pass is required to do so
16450 manually. However only few cases occur in practice. The pass may call
16461 It is also possible that a pass has to insert control flow instruction
16481 While debugging the optimization pass, an `verify_flow_info' function
16594 pass, only the names of the insns matter, from either
16636 RTL-generation pass of the compiler. This pass knows certain
16728 RTL generation pass that, when it is necessary to test such a value, an
17665 the reload pass of the compiler to generate additional insns to make
17724 operand happens to be a register, the reload pass will be stymied,
17876 would only waste time in the reload pass. The modifier is not
19740 generation pass of the compiler. Giving one of these names to an
19741 instruction pattern tells the RTL generation pass that it can use the
19764 pass. Even the reload pass can generate move insns to copy values
19782 valid address later in the reload pass. In this case, nothing may
20603 The RTL generation pass generates this instruction only with
20620 The RTL generation pass generates this instruction only with
21179 of this, but the combine pass does not handle patterns with
21384 If a constraint in a pattern allows a constant, the reload pass may
21582 emitted at the end of the loop. The machine dependent reorg pass checks
21588 machine dependent reorg pass could emit a traditional compare and jump
21597 flow pass.
21969 combiner pass first tries to split a single `set' expression and then
22178 The `peephole2' pass is run after register allocation but before
23935 pass to CPP. It can also specify how to translate options you
23936 give to GCC into options for GCC to pass to the CPP.
23947 pass to `cc1', `cc1plus', `f771', and the other language front
23949 GCC into options for GCC to pass to front ends.
23955 pass to `cc1plus'. It can also specify how to translate options
23956 you give to GCC into options for GCC to pass to the `cc1plus'.
23965 pass to the assembler. It can also specify how to translate
23966 options you give to GCC into options for GCC to pass to the
23992 pass to the linker. It can also specify how to translate options
23993 you give to GCC into options for GCC to pass to the linker.
24069 pass the updated sysroot+headers_suffix to CPP, causing it to
24120 will pass the argument `-lgcc' to tell the linker to do the search.
24370 `builtin_assert' takes a string in the form you pass to the
26327 the reload pass.
26469 that should be treated like memory constraints by the reload pass.
26475 the reload pass to reload an operand, if it does not directly
26484 constraint can handle any memory operand, because the reload pass
26493 constraints by the reload pass.
26498 that consist of just a base register. This allows the reload pass
27135 frame pointer. This expression is evaluated in the reload pass.
27227 A C expression. If nonzero, push insns will be used to pass
27375 hard register in which to pass the argument, or zero to pass the
27387 register in which to pass this part of the argument, and the mode
27414 This target hook should return `true' if we should not pass TYPE
27840 caller to pass an address to the subroutine.
28074 contains a pointer, and is the one used to pass the `this' pointer
28214 work without change on machines that pass arguments on the stack.
28314 works for machines that pass all their arguments on the stack.
28662 non-strict one. The strict variant is used in the reload pass. It
29135 small pass which optimizes such cases. This hook should return
29136 true to enable this pass, and it should set the integers to which
29762 SCHED_RGN or SCHED_EBB bit set. This denotes the scheduler pass
31388 the scheduling pass is not run, or when no slot fillers could be
33320 If non-null, this hook performs a target-specific pass over the
33597 illegal to pass argument VAL to function FUNCDECL with prototype
34029 These are extra flags to pass to the C compiler. They are used
34533 it is called by the pass manager between passes.
34629 PLUGIN_PASS_MANAGER_SETUP, /* To hook into pass manager. */
34660 23.3 Interacting with the pass manager
34664 is useful for both analysis plugins (plugging in after a certain pass
34665 such as CFG or an IPA pass) and optimization plugins.
34668 provided. A plugin registers a new pass with GCC by calling
34674 PASS_POS_INSERT_AFTER, // Insert after the reference pass.
34675 PASS_POS_INSERT_BEFORE, // Insert before the reference pass.
34676 PASS_POS_REPLACE // Replace the reference pass.
34681 struct opt_pass *pass; /* New pass provided by the plugin. */
34682 const char *reference_pass_name; /* Name of the reference pass for hooking
34683 up the new pass. */
34684 int ref_pass_instance_number; /* Insert the pass at the specified
34685 instance number of the reference pass. */
34687 enum pass_positioning_ops pos_op; /* how to insert the new pass. */
34691 /* Sample plugin code that registers a new pass. */
34700 /* Code to fill in the pass_info object with new pass information. */
34704 /* Register the new pass. */
34921 gratis or for a fee, you must pass on to the recipients the same
36619 documentation in texinfo format by contributing a first pass at a
36650 work in the reload pass as well a serving as release manager for
40926 * cgraph_finalize_function: Parsing pass. (line 52)
41576 * GENERIC <1>: Parsing pass. (line 6)
41578 * GENERIC: Gimplification pass.
41610 * GIMPLE <1>: Gimplification pass.
41612 * GIMPLE <2>: Parsing pass. (line 14)
41958 * gimplification <1>: Parsing pass. (line 14)
41959 * gimplification: Gimplification pass.
41961 * gimplifier: Parsing pass
41963 * gimplify_expr: Gimplification pass.
41965 * gimplify_function_tree: Gimplification pass.
42176 * intermediate representation lowering: Parsing pass. (line 14)
42224 * lang_hooks.gimplify_expr: Gimplification pass.
42226 * lang_hooks.parse_file: Parsing pass. (line 6)
42227 * language-independent intermediate representation: Parsing pass.
42319 * lowering, language-dependent intermediate representation: Parsing pass.
42932 * rest_of_decl_compilation: Parsing pass. (line 52)
42933 * rest_of_type_compilation: Parsing pass. (line 52)
44013 Node: Parsing pass240444
44014 Node: Gimplification pass243972
44015 Node: Pass manager245799
