GNU Info
(gcc-295.info)Passes
Passes and Files of the Compiler
********************************
The overall control structure of the compiler is in `toplev.c'. This
file is responsible for initialization, decoding arguments, opening and
closing files, and sequencing the passes.
The parsing pass is invoked only once, to parse the entire input.
The RTL intermediate code for a function is generated as the function
is parsed, a statement at a time. Each statement is read in as a
syntax tree and then converted to RTL; then the storage for the tree
for the statement is reclaimed. Storage for types (and the expressions
for their sizes), declarations, and a representation of the binding
contours and how they nest, remain until the function is finished being
compiled; these are all needed to output the debugging information.
Each time the parsing pass reads a complete function definition or
top-level declaration, it calls either the function
`rest_of_compilation', or the function `rest_of_decl_compilation' in
`toplev.c', which are responsible for all further processing necessary,
ending with output of the assembler language. All other compiler
passes run, in sequence, within `rest_of_compilation'. When that
function returns from compiling a function definition, the storage used
for that function definition's compilation is entirely freed, unless it
is an inline function (*note An Inline Function is As Fast As a Macro:
Inline.).
Here is a list of all the passes of the compiler and their source
files. Also included is a description of where debugging dumps can be
requested with `-d' options.
* Parsing. This pass reads the entire text of a function definition,
constructing partial syntax trees. This and RTL generation are no
longer truly separate passes (formerly they were), but it is
easier to think of them as separate.
The tree representation does not entirely follow C syntax, because
it is intended to support other languages as well.
Language-specific data type analysis is also done in this pass,
and every tree node that represents an expression has a data type
attached. Variables are represented as declaration nodes.
Constant folding and some arithmetic simplifications are also done
during this pass.
The language-independent source files for parsing are
`stor-layout.c', `fold-const.c', and `tree.c'. There are also
header files `tree.h' and `tree.def' which define the format of
the tree representation.
The source files to parse C are `c-parse.in', `c-decl.c',
`c-typeck.c', `c-aux-info.c', `c-convert.c', and `c-lang.c' along
with header files `c-lex.h', and `c-tree.h'.
The source files for parsing C++ are `cp-parse.y', `cp-class.c',
`cp-cvt.c', `cp-decl.c', `cp-decl2.c', `cp-dem.c', `cp-except.c',
`cp-expr.c', `cp-init.c', `cp-lex.c', `cp-method.c', `cp-ptree.c',
`cp-search.c', `cp-tree.c', `cp-type2.c', and `cp-typeck.c', along
with header files `cp-tree.def', `cp-tree.h', and `cp-decl.h'.
The special source files for parsing Objective C are
`objc-parse.y', `objc-actions.c', `objc-tree.def', and
`objc-actions.h'. Certain C-specific files are used for this as
well.
The file `c-common.c' is also used for all of the above languages.
* RTL generation. This is the conversion of syntax tree into RTL
code. It is actually done statement-by-statement during parsing,
but for most purposes it can be thought of as a separate pass.
This is where the bulk of target-parameter-dependent code is found,
since often it is necessary for strategies to apply only when
certain standard kinds of instructions are available. The purpose
of named instruction patterns is to provide this information to
the RTL generation pass.
Optimization is done in this pass for `if'-conditions that are
comparisons, boolean operations or conditional expressions. Tail
recursion is detected at this time also. Decisions are made about
how best to arrange loops and how to output `switch' statements.
The source files for RTL generation include `stmt.c', `calls.c',
`expr.c', `explow.c', `expmed.c', `function.c', `optabs.c' and
`emit-rtl.c'. Also, the file `insn-emit.c', generated from the
machine description by the program `genemit', is used in this
pass. The header file `expr.h' is used for communication within
this pass.
The header files `insn-flags.h' and `insn-codes.h', generated from
the machine description by the programs `genflags' and `gencodes',
tell this pass which standard names are available for use and
which patterns correspond to them.
Aside from debugging information output, none of the following
passes refers to the tree structure representation of the function
(only part of which is saved).
The decision of whether the function can and should be expanded
inline in its subsequent callers is made at the end of rtl
generation. The function must meet certain criteria, currently
related to the size of the function and the types and number of
parameters it has. Note that this function may contain loops,
recursive calls to itself (tail-recursive functions can be
inlined!), gotos, in short, all constructs supported by GCC. The
file `integrate.c' contains the code to save a function's rtl for
later inlining and to inline that rtl when the function is called.
The header file `integrate.h' is also used for this purpose.
The option `-dr' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.rtl' to
the input file name.
* Jump optimization. This pass simplifies jumps to the following
instruction, jumps across jumps, and jumps to jumps. It deletes
unreferenced labels and unreachable code, except that unreachable
code that contains a loop is not recognized as unreachable in this
pass. (Such loops are deleted later in the basic block analysis.)
It also converts some code originally written with jumps into
sequences of instructions that directly set values from the
results of comparisons, if the machine has such instructions.
Jump optimization is performed two or three times. The first time
is immediately following RTL generation. The second time is after
CSE, but only if CSE says repeated jump optimization is needed.
The last time is right before the final pass. That time,
cross-jumping and deletion of no-op move instructions are done
together with the optimizations described above.
The source file of this pass is `jump.c'.
The option `-dj' causes a debugging dump of the RTL code after
this pass is run for the first time. This dump file's name is
made by appending `.jump' to the input file name.
* Register scan. This pass finds the first and last use of each
register, as a guide for common subexpression elimination. Its
source is in `regclass.c'.
* Jump threading. This pass detects a condition jump that branches
to an identical or inverse test. Such jumps can be `threaded'
through the second conditional test. The source code for this
pass is in `jump.c'. This optimization is only performed if
`-fthread-jumps' is enabled.
* Common subexpression elimination. This pass also does constant
propagation. Its source file is `cse.c'. If constant propagation
causes conditional jumps to become unconditional or to become
no-ops, jump optimization is run again when CSE is finished.
The option `-ds' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.cse' to
the input file name.
* Global common subexpression elimination. This pass performs GCSE
using Morel-Renvoise Partial Redundancy Elimination, with the
exception that it does not try to move invariants out of loops -
that is left to the loop optimization pass. This pass also
performs global constant and copy propagation.
The source file for this pass is gcse.c.
The option `-dG' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.gcse' to
the input file name.
* Loop optimization. This pass moves constant expressions out of
loops, and optionally does strength-reduction and loop unrolling
as well. Its source files are `loop.c' and `unroll.c', plus the
header `loop.h' used for communication between them. Loop
unrolling uses some functions in `integrate.c' and the header
`integrate.h'.
The option `-dL' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.loop' to
the input file name.
* If `-frerun-cse-after-loop' was enabled, a second common
subexpression elimination pass is performed after the loop
optimization pass. Jump threading is also done again at this time
if it was specified.
The option `-dt' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.cse2' to
the input file name.
* Stupid register allocation is performed at this point in a
nonoptimizing compilation. It does a little data flow analysis as
well. When stupid register allocation is in use, the next pass
executed is the reloading pass; the others in between are skipped.
The source file is `stupid.c'.
* Data flow analysis (`flow.c'). This pass divides the program into
basic blocks (and in the process deletes unreachable loops); then
it computes which pseudo-registers are live at each point in the
program, and makes the first instruction that uses a value point at
the instruction that computed the value.
This pass also deletes computations whose results are never used,
and combines memory references with add or subtract instructions
to make autoincrement or autodecrement addressing.
The option `-df' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.flow' to
the input file name. If stupid register allocation is in use, this
dump file reflects the full results of such allocation.
* Instruction combination (`combine.c'). This pass attempts to
combine groups of two or three instructions that are related by
data flow into single instructions. It combines the RTL
expressions for the instructions by substitution, simplifies the
result using algebra, and then attempts to match the result
against the machine description.
The option `-dc' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.combine'
to the input file name.
* Register movement (`regmove.c'). This pass looks for cases where
matching constraints would force an instruction to need a reload,
and this reload would be a register to register move. It them
attempts to change the registers used by the instruction to avoid
the move instruction.
The option `-dN' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.regmove'
to the input file name.
* Instruction scheduling (`sched.c'). This pass looks for
instructions whose output will not be available by the time that
it is used in subsequent instructions. (Memory loads and floating
point instructions often have this behavior on RISC machines). It
re-orders instructions within a basic block to try to separate the
definition and use of items that otherwise would cause pipeline
stalls.
Instruction scheduling is performed twice. The first time is
immediately after instruction combination and the second is
immediately after reload.
The option `-dS' causes a debugging dump of the RTL code after this
pass is run for the first time. The dump file's name is made by
appending `.sched' to the input file name.
* Register class preferencing. The RTL code is scanned to find out
which register class is best for each pseudo register. The source
file is `regclass.c'.
* Local register allocation (`local-alloc.c'). This pass allocates
hard registers to pseudo registers that are used only within one
basic block. Because the basic block is linear, it can use fast
and powerful techniques to do a very good job.
The option `-dl' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.lreg' to
the input file name.
* Global register allocation (`global.c'). This pass allocates hard
registers for the remaining pseudo registers (those whose life
spans are not contained in one basic block).
* Reloading. This pass renumbers pseudo registers with the hardware
registers numbers they were allocated. Pseudo registers that did
not get hard registers are replaced with stack slots. Then it
finds instructions that are invalid because a value has failed to
end up in a register, or has ended up in a register of the wrong
kind. It fixes up these instructions by reloading the
problematical values temporarily into registers. Additional
instructions are generated to do the copying.
The reload pass also optionally eliminates the frame pointer and
inserts instructions to save and restore call-clobbered registers
around calls.
Source files are `reload.c' and `reload1.c', plus the header
`reload.h' used for communication between them.
The option `-dg' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.greg' to
the input file name.
* Instruction scheduling is repeated here to try to avoid pipeline
stalls due to memory loads generated for spilled pseudo registers.
The option `-dR' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.sched2'
to the input file name.
* Jump optimization is repeated, this time including cross-jumping
and deletion of no-op move instructions.
The option `-dJ' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.jump2' to
the input file name.
* Delayed branch scheduling. This optional pass attempts to find
instructions that can go into the delay slots of other
instructions, usually jumps and calls. The source file name is
`reorg.c'.
The option `-dd' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.dbr' to
the input file name.
* Conversion from usage of some hard registers to usage of a register
stack may be done at this point. Currently, this is supported only
for the floating-point registers of the Intel 80387 coprocessor.
The source file name is `reg-stack.c'.
The options `-dk' causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending `.stack' to
the input file name.
* Final. This pass outputs the assembler code for the function. It
is also responsible for identifying spurious test and compare
instructions. Machine-specific peephole optimizations are
performed at the same time. The function entry and exit sequences
are generated directly as assembler code in this pass; they never
exist as RTL.
The source files are `final.c' plus `insn-output.c'; the latter is
generated automatically from the machine description by the tool
`genoutput'. The header file `conditions.h' is used for
communication between these files.
* Debugging information output. This is run after final because it
must output the stack slot offsets for pseudo registers that did
not get hard registers. Source files are `dbxout.c' for DBX
symbol table format, `sdbout.c' for SDB symbol table format, and
`dwarfout.c' for DWARF symbol table format.
Some additional files are used by all or many passes:
* Every pass uses `machmode.def' and `machmode.h' which define the
machine modes.
* Several passes use `real.h', which defines the default
representation of floating point constants and how to operate on
them.
* All the passes that work with RTL use the header files `rtl.h' and
`rtl.def', and subroutines in file `rtl.c'. The tools `gen*' also
use these files to read and work with the machine description RTL.
* Several passes refer to the header file `insn-config.h' which
contains a few parameters (C macro definitions) generated
automatically from the machine description RTL by the tool
`genconfig'.
* Several passes use the instruction recognizer, which consists of
`recog.c' and `recog.h', plus the files `insn-recog.c' and
`insn-extract.c' that are generated automatically from the machine
description by the tools `genrecog' and `genextract'.
* Several passes use the header files `regs.h' which defines the
information recorded about pseudo register usage, and
`basic-block.h' which defines the information recorded about basic
blocks.
* `hard-reg-set.h' defines the type `HARD_REG_SET', a bit-vector
with a bit for each hard register, and some macros to manipulate
it. This type is just `int' if the machine has few enough hard
registers; otherwise it is an array of `int' and some of the
macros expand into loops.
* Several passes use instruction attributes. A definition of the
attributes defined for a particular machine is in file
`insn-attr.h', which is generated from the machine description by
the program `genattr'. The file `insn-attrtab.c' contains
subroutines to obtain the attribute values for insns. It is
generated from the machine description by the program `genattrtab'.
automatically generated by info2www version 1.2.2.9