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. A
high level tree representation is then generated from the input,
one function at a time. This tree code is then transformed into RTL
intermediate code, and processed. The files involved in transforming
the trees into RTL are expr.c
, expmed.c
, and
stmt.c
.
The order of trees that are processed, is not
necessarily the same order they are generated from
the input, due to deferred inlining, and other considerations.
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, or was deferred for some reason (this can occur in
templates, for example).
(see An Inline Function is As Fast As a Macro).
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.
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.
The language-independent source files for parsing are
tree.c
, fold-const.c
, and stor-layout.c
.
There are also header files tree.h
and tree.def
which define the format of the tree representation.
C preprocessing, for language front ends, that want or require it, is performed by cpplib, which is covered in separate documentation. In particular, the internals are covered in See Cpplib internals.
The source files to parse C are
c-convert.c
,
c-decl.c
,
c-errors.c
,
c-lang.c
,
c-objc-common.c
,
c-parse.in
,
c-aux-info.c
,
and
c-typeck.c
,
along with a header file
c-tree.h
and some files shared with Objective-C and C++.
The source files for parsing C++ are in cp/
.
They are parse.y
,
class.c
,
cvt.c
, decl.c
, decl2.c
,
except.c
,
expr.c
, init.c
, lex.c
,
method.c
, ptree.c
,
search.c
, spew.c
,
semantics.c
, tree.c
,
typeck2.c
, and
typeck.c
, along with header files cp-tree.def
,
cp-tree.h
, and decl.h
.
The special source files for parsing Objective-C are in objc/
.
They are objc-act.c
, objc-tree.def
, and objc-act.h
.
Certain C-specific files are used for this as well.
The files
c-common.c
,
c-common.def
,
c-format.c
,
c-opts.c
,
c-pragma.c
,
c-semantics.c
,
and
c-lex.c
,
along with header files
c-common.h
,
c-dump.h
,
and
c-pragma.h
,
are also used for all of the above languages.
Currently, the main optimization performed here is tree-based
inlining.
This is implemented in tree-inline.c
and used by both C and C++.
Note that tree based inlining turns off rtx based inlining (since it's more
powerful, it would be a waste of time to do rtx based inlining in
addition).
Constant folding and some arithmetic simplifications are also done
during this pass, on the tree representation.
The routines that perform these tasks are located in fold-const.c
.
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.
The source file of this pass is sibcall.c
The option -di
causes a debugging dump of the RTL code after
this pass is run. This dump file's name is made by appending
.sibling
to the input file name.
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.
regclass.c
.
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.
-fssa
option (it is also done automatically if you enable an SSA optimization pass).
These passes utilize a form called Static Single Assignment. In SSA form,
each variable (pseudo register) is only set once, giving you def-use
and use-def chains for free, and enabling a lot more optimization
passes to be run in linear time.
Conversion to and from SSA form is handled by functions in
ssa.c
.
The option -de
causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending .ssa
to
the input file name.
-fssa-ccp
option. This pass performs conditional constant propagation to simplify
instructions including conditional branches. This pass is more aggressive
than the constant propagation done by the CSE and GCSE passes, but operates
in linear time.
The option -dW
causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending .ssaccp
to
the input file name.
-fssa-dce
option. This pass performs elimination of code considered unnecessary because
it has no externally visible effects on the program. It operates in
linear time.
The option -dX
causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending .ssadce
to
the input file name.
cse.c
, and cselib.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.
The source file for this pass is gcse.c
, and the LCM routines
are in lcm.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.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
.
Loop dependency analysis routines are contained in dependence.c
.
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.
-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.
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.
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.
ifcvt.c
.
The option -dE
causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending .ce
to
the input file name.
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 then 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.
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.
regclass.c
.
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.c
). This pass
allocates hard registers for the remaining pseudo registers (those
whose life spans are not contained in one basic block).
ra.c
, ra-build.c
,
ra-colorize.c
, ra-debug.c
, ra-rewrite.c
together with
the header ra.h
contain another register allocator, which is used
when the option -fnew-ra
is given. In that case it is run instead
of the above mentioned local and global register allocation passes, and the
option -dl
causes a debugging dump of its work.
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.
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.
bb-reorder.c
, and the
various prediction routines are in predict.c
.
The option -dB
causes a debugging dump of the RTL code after
this pass. This dump file's name is made by appending .bbro
to
the input file name.
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.
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.
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.
dbxout.c
for DBX symbol table
format, sdbout.c
for SDB symbol table format, dwarfout.c
for DWARF symbol table format, files dwarf2out.c
and
dwarf2asm.c
for DWARF2 symbol table format, and vmsdbgout.c
for VMS debug symbol table format.
Some additional files are used by all or many passes:
machmode.def
and machmode.h
which define
the machine modes.
real.h
, which defines the default
representation of floating point constants and how to operate on them.
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.
gensupport.c
, errors.c
, and read-rtl.c
.
insn-config.h
which
contains a few parameters (C macro definitions) generated
automatically from the machine description RTL by the tool
genconfig
.
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
.
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.
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 and information
about processor pipeline characteristics for the instruction
scheduler. It is generated from the machine description by the
program genattrtab
.