Lines Matching full:pass
160 RTL-generation pass, it is often necessary to have multiple strategies
191 hook `TARGET_STRUCT_VALUE_RTX' tells GCC where to pass this address.
201 standard system convention is to pass to the subroutine the address of
5086 * Parsing pass:: The language front end turns text into bits.
5087 * Gimplification pass:: The bits are turned into something we can optimize.
5088 * Pass manager:: Sequencing the optimization passes.
5093 File: gccint.info, Node: Parsing pass, Next: Gimplification pass, Up: Passes
5095 8.1 Parsing pass
5133 The front end needs to pass all function definitions and top level
5162 File: gccint.info, Node: Gimplification pass, Next: Pass manager, Prev: Parsing pass, Up: Passes
5164 8.2 Gimplification pass
5179 The main entry point to this pass is `gimplify_function_tree' located
5181 each statement in turn. The main workhorse for this pass is
5198 File: gccint.info, Node: Pass manager, Next: Tree-SSA passes, Prev: Gimplification pass, Up: Passes
5200 8.3 Pass manager
5203 The pass manager is located in `passes.c', `tree-optimize.c' and
5204 `tree-pass.h'. Its job is to run all of the individual passes in the
5206 every pass.
5208 The theory of operation is that each pass defines a structure that
5209 represents everything we need to know about that pass--when it should
5211 on-the-side data structures it needs. We register the pass to be run
5212 in some particular order, and the pass manager arranges for everything
5217 defined elsewhere. The pass manager validates constraints but does not
5219 form based on the requirements of the next pass. Nevertheless, what is
5222 TODO: describe the global variables set up by the pass manager, and a
5223 brief description of how a new pass should use it. I need to look at
5227 File: gccint.info, Node: Tree-SSA passes, Next: RTL passes, Prev: Pass manager, Up: Passes
5237 This pass is an extremely simple sweep across the gimple code in
5244 when it's more work to get rid of it. This pass is located in
5254 (`extern'). This pass generates new exception handling constructs
5256 addition, the pass enqueues declarations of static variables whose
5257 lifetimes extend to the entire program. The pass is located in
5262 If OpenMP generation (`-fopenmp') is enabled, this pass lowers
5269 the control flow graph. The pass is located in `omp-low.c' and is
5274 If OpenMP generation (`-fopenmp') is enabled, this pass expands
5276 thread library. The pass is located in `omp-low.c' and is
5281 This pass flattens `if' statements (`COND_EXPR') and moves lexical
5282 bindings (`BIND_EXPR') out of line. After this pass, all `if'
5286 position under a `BIND_EXPR'. This pass is found in
5291 This pass decomposes high-level exception handling constructs
5293 explicitly represents the control flow involved. After this pass,
5299 in `except.h' and built in `except.c'. The lowering pass itself
5304 This pass decomposes a function into basic blocks and creates all
5310 This pass walks the entire function and collects an array of all
5314 SSA rewriting routines. The pass is located in `tree-dfa.c' and
5319 This pass rewrites the function such that it is in SSA form. After
5320 this pass, all `is_gimple_reg' variables will be referenced by
5323 inserted as necessary for each basic block. This pass is located
5328 This pass scans the function for uses of `SSA_NAME's that are fed
5330 uninitialized. The pass is run twice, before and after
5331 optimization. In the first pass we only warn for uses that are
5332 positively uninitialized; in the second pass we warn for uses that
5333 are possibly uninitialized. The pass is located in `tree-ssa.c'
5339 This pass scans the function for statements without side effects
5341 any value that is stored in memory is considered used. The pass
5347 This pass performs trivial dominator-based copy and constant
5354 This pass attempts to remove redundant computation by substituting
5361 This pass attempts to change the name of compiler temporaries
5370 This pass recognizes forms of PHI inputs that can be represented as
5377 This pass performs a flow sensitive SSA-based points-to analysis.
5383 pass is located in `tree-ssa-alias.c' and is described by
5391 This pass rewrites the function in order to collect runtime block
5394 expected execution frequencies. The pass is located in
5399 This pass rewrites complex arithmetic operations into their
5400 component scalar arithmetic operations. The pass is located in
5405 This pass rewrites suitable non-aliased local aggregate variables
5408 passes to do a significantly better job with them. The pass is
5413 This pass eliminates stores to memory that are subsequently
5415 pass is located in `tree-ssa-dse.c' and is described by `pass_dse'.
5419 This pass transforms tail recursion into a loop. It is located in
5424 This pass sinks stores and assignments down the flowgraph closer
5425 to their use point. The pass is located in `tree-ssa-sink.c' and
5430 This pass eliminates partially redundant computations, as well as
5431 performing load motion. The pass is located in `tree-ssa-pre.c'
5436 divisions to multiplications by the reciprocal. The pass is
5448 The main driver of the pass is placed in `tree-ssa-loop.c' and
5451 The optimizations performed by this pass are:
5453 Loop invariant motion. This pass moves only invariants that would
5458 loop unswitching. The pass also includes store motion. The pass
5461 Canonical induction variable creation. This pass creates a simple
5466 pass is implemented in `tree-ssa-loop-ivcanon.c'.
5468 Induction variable optimizations. This pass performs standard
5471 The pass is implemented in `tree-ssa-loop-ivopts.c'.
5473 Loop unswitching. This pass moves the conditional jumps that are
5476 The pass is implemented in `tree-ssa-loop-unswitch.c'. This pass
5478 `loop-unswitch.c', but currently the rtl-level pass is not
5486 Vectorization. This pass transforms loops to operate on vector
5496 and to align the memory accesses in the loop. The pass is
5501 Autoparallelization. This pass splits the loop iteration space to
5502 run into several threads. The pass is implemented in
5507 This pass applies if-conversion to simple loops to help vectorizer.
5512 re-introduces COND_EXPR at GIMPLE level. This pass is located in
5517 This pass relaxes a lattice of values in order to identify those
5519 The pass is located in `tree-ssa-ccp.c' and is described by
5522 A related pass that works on memory loads and stores, and not just
5530 code. The pass is located in `tree-ssa-copy.c' and described by
5533 A related pass that works on memory copies, and not just register
5548 The pass is located in `tree-vrp.c' and is described by
5553 This pass simplifies built-in functions, as applicable, with
5560 This pass identifies critical edges and inserts empty basic blocks
5561 such that the edge is no longer critical. The pass is located in
5566 This pass is a stronger form of dead code elimination that can
5572 This pass identifies function calls that may be rewritten into
5577 The pass is located in `tree-tailcall.c' and is described by
5583 For non-void functions, this pass locates return statements that do
5586 pass is run last so that we have as much time as possible to prove
5599 value, with a fallback function call into the runtime. The pass
5605 This pass rewrites the function such that it is in normal form. At
5608 GENERIC. The pass is located in `tree-outof-ssa.c' and is
5615 nodes. The pass is located in `tree-cfgcleanup.c' and is
5624 optimization applied to GIMPLE. The pass is located in
5630 foo()', this pass tries to change the call so that the address of
5632 pass is located in `tree-nrv.c' and is described by
5637 This is a propagation pass similar to CCP that tries to remove
5639 computed at compile-time. This pass is located in
5644 This pass removes expensive loop-invariant computations out of
5645 loops. The pass is located in `tree-ssa-loop.c' and described by
5655 pass is located in `tree-loop-linear.c' and described by
5660 This pass removes loops with no code in them. The pass is located
5665 This pass completely unrolls loops with few iterations. The pass
5671 This pass makes the code reuse the computations from the previous
5677 version of the temporary variable. This pass is located in
5682 This pass issues prefetch instructions for array references inside
5683 loops. The pass is located in `tree-ssa-loop-prefetch.c' and
5688 This pass rewrites arithmetic expressions to enable optimizations
5690 vectorization. The pass is located in `tree-ssa-reassoc.c' and
5695 This pass tries to avoid the saving of register arguments into the
5702 don't need to be saved. This pass is located in `tree-stdarg.c'
5721 pass. The header file `expr.h' is used for communication within
5722 this pass.
5726 tell this pass which standard names are available for use and
5731 This pass generates the glue that handles communication between the
5735 pads". The code for this pass is located within `except.c'.
5739 This pass removes unreachable code, simplifies jumps to next,
5740 jumps to jump, jumps across jumps, etc. The pass is run multiple
5742 the "jump optimization pass". The bulk of the code for this pass
5748 This pass attempts to remove redundant computation by substituting
5751 addressing mode selection. The pass is run twice, with values
5757 This pass removes redundant computation within basic blocks, and
5758 optimizes addressing modes based on cost. The pass is run twice.
5763 This pass performs two different types of GCSE depending on
5769 loops--that is left to the loop optimization pass. If MR PRE
5776 the GCSE pass also performs global constant and copy propagation.
5777 The source file for this pass is `gcse.c', and the LCM routines
5782 This pass performs several loop related optimizations. The source
5786 motion pass is implemented in `loop-invariant.c'. Basic block
5794 This pass is an aggressive form of GCSE that transforms the control
5796 branch instructions. The source file for this pass is `gcse.c'.
5800 This pass attempts to replace conditional branches and surrounding
5804 when supported by the target. The pass is located in `ifcvt.c'.
5808 This pass splits independent uses of each pseudo-register. This
5814 This pass computes which pseudo-registers are live at each point in
5819 or autodecrement addressing. The pass is located in `flow.c'.
5823 This pass attempts to combine groups of two or three instructions
5827 the result against the machine description. The pass is located
5832 This pass looks for cases where matching constraints would force an
5836 The pass is located in `regmove.c'.
5840 This pass looks for instructions that require the processor to be
5848 This pass looks at innermost loops and reorders their instructions
5850 performed immediately before instruction scheduling. The pass is
5855 This pass looks for instructions whose output will not be
5860 that otherwise would cause pipeline stalls. This pass is
5861 performed twice, before and after register allocation. The pass
5876 * Local register allocation. This pass allocates hard
5882 * Global register allocation. This pass allocates hard
5884 life spans are not contained in one basic block). The pass
5887 * Reloading. This pass renumbers pseudo registers with the
5897 The reload pass also optionally eliminates the frame pointer
5906 This pass implements profile guided code positioning. If profile
5915 This pass computes where the variables are stored at each position
5923 This optional pass attempts to find instructions that can go into
5931 branches. In this pass, the compiler figures out what how far
5945 This pass outputs the assembler code for the function. The source
6310 type system is miscomparing types, pass `--param
8226 function to call and the arguments to pass.
8587 The compiler pass which lowers GENERIC to GIMPLE is referred to as the
8617 of the IL before the pass `pass_lower_cf'. High GIMPLE still contains
8625 work done on a genericization pass which would run first, but the
8629 in the future if someone writes an optimization pass which would work
8749 Tree level if-conversion pass re-introduces `?:' expression, if
8943 pass which runs before most of the optimization passes eliminates these
9696 the SSA property. This can happen when a pass has added new symbols or
9753 Updating the SSA form is a two step process. First, the pass has to
9758 `register_new_name_mapping' (note that if your pass creates new code by
9760 the necessary mappings automatically). On the other hand, if your pass
9767 flags in the `tree_opt_pass' structure for your pass. There are
9793 pass may be doing something wrong. Inserting PHI nodes for an
9830 Additionally, if the pass discovers that it did not need to make
9996 This pass will compare the alias set of every symbol memory tag and
10170 middle of an optimization pass, you must be able to deal with the new
10581 There are also functions that pass through all the exits of a loop and
10765 dependence check pass has been implemented based on two different
11407 scheduling pass, for example, `use' insns before a `call_insn' may
11529 be returned by the current function. On machines that pass
12194 not care what value the additional bits have. The reload pass
12227 Between the combiner pass and the reload pass, it is possible to
12229 `reg' as its first operand. After the reload pass, it is also
12246 pass prevents `subreg' expressions such as these from being formed.
12256 the reload pass.
12631 pass will try to merge the operations to produce the `eq' shown in case
13276 Instruction patterns may not use them. Until the `flow' pass of the
13278 `flow' pass finds cases where registers are incremented or decremented
13567 The common subexpression elimination pass sets the mode of an insn to
13571 The second Haifa scheduling pass, for targets that can multiple issue,
13629 This list is originally set up by the flow analysis pass; it is a null
13632 analysis pass adds a link to insns which store into registers values
14012 * During the combiner pass, shared structure within an insn can exist
14432 issue in each pass that modifies the CFG.
14446 An important task of each compiler pass is to keep both the control
14448 the control flow graph after each pass is not an option, since it may be
14533 Usually a code manipulating pass simplifies the instruction stream and
14538 not transparent and each optimization pass is required to do so
14539 manually. However only few cases occur in practice. The pass may call
14550 It is also possible that a pass has to insert control flow instruction
14570 While debugging the optimization pass, an `verify_flow_info' function
14683 For the generate pass, only the names of the insns matter, from either
14725 RTL-generation pass of the compiler. This pass knows certain
14817 RTL generation pass that, when it is necessary to test such a value, an
15751 the reload pass of the compiler to generate additional insns to make
15810 operand happens to be a register, the reload pass will be stymied,
15962 would only waste time in the reload pass. The modifier is not
17717 generation pass of the compiler. Giving one of these names to an
17718 instruction pattern tells the RTL generation pass that it can use the
17741 pass. Even the reload pass can generate move insns to copy values
17759 valid address later in the reload pass. In this case, nothing may
18574 The RTL generation pass generates this instruction only with
18591 The RTL generation pass generates this instruction only with
19150 of this, but the combine pass does not handle patterns with
19355 If a constraint in a pattern allows a constant, the reload pass may
19553 emitted at the end of the loop. The machine dependent reorg pass checks
19559 machine dependent reorg pass could emit a traditional compare and jump
19568 flow pass.
19940 combiner pass first tries to split a single `set' expression and then
20149 The `peephole2' pass is run after register allocation but before
21891 pass to CPP. It can also specify how to translate options you
21892 give to GCC into options for GCC to pass to the CPP.
21903 pass to `cc1', `cc1plus', `f771', and the other language front
21905 GCC into options for GCC to pass to front ends.
21911 pass to `cc1plus'. It can also specify how to translate options
21912 you give to GCC into options for GCC to pass to the `cc1plus'.
21921 pass to the assembler. It can also specify how to translate
21922 options you give to GCC into options for GCC to pass to the
21948 pass to the linker. It can also specify how to translate options
21949 you give to GCC into options for GCC to pass to the linker.
22025 pass the updated sysroot+headers_suffix to CPP, causing it to
22076 will pass the argument `-lgcc' to tell the linker to do the search.
22326 `builtin_assert' takes a string in the form you pass to the
24290 the reload pass.
24409 that should be treated like memory constraints by the reload pass.
24415 the reload pass to reload an operand, if it does not directly
24424 constraint can handle any memory operand, because the reload pass
24433 constraints by the reload pass.
24438 that consist of just a base register. This allows the reload pass
25062 frame pointer. This expression is evaluated in the reload pass.
25154 A C expression. If nonzero, push insns will be used to pass
25300 hard register in which to pass the argument, or zero to pass the
25312 register in which to pass this part of the argument, and the mode
25339 This target hook should return `true' if we should not pass TYPE
25737 caller to pass an address to the subroutine.
25971 contains a pointer, and is the one used to pass the `this' pointer
26111 work without change on machines that pass arguments on the stack.
26211 works for machines that pass all their arguments on the stack.
26559 non-strict one. The strict variant is used in the reload pass. It
27020 small pass which optimizes such cases. This hook should return
27021 true to enable this pass, and it should set the integers to which
27597 SCHED_RGN or SCHED_EBB bit set. This denotes the scheduler pass
29223 the scheduling pass is not run, or when no slot fillers could be
31043 If non-null, this hook performs a target-specific pass over the
31299 illegal to pass argument VAL to function FUNCDECL with prototype
31725 These are extra flags to pass to the C compiler and preprocessor,
32320 gratis or for a fee, you must pass on to the recipients the same
34018 documentation in texinfo format by contributing a first pass at a
34049 work in the reload pass as well a serving as release manager for
38269 * cgraph_finalize_function: Parsing pass. (line 52)
38325 * combiner pass: Regs and Memory. (line 148)
38911 * GENERIC <2>: Gimplification pass.
38913 * GENERIC: Parsing pass. (line 6)
38942 * GIMPLE <1>: Parsing pass. (line 14)
38944 * GIMPLE: Gimplification pass.
38950 * gimplification <1>: Parsing pass. (line 14)
38951 * gimplification <2>: Gimplification pass.
38954 * gimplifier: Parsing pass. (line 14)
38955 * gimplify_expr: Gimplification pass.
38957 * gimplify_function_tree: Gimplification pass.
39133 * intermediate representation lowering: Parsing pass. (line 14)
39177 * lang_hooks.gimplify_expr: Gimplification pass.
39179 * lang_hooks.parse_file: Parsing pass. (line 6)
39180 * language-independent intermediate representation: Parsing pass.
39272 * lowering, language-dependent intermediate representation: Parsing pass.
39872 * reload pass: Regs and Memory. (line 148)
39884 * rest_of_decl_compilation: Parsing pass. (line 52)
39885 * rest_of_type_compilation: Parsing pass. (line 52)
40897 Node: Parsing pass237058
40898 Node: Gimplification pass240586
40899 Node: Pass manager242413
