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.  Routines for emitting diagnostic messages are defined in diagnostic.c.  The files pretty-print.h and pretty-print.c provide basic support for language-independent pretty-printing.

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 (Using the GNU Compiler Collection (GCC))).

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 a high level tree representation.  (Because of the semantic analysis that takes place during this pass, it does more than is formally considered to be parsing.)

     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 (Cpplib Internals).

     The source files to parse C are found in the toplevel directory, and by convention are named c-*.  Some of these are also used by the other C-like languages: c-common.c, c-common.def, c-format.c, c-opts.c, c-pragma.c, c-semantics.c, c-lex.c, c-incpath.c, c-ppoutput.c, c-cppbuiltin.c, c-common.h, c-dump.h, c.opt, c-incpath.h and c-pragma.h,

     Files specific to each language are in subdirectories named after the language in question, like ada, objc, cp (for C++).

  * Tree optimization.   This is the optimization of the tree representation, before converting into RTL code.

     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.

  * RTL generation.  This is the conversion of syntax tree into RTL code.

     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.

  * Sibling call optimization.   This pass performs tail recursion elimination, and tail and sibling call optimizations.  The purpose of these optimizations is to reduce the overhead of function calls, whenever possible.

     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.  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 files are 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.

  * Global common subexpression elimination.  This pass performs two different types of GCSE  depending on whether you are optimizing for size or not (LCM based GCSE tends to increase code size for a gain in speed, while Morel-Renvoise based GCSE does not). When optimizing for size, GCSE is done 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. If MR PRE GCSE is done, code hoisting (aka unification) is also done, as well as load motion. If you are optimizing for speed, LCM (lazy code motion) based GCSE is done.  LCM is based on the work of Knoop, Ruthing, and Steffen.  LCM based GCSE also does loop invariant code motion.  We also perform load and store motion when optimizing for speed. Regardless of which type of GCSE is used, the GCSE pass also performs global constant and  copy propagation.

     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 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. Loop dependency analysis routines are contained in dependence.c.

     Second loop optimization pass takes care of basic block level optimizations -- unrolling, peeling and unswitching loops. The source files are cfgloopanal.c and cfgloopmanip.c containing generic loop analysis and manipulation code, loop-init.c with initialization and finalization code, loop-unswitch.c for loop unswitching and loop-unroll.c for loop unrolling and peeling.

     The option -dL causes a debugging dump of the RTL code after these passes.  The dump file names are made by appending .loop and .loop2 to the input file name.

  * Jump bypassing.  This pass is an aggressive form of GCSE that transforms the control flow graph of a function by propagating constants into conditional branch instructions.

     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 .bypass to the input file name.

  * Simple optimization pass that splits independent uses of each pseudo increasing effect of other optimizations.  This can improve effect of the other transformation, such as CSE or register allocation. Its source files are web.c.

     The option -dZ causes a debugging dump of the RTL code after this pass.  This dump file's name is made by appending .web 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.

  * 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.

  * If-conversion is a transformation that transforms control dependencies into data dependencies (IE it transforms conditional code into a single control stream). It is implemented in the file 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.

  * 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 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.

  * 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 allocation.  These passes make sure that all occurrences of pseudo registers are eliminated, either by allocating them to a hard register, replacing them by an equivalent expression (e.g. a constant) or by placing them on the stack.  This is done in several subpasses:

       * 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).

       * Graph coloring register allocator.  The files 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.

       * 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.

  * Basic block reordering.  This pass implements profile guided code positioning.  If profile information is not available, various types of static analysis are performed to make the predictions normally coming from the profile feedback (IE execution frequency, branch probability, etc).  It is implemented in the file 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.

  * 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.

  * Branch shortening.  On many RISC machines, branch instructions have a limited range.  Thus, longer sequences of instructions must be used for long branches.  In this pass, the compiler figures out what how far each instruction will be from each other instruction, and therefore whether the usual instructions, or the longer sequences, must be used for each branch.

  * 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,  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:

  * 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.

  * All the tools that read the machine description use support routines found in gensupport.c, errors.c, and read-rtl.c.

  * 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 and information about processor pipeline characteristics for the instruction scheduler.  It is generated from the machine description by the program genattrtab.