Lines Matching full:pass
158 RTL-generation pass, it is often necessary to have multiple strategies
189 hook `TARGET_STRUCT_VALUE_RTX' tells GCC where to pass this address.
199 standard system convention is to pass to the subroutine the address of
2293 pass.
3070 * Parsing pass:: The language front end turns text into bits.
3071 * Gimplification pass:: The bits are turned into something we can optimize.
3072 * Pass manager:: Sequencing the optimization passes.
3077 File: gccint.info, Node: Parsing pass, Next: Gimplification pass, Up: Passes
3079 8.1 Parsing pass
3117 The front end needs to pass all function definitions and top level
3146 File: gccint.info, Node: Gimplification pass, Next: Pass manager, Prev: Parsing pass, Up: Passes
3148 8.2 Gimplification pass
3163 The main entry point to this pass is `gimplify_function_tree' located
3165 each statement in turn. The main workhorse for this pass is
3182 File: gccint.info, Node: Pass manager, Next: Tree-SSA passes, Prev: Gimplification pass, Up: Passes
3184 8.3 Pass manager
3187 The pass manager is located in `passes.c', `tree-optimize.c' and
3188 `tree-pass.h'. Its job is to run all of the individual passes in the
3190 every pass.
3192 The theory of operation is that each pass defines a structure that
3193 represents everything we need to know about that pass--when it should
3195 on-the-side data structures it needs. We register the pass to be run
3196 in some particular order, and the pass manager arranges for everything
3201 defined elsewhere. The pass manager validates constraints but does not
3203 form based on the requirements of the next pass. Nevertheless, what is
3206 TODO: describe the global variables set up by the pass manager, and a
3207 brief description of how a new pass should use it. I need to look at
3211 File: gccint.info, Node: Tree-SSA passes, Next: RTL passes, Prev: Pass manager, Up: Passes
3221 This pass is an extremely simple sweep across the gimple code in
3228 when it's more work to get rid of it. This pass is located in
3238 (`extern'). This pass generates new exception handling constructs
3240 addition, the pass enqueues declarations of static variables whose
3241 lifetimes extend to the entire program. The pass is located in
3246 If OpenMP generation (`-fopenmp') is enabled, this pass lowers
3253 the control flow graph. The pass is located in `omp-low.c' and is
3258 If OpenMP generation (`-fopenmp') is enabled, this pass expands
3260 thread library. The pass is located in `omp-low.c' and is
3265 This pass flattens `if' statements (`COND_EXPR') and moves lexical
3266 bindings (`BIND_EXPR') out of line. After this pass, all `if'
3270 position under a `BIND_EXPR'. This pass is found in
3275 This pass decomposes high-level exception handling constructs
3277 explicitly represents the control flow involved. After this pass,
3283 in `except.h' and built in `except.c'. The lowering pass itself
3288 This pass decomposes a function into basic blocks and creates all
3294 This pass walks the entire function and collects an array of all
3298 SSA rewriting routines. The pass is located in `tree-dfa.c' and
3303 This pass rewrites the function such that it is in SSA form. After
3304 this pass, all `is_gimple_reg' variables will be referenced by
3307 inserted as necessary for each basic block. This pass is located
3312 This pass scans the function for uses of `SSA_NAME's that are fed
3314 uninitialized. The pass is run twice, before and after
3315 optimization. In the first pass we only warn for uses that are
3316 positively uninitialized; in the second pass we warn for uses that
3317 are possibly uninitialized. The pass is located in `tree-ssa.c'
3323 This pass scans the function for statements without side effects
3325 any value that is stored in memory is considered used. The pass
3331 This pass performs trivial dominator-based copy and constant
3338 This pass removes PHI nodes for which all of the arguments are the
3340 typically created by removing unreachable code. The pass is run
3346 This pass attempts to remove redundant computation by substituting
3353 This pass attempts to change the name of compiler temporaries
3362 This pass recognizes forms of PHI inputs that can be represented as
3369 This pass performs a flow sensitive SSA-based points-to analysis.
3375 pass is located in `tree-ssa-alias.c' and is described by
3383 This pass rewrites the function in order to collect runtime block
3386 expected execution frequencies. The pass is located in
3391 This pass rewrites complex arithmetic operations into their
3392 component scalar arithmetic operations. The pass is located in
3397 This pass rewrites suitable non-aliased local aggregate variables
3400 passes to do a significantly better job with them. The pass is
3405 This pass eliminates stores to memory that are subsequently
3407 pass is located in `tree-ssa-dse.c' and is described by `pass_dse'.
3411 This pass transforms tail recursion into a loop. It is located in
3416 This pass sinks stores and assignments down the flowgraph closer
3417 to it's use point. The pass is located in `tree-ssa-sink.c' and is
3422 This pass eliminates partially redundant computations, as well as
3423 performing load motion. The pass is located in `tree-ssa-pre.c'
3428 divisions to multiplications by the reciprocal. The pass is
3440 The main driver of the pass is placed in `tree-ssa-loop.c' and
3443 The optimizations performed by this pass are:
3445 Loop invariant motion. This pass moves only invariants that would
3450 loop unswitching. The pass also includes store motion. The pass
3453 Canonical induction variable creation. This pass creates a simple
3458 pass is implemented in `tree-ssa-loop-ivcanon.c'.
3460 Induction variable optimizations. This pass performs standard
3463 The pass is implemented in `tree-ssa-loop-ivopts.c'.
3465 Loop unswitching. This pass moves the conditional jumps that are
3468 The pass is implemented in `tree-ssa-loop-unswitch.c'. This pass
3470 `loop-unswitch.c', but currently the rtl-level pass is not
3478 Vectorization. This pass transforms loops to operate on vector
3488 and to align the memory accesses in the loop. The pass is
3495 This pass applies if-conversion to simple loops to help vectorizer.
3500 re-introduces COND_EXPR at GIMPLE level. This pass is located in
3505 This pass relaxes a lattice of values in order to identify those
3507 The pass is located in `tree-ssa-ccp.c' and is described by
3510 A related pass that works on memory loads and stores, and not just
3518 code. The pass is located in `tree-ssa-copy.c' and described by
3521 A related pass that works on memory copies, and not just register
3536 The pass is located in `tree-vrp.c' and is described by
3541 This pass simplifies built-in functions, as applicable, with
3548 This pass identifies critical edges and inserts empty basic blocks
3549 such that the edge is no longer critical. The pass is located in
3554 This pass is a stronger form of dead code elimination that can
3560 This pass identifies function calls that may be rewritten into
3565 The pass is located in `tree-tailcall.c' and is described by
3571 For non-void functions, this pass locates return statements that do
3574 pass is run last so that we have as much time as possible to prove
3587 value, with a fallback function call into the runtime. The pass
3593 This pass rewrites the function such that it is in normal form. At
3596 GENERIC. The pass is located in `tree-outof-ssa.c' and is
3603 nodes. The pass is located in `tree-cfgcleanup.c' and is
3612 optimization applied to GIMPLE. The pass is located in
3618 foo()', this pass tries to change the call so that the address of
3620 pass is located in `tree-nrv.c' and is described by
3625 This is a propagation pass similar to CCP that tries to remove
3627 computed at compile-time. This pass is located in
3632 This pass removes expensive loop-invariant computations out of
3633 loops. The pass is located in `tree-ssa-loop.c' and described by
3643 pass is located in `tree-loop-linear.c' and described by
3648 This pass removes loops with no code in them. The pass is located
3653 This pass completely unrolls loops with few iterations. The pass
3659 This pass issues prefetch instructions for array references inside
3660 loops. The pass is located in `tree-ssa-loop-prefetch.c' and
3665 This pass rewrites arithmetic expressions to enable optimizations
3667 vectorization. The pass is located in `tree-ssa-reassoc.c' and
3672 This pass tries to avoid the saving of register arguments into the
3679 don't need to be saved. This pass is located in `tree-stdarg.c'
3698 pass. The header file `expr.h' is used for communication within
3699 this pass.
3703 tell this pass which standard names are available for use and
3708 This pass generates the glue that handles communication between the
3712 pads". The code for this pass is located within `except.c'.
3716 This pass removes unreachable code, simplifies jumps to next,
3717 jumps to jump, jumps across jumps, etc. The pass is run multiple
3719 the "jump optimization pass". The bulk of the code for this pass
3725 This pass removes redundant computation within basic blocks, and
3726 optimizes addressing modes based on cost. The pass is run twice.
3731 This pass performs two different types of GCSE depending on
3737 loops--that is left to the loop optimization pass. If MR PRE
3744 the GCSE pass also performs global constant and copy propagation.
3745 The source file for this pass is `gcse.c', and the LCM routines
3750 This pass performs several loop related optimizations. The source
3754 motion pass is implemented in `loop-invariant.c'. Basic block
3762 This pass is an aggressive form of GCSE that transforms the control
3764 branch instructions. The source file for this pass is `gcse.c'.
3768 This pass attempts to replace conditional branches and surrounding
3772 when supported by the target. The pass is located in `ifcvt.c'.
3776 This pass splits independent uses of each pseudo-register. This
3782 This pass computes which pseudo-registers are live at each point in
3787 or autodecrement addressing. The pass is located in `flow.c'.
3791 This pass attempts to combine groups of two or three instructions
3795 the result against the machine description. The pass is located
3800 This pass looks for cases where matching constraints would force an
3804 The pass is located in `regmove.c'.
3808 This pass looks for instructions that require the processor to be
3816 This pass looks at innermost loops and reorders their instructions
3818 performed immediately before instruction scheduling. The pass is
3823 This pass looks for instructions whose output will not be
3828 that otherwise would cause pipeline stalls. This pass is
3829 performed twice, before and after register allocation. The pass
3844 * Local register allocation. This pass allocates hard
3850 * Global register allocation. This pass allocates hard
3852 life spans are not contained in one basic block). The pass
3855 * Reloading. This pass renumbers pseudo registers with the
3865 The reload pass also optionally eliminates the frame pointer
3874 This pass implements profile guided code positioning. If profile
3883 This pass computes where the variables are stored at each position
3891 This optional pass attempts to find instructions that can go into
3899 branches. In this pass, the compiler figures out what how far
3913 This pass outputs the assembler code for the function. The source
6094 a `CALL_EXPR'. The second operand are the arguments to pass that
6353 The compiler pass which lowers GENERIC to GIMPLE is referred to as the
6383 of the IL before the pass `pass_lower_cf'. High GIMPLE still contains
6391 work done on a genericization pass which would run first, but the
6395 in the future if someone writes an optimization pass which would work
6515 Tree level if-conversion pass re-introduces `?:' expression, if
6709 pass which runs before most of the optimization passes eliminates these
7477 the SSA property. This can happen when a pass has added new symbols or
7534 Updating the SSA form is a two step process. First, the pass has to
7539 `register_new_name_mapping' (note that if your pass creates new code by
7541 the necessary mappings automatically). On the other hand, if your pass
7548 flags in the `tree_opt_pass' structure for your pass. There are
7574 pass may be doing something wrong. Inserting PHI nodes for an
7766 This pass will compare the alias set of every symbol memory tag and
7932 it in the middle of an optimization pass, you must be able to deal with
8326 There are also functions that pass through all the exits of a loop and
9121 scheduling pass, for example, `use' insns before a `call_insn' may
9245 be returned by the current function. On machines that pass
9802 not care what value the additional bits have. The reload pass
9835 Between the combiner pass and the reload pass, it is possible to
9837 `reg' as its first operand. After the reload pass, it is also
9854 pass prevents `subreg' expressions such as these from being formed.
9864 the reload pass.
10212 pass will try to merge the operations to produce the `eq' shown in case
10831 Instruction patterns may not use them. Until the `flow' pass of the
10833 `flow' pass finds cases where registers are incremented or decremented
11126 The common subexpression elimination pass sets the mode of an insn to
11130 The second Haifa scheduling pass, for targets that can multiple issue,
11186 This list is originally set up by the flow analysis pass; it is a null
11189 analysis pass adds a link to insns which store into registers values
11191 scheduling pass adds extra links so that every dependence will be
11555 * During the combiner pass, shared structure within an insn can exist
11975 issue in each pass that modifies the CFG.
11989 An important task of each compiler pass is to keep both the control
11991 the control flow graph after each pass is not an option, since it may be
12076 Usually a code manipulating pass simplifies the instruction stream and
12081 not transparent and each optimization pass is required to do so
12082 manually. However only few cases occur in practice. The pass may call
12093 It is also possible that a pass has to insert control flow instruction
12113 While debugging the optimization pass, an `verify_flow_info' function
12154 of a modifies basic block, so the pass may simply use`clear_bb_flags'
12233 For the generate pass, only the names of the insns matter, from either
12275 RTL-generation pass of the compiler. This pass knows certain
12367 RTL generation pass that, when it is necessary to test such a value, an
13301 the reload pass of the compiler to generate additional insns to make
13360 operand happens to be a register, the reload pass will be stymied,
13512 would only waste time in the reload pass. The modifier is not
15097 generation pass of the compiler. Giving one of these names to an
15098 instruction pattern tells the RTL generation pass that it can use the
15121 pass. Even the reload pass can generate move insns to copy values
15139 valid address later in the reload pass. In this case, nothing may
15741 The RTL generation pass generates this instruction only with
15758 The RTL generation pass generates this instruction only with
16312 of this, but the combine pass does not handle patterns with
16509 If a constraint in a pattern allows a constant, the reload pass may
16707 emitted at the end of the loop. The machine dependent reorg pass checks
16713 machine dependent reorg pass could emit a traditional compare and jump
16722 flow pass.
17091 combiner pass first tries to split a single `set' expression and then
17300 The `peephole2' pass is run after register allocation but before
19037 pass to CPP. It can also specify how to translate options you
19038 give to GCC into options for GCC to pass to the CPP.
19049 pass to `cc1', `cc1plus', `f771', and the other language front
19051 GCC into options for GCC to pass to front ends.
19057 pass to `cc1plus'. It can also specify how to translate options
19058 you give to GCC into options for GCC to pass to the `cc1plus'.
19067 pass to the assembler. It can also specify how to translate
19068 options you give to GCC into options for GCC to pass to the
19094 pass to the linker. It can also specify how to translate options
19095 you give to GCC into options for GCC to pass to the linker.
19171 pass the updated sysroot+headers_suffix to CPP, causing it to
19222 will pass the argument `-lgcc' to tell the linker to do the search.
19448 `builtin_assert' takes a string in the form you pass to the
21317 the reload pass.
21436 that should be treated like memory constraints by the reload pass.
21442 the reload pass to reload an operand, if it does not directly
21451 constraint can handle any memory operand, because the reload pass
21460 constraints by the reload pass.
21465 that consist of just a base register. This allows the reload pass
22084 frame pointer. This expression is evaluated in the reload pass.
22176 A C expression. If nonzero, push insns will be used to pass
22321 hard register in which to pass the argument, or zero to pass the
22333 register in which to pass this part of the argument, and the mode
22360 This target hook should return `true' if we should not pass TYPE
22753 caller to pass an address to the subroutine.
22987 contains a pointer, and is the one used to pass the `this' pointer
23127 work without change on machines that pass arguments on the stack.
23227 works for machines that pass all their arguments on the stack.
23566 non-strict one. The strict variant is used in the reload pass. It
23970 small pass which optimizes such cases. This hook should return
23971 true to enable this pass, and it should set the integers to which
24528 SCHED_RGN or SCHED_EBB bit set. This denotes the scheduler pass
26066 the scheduling pass is not run, or when no slot fillers could be
27850 If non-null, this hook performs a target-specific pass over the
28080 illegal to pass argument VAL to function FUNCDECL with prototype
28499 These are extra flags to pass to the C compiler and preprocessor,
30409 documentation in texinfo format by contributing a first pass at a
30440 work in the reload pass as well a serving as release manager for
31902 * cgraph_finalize_function: Parsing pass. (line 52)
31953 * combiner pass: Regs and Memory. (line 148)
32521 * GENERIC <2>: Gimplification pass.
32523 * GENERIC: Parsing pass. (line 6)
32551 * GIMPLE <2>: Gimplification pass.
32553 * GIMPLE: Parsing pass. (line 14)
32559 * gimplification <2>: Gimplification pass.
32561 * gimplification: Parsing pass. (line 14)
32562 * gimplifier: Parsing pass. (line 14)
32563 * gimplify_expr: Gimplification pass.
32565 * gimplify_function_tree: Gimplification pass.
32748 * intermediate representation lowering: Parsing pass. (line 14)
32792 * lang_hooks.gimplify_expr: Gimplification pass.
32794 * lang_hooks.parse_file: Parsing pass. (line 6)
32795 * language-independent intermediate representation: Parsing pass.
32880 * lowering, language-dependent intermediate representation: Parsing pass.
33463 * reload pass: Regs and Memory. (line 148)
33474 * rest_of_decl_compilation: Parsing pass. (line 52)
33475 * rest_of_type_compilation: Parsing pass. (line 52)
34362 Node: Parsing pass128900
34363 Node: Gimplification pass132428
34364 Node: Pass manager134255
