Go to the first, previous, next, last section, table of contents.
GNU CC automatically arranges for main
to return 1 by default if
you fail to specify an explicit return value. This will be interpreted
by VMS as a status code indicating a normal successful completion.
Version 1 of GNU CC did not provide this default.
GNU CC on VMS works only with the GNU assembler, GAS. You need version
1.37 or later of GAS in order to produce value debugging information for
the VMS debugger. Use the ordinary VMS linker with the object files
produced by GAS.
Under previous versions of GNU CC, the generated code would occasionally
give strange results when linked to the sharable `VAXCRTL' library.
Now this should work.
A caveat for use of const
global variables: the const
modifier must be specified in every external declaration of the variable
in all of the source files that use that variable. Otherwise the linker
will issue warnings about conflicting attributes for the variable. Your
program will still work despite the warnings, but the variable will be
placed in writable storage.
Although the VMS linker does distinguish between upper and lower case
letters in global symbols, most VMS compilers convert all such symbols
into upper case and most run-time library routines also have upper case
names. To be able to reliably call such routines, GNU CC (by means of
the assembler GAS) converts global symbols into upper case like other
VMS compilers. However, since the usual practice in C is to distinguish
case, GNU CC (via GAS) tries to preserve usual C behavior by augmenting
each name that is not all lower case. This means truncating the name
to at most 23 characters and then adding more characters at the end
which encode the case pattern of those 23. Names which contain at
least one dollar sign are an exception; they are converted directly into
upper case without augmentation.
Name augmentation yields bad results for programs that use precompiled
libraries (such as Xlib) which were generated by another compiler. You
can use the compiler option `/NOCASE_HACK' to inhibit augmentation;
it makes external C functions and variables case-independent as is usual
on VMS. Alternatively, you could write all references to the functions
and variables in such libraries using lower case; this will work on VMS,
but is not portable to other systems. The compiler option `/NAMES'
also provides control over global name handling.
Function and variable names are handled somewhat differently with GNU
C++. The GNU C++ compiler performs name mangling on function
names, which means that it adds information to the function name to
describe the data types of the arguments that the function takes. One
result of this is that the name of a function can become very long.
Since the VMS linker only recognizes the first 31 characters in a name,
special action is taken to ensure that each function and variable has a
unique name that can be represented in 31 characters.
If the name (plus a name augmentation, if required) is less than 32
characters in length, then no special action is performed. If the name
is longer than 31 characters, the assembler (GAS) will generate a
hash string based upon the function name, truncate the function name to
23 characters, and append the hash string to the truncated name. If the
`/VERBOSE' compiler option is used, the assembler will print both
the full and truncated names of each symbol that is truncated.
The `/NOCASE_HACK' compiler option should not be used when you are
compiling programs that use libg++. libg++ has several instances of
objects (i.e. Filebuf
and filebuf
) which become
indistinguishable in a case-insensitive environment. This leads to
cases where you need to inhibit augmentation selectively (if you were
using libg++ and Xlib in the same program, for example). There is no
special feature for doing this, but you can get the result by defining a
macro for each mixed case symbol for which you wish to inhibit
augmentation. The macro should expand into the lower case equivalent of
itself. For example:
#define StuDlyCapS studlycaps
These macro definitions can be placed in a header file to minimize the
number of changes to your source code.
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 `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.
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 GNU CC. 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.
-
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.
-
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'.
Go to the first, previous, next, last section, table of contents.