NAME
gcc, g++ - GNU project C and C++ Compiler

SYNOPSIS
cc [option | filename ]...
gcc [option | filename ]...
g++ [option | filename ]...

SPECIAL NOTE
The information in this man page is extracted from the full
documentation of the GNU C compiler, and is limited to the meaning
of the options. MachTen Professional supplies both the (2.3.3) C
and C++ compilers. MachTen Personal supplies the (1.40) C compiler
only, which understands a subset of the full options shown.

DESCRIPTION
The C and C++ compilers are integrated. Both process input files
through one or more of four stages: preprocessing, compilation,
assembly, and linking. Source filename suffixes identify the
source language, but which name you use for the compiler governs
default assumptions:

gcc assumes preprocessed (.i) files are C and assumes C style
linking.

g++ assumes preprocessed (.i) files are C++ and assumes C++ style
linking.

For any given input file, the file name suggix determines what kind
of compilation is done:

file.c
C source; preprocess, compile, assemble

file.C
C++ source; preprocess, compile, assemble

file.cc
C++ source; preprocess, compile, assemble

file.cxx
C++ source; preprocess, compile, assemble

file.m
Objective-C source; preprocess, compile, assemble

file.i
preprocessed C; compile, assemble

file.ii
preprocessed C++; compile, assemble

file.s
Assembler source; assemble

file.S
Assembler source; preprocess, assemble

file.h
Preprocessor file; not usually named on command line

other
An object file to be fed straight into linking. Any file name
with no recognized suffix is treated this way.

Linking is always the last stage unless you use one of the -c, -S,
or -E options to avoid it (or unless compilation errors stop the
whole process). For the link stage, all .o files corresponding to
source files, -l libraries, unrecognized filenames (including named
.o object files and .a archives) are passed to the linker in
command-line order.

OPTIONS
Options must be separate: ‘-dr’ is quite different from ‘-d -r ’.

Most ‘-f’ and ‘-W’ options have two contrary forms: -fname and
-fno-name (or -Wname and -Wno-name). Only the non-default forms are
shown here.

Here is a summary of all the options, grouped by type.
Explanations are in the following sections.

Overall Options
-c -S -E -o file -pipe -v -x language

Language Options
-ansi -fall-virtual -fbuiltin-alloca -fcond-mismatch
-fdollars-in-identifiers -fenum-int-equiv -fno-asm
-fno-builtin -fno-strict-prototype -fsigned-bitfields
-fsigned-char -fthis-is-variable -funsigned-bitfields
-funsigned-char -fwritable-strings -traditional
-traditional-cpp -trigraphs

Warning Options
-fsyntax-only -pedantic -pedantic-errors -w -W -Wall
-Waggregate-return -Wcast-align -Wcast-qual -Wcomment
-Wconversion -Wenum-clash -Werror -Wformat -Wid-clash-len
-Wimplicit -Winline -Wmissing-prototypes -Wparentheses
-Wpointer-arith -Wreturn-type -Wshadow -Wstrict-prototypes
-Wswitch -Wtraditional -Wtrigraphs -Wuninitialized -Wunused
-Wwrite-strings

Debugging Options
-a -dletters -fpretend-float -g -gstabs -gdwarf -ggdb -gsdb -p
-pg -save-temps

Optimization Options
-fcaller-saves -fcse-follow-jumps -fdelayed-branch
-felide-constructors -fexpensive-optimizations -ffloat-store
-fforce-addr -fforce-mem -finline -finline-functions
-fkeep-inline-functions -fmemoize-lookups -fno-default-inline
-fno-defer-pop -fno-function-cse -fomit-frame-pointer
-frerun-cse-after-loop -fschedule-insns -fschedule-insns2
-fstrength-reduce -fthread-jumps -funroll-all-loops
-funroll-loops -O -O2

Preprocessor Options
-C -dD -dM -dN -Dmacro[=defn] -E -H -i file -M -MD -MM -MMD
-nostdinc -P -Umacro -undef

Linker Options
-llibrary -nostdlib -static

Directory Options
-Bprefix -Idir -I- -Ldir

Target Options
-b machine -V version

Machine Dependent Options
M680x0 Options
-m68000 -m68020 -m68881 -mbitfield -mc68000 -mc68020 -mfpa
-mnobitfield -mrtd -mshort -msoft-float

RS6000 Options
-mfp-in-toc -mno-fop-in-toc

Code Generation Options
+eN -fcall-saved-reg -fcall-used-reg -ffixed-reg -fno-common
-fno-gnu-binutils -fnonnull-objects -fpcc-struct-return -fpic
-fPIC -fshared-data -fshort-enums -fshort-double -fvolatile

C (1.40) Option Summary
-c -S -E -o file -pipe

-ansi -fbuiltin-alloca -fcond-mismatch -fno-asm -fsigned-char
-funsigned-char -fwritable-strings -traditional -trigraphs

-pedantic -w -W -Wall -Wcast-qual -Wcomment -Wid-clash-len
-Wimplicit -Wpointer-arith -Wreturn-type -Wshadow -Wswitch
-Wtrigraphs -Wunused -Wwrite-strings

-a -dletters -g -p -pg

-fcaller-saves -fdelayed-branch -ffloat-store -fforce-addr
-fforce-mem -finline-functions -fkeep-inline-functions
-fno-defer-pop -fno-function-cse -fomit-frame-pointer
-fstrength-reduce -O

-C -Dmacro[=defn] -E -M -MM -nostdinc -Umacro -undef

-m68000 -m68020 -m68881 -mbitfield -mc68000 -mc68020 -mfpa
-mnobitfield -mrtd -mshort -msoft-float

-fcall-saved-reg -fcall-used-reg -ffixed-reg
-fpcc-struct-return -fshared-data -fvolatile

OVERALL OPTIONS
-x language
Specify explicitly the language for the following input files
(rather than choosing a default based on the file name suffix)
. This option applies to all following input files until the
next ‘-x’ option. Possible values of language are ‘c’,
‘objective-c’, ‘c-header’, ‘c++’, ‘cpp-output’, ‘assembler’,
and ‘assembler-with-cpp’.

-x none
Turn off any specification of a language, so that subsequent
files are handled according to their file name suffixes (as
they are if ‘-x’ has not been used at all).

If you want only some of the four stages (preprocess, compile, as-
semble, link), you can use ‘-x’ (or filename suffixes) to tell gcc
where to start, and one of the options ‘-c’, ‘-S’, or ‘-E’ to say
where gcc is to stop. Note that some combinations (for example,
‘-x cpp-output -E’) instruct gcc to do nothing at all.

-c Compile or assemble the source files, but do not link. The
compiler output is an object file corresponding to each source
file.

By default, GCC makes the object file name for a source file
by replacing the suffix ‘.c’, ‘.i’, ‘.s’, etc., with ‘.o’.
Use -o to select another name.

GCC ignores any unrecognized input files (those that do not
require compilation or assembly) with the -c option.

-S Stop after the stage of compilation proper; do not assemble.
The output is an assembler code file for each non-assembler
input file specified.

By default, GCC makes the assembler file name for a source
file by replacing the suffix ‘.c’, ‘.i’, etc., with ‘.s’. Use
-o to select another name.

GCC ignores any input files that don’t require compilation.

-E Stop after the preprocessing stage; do not run the compiler
proper. The output is preprocessed source code, which is sent
to the standard output.

GCC ignores input files which don’t require preprocessing.

-o file
Place output in file file. This applies regardless to what-
ever sort of output GCC is producing, whether it be an execut-
able file, an object file, an assembler file or preprocessed C
code.

Since only one output file can be specified, it does not make
sense to use ‘-o’ when compiling more than one input file, un-
less you are producing an executable file as output.

If you do not specify ‘-o’, the default is to put an execut-
able file in ‘a.out’, the object file for ‘source.suffix’ in
‘source.o’, its assembler file in ‘source.s’, and all prepro-
cessed C source on standard output.

-v Print (on standard error output) the commands executed to run
the stages of compilation. Also print the version number of
the compiler driver program and of the preprocessor and the
compiler proper.

-pipe
Use pipes rather than temporary files for communication
between the various stages of compilation. This fails to work
on some systems where the assembler cannot read from a pipe;
but the GNU assembler has no trouble.

LANGUAGE OPTIONS
The following options control the dialect of C that the compiler
accepts:

-ansi
Support all ANSI standard C programs.

This turns off certain features of GNU C that are incompatible
with ANSI C, such as the asm, inline and typeof keywords, and
predefined macros such as unix and vax that identify the type
of system you are using. It also enables the undesirable and
rarely used ANSI trigraph feature, and makes the preprocessor
accept ‘$’ as part of identifiers.

The alternate keywords __asm__, __extension__, __inline__ and
__typeof__ continue to work despite ‘-ansi’. You would not
want to use them in an ANSI C program, of course, but it is
useful to put them in header files that might be included in
compilations done with ‘-ansi’. Alternate predefined macros
such as __unix__ and __vax__ are also available, with or
without ‘-ansi’.

The ‘-ansi’ option does not cause non-ANSI programs to be re-
jected gratuitously. For that, ‘-pedantic’ is required in ad-
dition to ‘-ansi’.

The preprocessor predefines a macro __STRICT_ANSI__ when you
use the ‘-ansi’ option. Some header files may notice this
macro and refrain from declaring certain functions or defining
certain macros that the ANSI standard doesn’t call for; this
is to avoid interfering with any programs that might use these
names for other things.

The functions are not builtin functions when ‘-ansi’ is used.

-fall-virtual
(C++ only.) When you use the ‘-fall-virtual’, all member func-
tions (except for constructor functions and new/delete member
operators) declared in the same class with a "method-call"
operator method are treated as virtual functions of the given
class. In effect, all of these methods become "implicitly
virtual."

This does not mean that all calls to these methods will be
made through the internal table of virtual functions. There
are some circumstances under which it is obvious that a call
to a given virtual function can be made directly, and in these
cases the calls still go direct.

The effect of making all methods of a class with a declared
‘operator->()()’ implicitly virtual using ‘-fall-virtual’ ex-
tends also to all non-constructor methods of any class derived
from such a class.

-fbuiltin-alloca
Recognize __builtin_alloca as a built-in function and emit
code which directly manipulates the stack. This is not recom-
mended for systems not providing virtual memory; instead use
__builtin_alloca function supplied in libc.a, which determines
at runtime how best to satisfy the request.

-fdollars-in-identifiers
(C++ only.) Permit the use of ‘$’ in identifiers. (For GNU
C, this is the default, and you can forbid it with ‘-ansi’.)
Traditional C allowed the character ‘$’ to form part of iden-
tifiers; by default, GNU C also allows this. However, ANSI C
forbids ‘$’ in identifiers, and GNU C++ also forbids it by de-
fault on most platforms (though on some platforms it’s enabled
by default for GNU C++ as well).

-fenum-int-equiv
(C++ only.) Normally GNU C++ allows conversion of enum to int,
but not the other way around. Use this option if you want GNU
C++ to allow conversion of int to enum as well.

-fno-asm
Do not recognize asm, inline or typeof as a keyword. These
words may then be used as identifiers. You can use __asm__,
__inline__ and __typeof__ instead. ‘-ansi’ implies
‘-fno-asm’.

-fno-builtin
(Ignored for C++.) Don’t recognize built-in functions that do
not begin with two leading underscores. Currently, the func-
tions affected include _exit, abort, abs, alloca, cos, exit,
fabs, labs, memcmp, memcpy, sin, sqrt, strcmp, strcpy, and
strlen. The ‘-ansi’ option prevents allocaand_exit from being
builtin functions.

-fno-strict-prototype
(C++ only.) Consider the declaration int foo ();. In C++,
this means that the function foo takes no arguments. In ANSI
C, this is declared int foo(void);. With the flag
‘-fno-strict-prototype’, declaring functions with no arguments
is equivalent to declaring its argument list to be untyped,
i.e., int foo (); is equivalent to saying int foo (...);.

-fthis-is-variable
(C++ only.) The incorporation of user-defined free store
management into C++ has made assignment to this an anachron-
ism. Therefore, by default GNU C++ treats the type of this in
a member function of class X to be X *const. In other words,
it is illegal to assign to this within a class member func-
tion. However, for backwards compatibility, you can invoke
the old behavior by using ‘-fthis-is-variable’.

-trigraphs
Support ANSI C trigraphs. The ‘-ansi’ option implies ‘-tri-
graphs’.

-traditional
Attempt to support some aspects of traditional C compilers.
For details, see the GNU C Manual; the duplicate list here has
been deleted so that we won’t get complaints when it is out of
date.

But one note about C++ programs only (not C). ‘-traditional’
has one additional effect for C++: assignment to this is per-
mitted. This is the same as the effect of
‘-fthis-is-variable’.

-traditional-cpp
Attempt to support some aspects of traditional C preproces-
sors. This includes the items that specifically mention the
preprocessor above, but none of the other effects of ‘-tradi-
tional’.

-fcond-mismatch
Allow conditional expressions with mismatched types in the
second and third arguments. The value of such an expression
is void.

-funsigned-char
Let the type char be unsigned, like unsigned char.

Each kind of machine has a default for what char should be.
It is either like unsigned char by default or like signed char
by default.

Ideally, a portable program should always use signed char or
unsigned char when it depends on the signedness of an object.
But many programs have been written to use plain char and ex-
pect it to be signed, or expect it to be unsigned, depending
on the machines they were written for. This option, and its
inverse, let you make such a program work with the opposite
default.

The type char is always a distinct type from each of signed
char and unsigned char, even though its behavior is always
just like one of those two.

-fsigned-char
Let the type char be signed, like signed char.

Note that this is equivalent to ‘-fno-unsigned-char’, which is
the negative form of ‘-funsigned-char’. Likewise,
‘-fno-signed-char’ is equivalent to ‘-funsigned-char’.

-fsigned-bitfields

-funsigned-bitfields

-fno-signed-bitfields

-fno-unsigned-bitfields
These options control whether a bitfield is signed or un-
signed, when declared with no explicit ‘signed’ or ‘unsigned’
qualifier. By default, such a bitfield is signed, because
this is consistent: the basic integer types such as int are
signed types.

However, when you specify ‘-traditional’, bitfields are all
unsigned no matter what.

-fwritable-strings
Store string constants in the writable data segment and don’t
uniquize them. This is for compatibility with old programs
which assume they can write into string constants. ‘-tradi-
tional’ also has this effect.

Writing into string constants is a very bad idea; "con-
stants" should be constant.

PREPROCESSOR OPTIONS
These options control the C preprocessor, which is run on each C
source file before actual compilation.

If you use the ‘-E’ option, GCC does nothing except preprocessing.
Some of these options make sense only together with ‘-E’ because
they cause the preprocessor output to be unsuitable for actual com-
pilation.

-include file
Process file as input before processing the regular input
file. In effect, the contents of fileare compiled first. Any
‘-D’ and ‘-U’ options on the command line are always processed
before ‘-include file ’ All the ‘-include ’ and ‘-imacros ’
options are processed in the order in which they are written.

-imacros file
Process file as input, discarding the resulting output, be-
fore processing the regular input file. Because the output
generated from file is discarded, the only effect of ‘-i file’
is to make the macros defined in file available for use in the
main input. Any ‘-D’ and ‘-U’ options on the command line are
always processed before ‘-include file ’ All the ‘-include ’
and ‘-imacros ’ options are processed in the order in which
they are written.

-nostdinc
Do not search the standard system directories for header
files. Only the directories you have specified with ‘-I’ op-
tions (and the current directory, if appropriate) are
searched.

By using both ‘-nostdinc’ and ‘-I-’, you can limit the
include-file search file to only those directories you specify
explicitly.

-undef
Do not predefine any nonstandard macros. (Including architec-
ture flags).

-E Run only the C preprocessor. Preprocess all the C source
files specified and output the results to standard output or
to the specified output file.

-C Tell the preprocessor not to discard comments. Used with the
‘-E’ option.

-P Tell the preprocessor not to generate ‘#line’ commands. Used
with the ‘-E’ option.

-M Tell the preprocessor to output a rule suitable for make
describing the dependencies of each object file. For each
source file, the preprocessor outputs one make-rule whose tar-
get is the object file name for that source file and whose
dependencies are all the files ‘#include’d in it. This rule
may be a single line or may be continued with ‘´-newline if
it is long. The list of rules is printed on standard output
instead of the preprocessed C program.

‘-M’ implies ‘-E’.

-MM Like ‘-M’ but the output mentions only the user header files
included with ‘#include file"’. System header files included
with ‘#include <file>’ are omitted.

-MD Like ‘-M’ but the dependency information is written to files
with names made by replacing ‘.c’ with ‘.d’ at the end of the
input file names. This is in addition to compiling the file
as specified-‘-MD’ does not inhibit ordinary compilation the
way ‘-M’ does.

The Mach utility ‘md’ can be used to merge the ‘.d’ files into
a single dependency file suitable for using with the ‘make’
command.

-MMD Like ‘-MD’ except mention only user header files, not system
header files.

-H Print the name of each header file used, in addition to other
normal activities.

-Aquestion(answer)
Assert the answer answer for question, in case it is tested
with a preprocessor conditional such as ‘#if #question(answer)
’. ‘-A- ’ disables the standard assertions that normally
describe the target machine.

-Dmacro
Define macro macro with the string ‘1’ as its definition.

-Dmacro=defn
Define macro macro as defn. All instances of ‘-D’ on the
command line are processed before any ‘-U’ or ‘-i’ options.

-Umacro
Undefine macro macro. ‘-U’ options are evaluated after all
‘-D’ options, but before any ‘-i’ options.

-dM Tell the preprocessor to output only a list of the macro de-
finitions that are in effect at the end of preprocessing.
Used with the ‘-E’ option.

-dD Tell the preprocessing to pass all macro definitions into the
output, in their proper sequence in the rest of the output.

-dN Like ‘-dD’ except that the macro arguments and contents are
omitted. Only ‘#define name’ is included in the output.

LINKER OPTIONS
These options come into play when the compiler links object files
into an executable output file. They are meaningless if the com-
piler is not doing a link step.

object-file-name
A file name that does not end in a special recognized suffix
is considered to name an object file or library. (Object
files are distinguished from libraries by the linker according
to the file contents.) If GCC does a link step, these object
files are used as input to the linker.

-llibrary
Use the library named library when linking.

The linker searches a standard list of directories for the li-
brary, which is actually a file named ‘liblibrary.a’. The
linker then uses this file as if it had been specified pre-
cisely by name.

The directories searched include several standard system
directories plus any that you specify with ‘-L’.

Normally the files found this way are library files-archive
files whose members are object files. The linker handles an
archive file by scanning through it for members which define
symbols that have so far been referenced but not defined.
However, if the linker finds an ordinary object file rather
than a library, the object file is linked in the usual
fashion. The only difference between using an ‘-l’ option and
specifying a file name is that ‘-l’ surrounds library with
‘lib’ and ‘.a’ and searches several directories.

-nostdlib
Don’t use the standard system libraries and startup files when
linking. Only the files you specify will be passed to the
linker.

-static
On systems that support dynamic linking, this prevents linking
with the shared libraries. On other systems, this option has
no effect.

DIRECTORY OPTIONS
These options specify directories to search for header files, for
libraries and for parts of the compiler:

-Idir
Append directory dir to the list of directories searched for
include files.

-I- Any directories you specify with ‘-I’ options before the ‘-I-’
option are searched only for the case of ‘#include "file"’;
they are not searched for ‘#include <file>’.

If additional directories are specified with ‘-I’ options
after the ‘-I-’, these directories are searched for all ‘#in-
clude’ directives. (Ordinarily all ‘-I’ directories are used
this way.)

In addition, the ‘-I-’ option inhibits the use of the current
directory (where the current input file came from) as the
first search directory for ‘#include "file"’. There is no way
to override this effect of ‘-I-’. With ‘-I.’ you can specify
searching the directory which was current when the compiler
was invoked. That is not exactly the same as what the prepro-
cessor does by default, but it is often satisfactory.

‘-I-’ does not inhibit the use of the standard system direc-
tories for header files. Thus, ‘-I-’ and ‘-nostdinc’ are in-
dependent.

-Ldir
Add directory dir to the list of directories to be searched
for ‘-l’.

-Bprefix
This option specifies where to find the executables, li-
braries and data files of the compiler itself.

The compiler driver program runs one or more of the subpro-
grams ‘cpp’, ‘cc1’ (or, for C++, ‘cc1plus’), ‘as’ and ‘ld’.
It tries prefix as a prefix for each program it tries to run,
both with and without ‘machine/version/’.

For each subprogram to be run, the compiler driver first tries
the ‘-B’ prefix, if any. If that name is not found, or if
‘-B’ was not specified, the driver tries the prefix
‘/usr/local/VMtools/’ and ‘/usr/local/lib/gcc-lib/’. If the
program is still not found, the compiler driver searches for
the unmodified program name, using the directories specified
in your ‘PATH’ environment variable.

The run-time support file ‘libgcc.a’ is also searched for us-
ing the ‘-B’ prefix, if needed. If it is not found there, the
two standard prefixes above are tried, and that is all. The
file is left out of the link if it is not found by those
means. Most of the time, on most machines, ‘libgcc.a’ is not
actually necessary.

You can get a similar result from the environment variable
GCC_EXEC_PREFIX; if it is defined, its value is used as a pre-
fix in the same way. If both the ‘-B’ option and the
GCC_EXEC_PREFIX variable are present, the ‘-B’ option is used
first and the environment variable value second.

WARNING OPTIONS
Warnings are diagnostic messages that report constructions which
are not inherently erroneous but which are risky or suggest there
may have been an error.

These options control the amount and kinds of warnings produced by
GNU CC:

-fsyntax-only
Check the code for syntax errors, but don’t emit any output.

-w Inhibit all warning messages.

-pedantic
Issue all the warnings demanded by strict ANSI standard C; re-
ject all programs that use forbidden extensions.

Valid ANSI standard C programs should compile properly with or
without this option (though a rare few will require ‘-ansi’).
However, without this option, certain GNU extensions and trad-
itional C features are supported as well. With this option,
they are rejected. There is no reason to use this option; it
exists only to satisfy pedants.

‘-pedantic’ does not cause warning messages for use of the al-
ternate keywords whose names begin and end with ‘__’. Pedan-
tic warnings are also disabled in the expression that follows
__extension__. However, only system header files should use
these escape routes; application programs should avoid them.

-pedantic-errors
Like ‘-pedantic’, except that errors are produced rather than
warnings.

-W Print extra warning messages for these events:

A nonvolatile automatic variable might be changed by a call to
longjmp. These warnings are possible only in optimizing com-
pilation.

The compiler sees only the calls to setjmp. It cannot know
where longjmp will be called; in fact, a signal handler could
call it at any point in the code. As a result, you may get a
warning even when there is in fact no problem because longjmp
cannot in fact be called at the place which would cause a
problem.

A function can return either with or without a value. (Fal-
ling off the end of the function body is considered returning
without a value.) For example, this function would evoke such
a warning:

foo (a)
{
if (a > 0)
return a;
}

Spurious warnings can occur because GNU CC does not realize
that certain functions (including abort and longjmp) will nev-
er return.

An expression-statement contains no side effects.

An unsigned value is compared against zero with ‘>’ or ‘<=’.

-Wimplicit
Warn whenever a function or parameter is implicitly declared.

-Wreturn-type
Warn whenever a function is defined with a return-type that
defaults to int. Also warn about any return statement with no
return-value in a function whose return-type is not void.

-Wunused
Warn whenever a local variable is unused aside from its de-
claration, whenever a function is declared static but never
defined, and whenever a statement computes a result that is
explicitly not used.

-Wswitch
Warn whenever a switch statement has an index of enumeral type
and lacks a case for one or more of the named codes of that
enumeration. (The presence of a default label prevents this
warning.) case labels outside the enumeration range also pro-
voke warnings when this option is used.

-Wcomment
Warn whenever a comment-start sequence ‘/*’ appears in a com-
ment.

-Wtrigraphs
Warn if any trigraphs are encountered (assuming they are en-
abled).

-Wformat
Check calls to printf and scanf, etc., to make sure that the
arguments supplied have types appropriate to the format string
specified.

-Wuninitialized
An automatic variable is used without first being initialized.

These warnings are possible only in optimizing compilation,
because they require data flow information that is computed
only when optimizing. If you don’t specify ‘-O’, you simply
won’t get these warnings.

These warnings occur only for variables that are candidates
for register allocation. Therefore, they do not occur for a
variable that is declared volatile, or whose address is taken,
or whose size is other than 1, 2, 4 or 8 bytes. Also, they do
not occur for structures, unions or arrays, even when they are
in registers.

Note that there may be no warning about a variable that is
used only to compute a value that itself is never used, be-
cause such computations may be deleted by data flow analysis
before the warnings are printed.

These warnings are made optional because GNU CC is not smart
enough to see all the reasons why the code might be correct
despite appearing to have an error. Here is one example of
how this can happen:

{
int x;
switch (y)
{
case 1: x = 1;
break;
case 2: x = 4;
break;
case 3: x = 5;
}
foo (x);
}

If the value of y is always 1, 2 or 3, then x is always ini-
tialized, but GNU CC doesn’t know this. Here is another com-
mon case:

{
int save_y;
if (change_y) save_y = y, y = new_y;
...
if (change_y) y = save_y;
}

This has no bug because save_y is used only if it is set.

Some spurious warnings can be avoided if you declare as vola-
tile all the functions you use that never return.

-Wparentheses
Warn if parentheses are omitted in certain contexts.

-Wall
All of the above ‘-W’ options combined. These are all the op-
tions which pertain to usage that we recommend avoiding and
that we believe is easy to avoid, even in conjunction with
macros.

The remaining ‘-W...’ options are not implied by ‘-Wall’ because
they warn about constructions that we consider reasonable to use,
on occasion, in clean programs.

-Wtraditional
Warn about certain constructs that behave differently in trad-
itional and ANSI C.

Macro arguments occurring within string constants in the macro
body. These would substitute the argument in traditional C,
but are part of the constant in ANSI C.

A function declared external in one block and then used after
the end of the block.

A switch statement has an operand of type long.

-Wshadow
Warn whenever a local variable shadows another local variable.

-Wid-clash-len
Warn whenever two distinct identifiers match in the first len
characters. This may help you prepare a program that will
compile with certain obsolete, brain-damaged compilers.

-Wpointer-arith
Warn about anything that depends on the "size of" a function
type or of void. GNU C assigns these types a size of 1, for
convenience in calculations with void * pointers and pointers
to functions.

-Wcast-qual
Warn whenever a pointer is cast so as to remove a type qualif-
ier from the target type. For example, warn if a const char *
is cast to an ordinary char *.

-Wcast-align
Warn whenever a pointer is cast such that the required align-
ment of the target is increased. For example, warn if a char
* is cast to an int * on machines where integers can only be
accessed at two- or four-byte boundaries.

-Wwrite-strings
Give string constants the type const char[length] so that
copying the address of one into a non-const char * pointer
will get a warning. These warnings will help you find at com-
pile time code that can try to write into a string constant,
but only if you have been very careful about using const in
declarations and prototypes. Otherwise, it will just be a
nuisance; this is why we did not make ‘-Wall’ request these
warnings.

-Wconversion
Warn if a prototype causes a type conversion that is different
from what would happen to the same argument in the absence of
a prototype. This includes conversions of fixed point to
floating and vice versa, and conversions changing the width or
signedness of a fixed point argument except when the same as
the default promotion.

-Waggregate-return
Warn if any functions that return structures or unions are de-
fined or called. (In languages where you can return an array,
this also elicits a warning.)

-Wstrict-prototypes
Warn if a function is declared or defined without specifying
the argument types. (An old-style function definition is per-
mitted without a warning if preceded by a declaration which
specifies the argument types.)

-Wmissing-prototypes
Warn if a global function is defined without a previous proto-
type declaration. This warning is issued even if the defini-
tion itself provides a prototype. The aim is to detect global
functions that fail to be declared in header files.

-Wenum-clash
(C++ only.) Warn when converting between different enumeration
types.

-Woverloaded-virtual
(C++ only.) In a derived class, the definitions of virtual
functions must match the type signature of a virtual function
declared in the base class. Use this option to request warn-
ings when a derived class declares a function that may be an
erroneous attempt to define a virtual function: that is, warn
when a function with the same name as a virtual function in
the base class, but with a type signature that doesn’t match
any virtual functions from the base class.

-Winline
Warn if a function can not be inlined, and either it was de-
clared as inline, or else the -finline-functions option was
given.

-Werror
Treat warnings as errors; abort compilation after any warning.

DEBUGGING OPTIONS
GNU CC has various special options that are used for debugging ei-
ther your program or GCC:

-g Produce debugging information in the operating system’s native
format (for DBX or SDB or DWARF). GDB also can work with this
debugging information. On most systems that use DBX format,
‘-g’ enables use of extra debugging information that only GDB
can use; if you want to control for certain whether to gen-
erate this information, use ‘-ggdb’ or ‘-gdbx’.

Unlike most other C compilers, GNU CC allows you to use ‘-g’
with ‘-O’. The shortcuts taken by optimized code may occa-
sionally produce surprising results: some variables you de-
clared may not exist at all; flow of control may briefly move
where you did not expect it; some statements may not be exe-
cuted because they compute constant results or their values
were already at hand; some statements may execute in different
places because they were moved out of loops.

Nevertheless it proves possible to debug optimized output.
This makes it reasonable to use the optimizer for programs
that might have bugs.

The following options are useful when GNU CC is configured and
compiled with the capability for more than one debugging for-
mat.

-ggdb
Produce debugging information in DBX format (if that is sup-
ported), including GDB extensions.

-gdbx
Produce debugging information in DBX format (if that is sup-
ported), without GDB extensions.

-gsdb
Produce debugging information in SDB format (if that is sup-
ported).

-gdwarf
Produce debugging information in DWARF format (if that is sup-
ported).

-glevel
-ggdblevel
-gdbxlevel
-gsdblevel

-gdwarflevel
Request debugging information and also use level to specify
how much information. The default level is 2.

Level 1 produces minimal information, enough for making back-
traces in parts of the program that you don’t plan to debug.
This includes descriptions of functions and external vari-
ables, but no information about local variables and no line
numbers.

-p Generate extra code to write profile information suitable for
the analysis program prof.

-pg Generate extra code to write profile information suitable for
the analysis program gprof.

-a Generate extra code to write profile information for basic
blocks, which will record the number of times each basic block
is executed. This data could be analyzed by a program like
tcov. Note, however, that the format of the data is not what
tcov expects. Eventually GNU gprof should be extended to pro-
cess this data.

-dletters
Says to make debugging dumps during compilation at times
specified by letters. This is used for debugging the com-
piler. The file names for most of the dumps are made by ap-
pending a word to the source file name (e.g. ‘foo.c.rtl’ or
‘foo.c.jump’).

-dM Dump all macro definitions, at the end of preprocessing, and
write no output.

-dN Dump all macro names, at the end of preprocessing.

-dD Dump all macro definitions, at the end of preprocessing, in
addition to normal output.

-dy Dump debugging information during parsing, to standard error.

-dr Dump after RTL generation, to ‘file.rtl’.

-dx Just generate RTL for a function instead of compiling it.
Usually used with ‘r’.

-dj Dump after first jump optimization, to ‘file.jump’.

-ds Dump after CSE (including the jump optimization that sometimes
follows CSE), to ‘file.cse’.

-dL Dump after loop optimization, to ‘file.loop’.

-dt Dump after the second CSE pass (including the jump optimiza-
tion that sometimes follows CSE), to ‘file.cse2’.

-df Dump after flow analysis, to ‘file.flow’.

-dc Dump after instruction combination, to ‘file.combine’.

-dS Dump after the first instruction scheduling pass, to
‘file.sched’.

-dl Dump after local register allocation, to ‘file.lreg’.

-dg Dump after global register allocation, to ‘file.greg’.

-dR Dump after the second instruction scheduling pass, to
‘file.sched2’.

-dJ Dump after last jump optimization, to ‘file.jump2’.

-dd Dump after delayed branch scheduling, to ‘file.dbr’.

-dk Dump after conversion from registers to stack, to
‘file.stack’.

-da Produce all the dumps listed above.

-dm Print statistics on memory usage, at the end of the run, to
standard error.

-dp Annotate the assembler output with a comment indicating which
pattern and alternative was used.

-fpretend-float
When running a cross-compiler, pretend that the target machine
uses the same floating point format as the host machine. This
causes incorrect output of the actual floating constants, but
the actual instruction sequence will probably be the same as
GNU CC would make when running on the target machine.

-save-temps
Store the usual "temporary" intermediate files permanently;
place them in the current directory and name them based on the
source file. Thus, compiling ‘foo.c’ with ‘-c -save-temps’
would produce files ‘foo.cpp’ and ‘foo.s’, as well as ‘foo.o’.

OPTIMIZATION OPTIONS
These options control various sorts of optimizations:

-O

-O1 Optimize. Optimizing compilation takes somewhat more time,
and a lot more memory for a large function.

Without ‘-O’, the compiler’s goal is to reduce the cost of
compilation and to make debugging produce the expected
results. Statements are independent: if you stop the program
with a breakpoint between statements, you can then assign a
new value to any variable or change the program counter to any
other statement in the function and get exactly the results
you would expect from the source code.

Without ‘-O’, only variables declared register are allocated
in registers. The resulting compiled code is a little worse
than produced by PCC without ‘-O’.

With ‘-O’, the compiler tries to reduce code size and execu-
tion time.

When you specify ‘-O’, ‘-fthread-jumps’ and ‘-fdelayed-branch’
are turned on. On some machines other flags may also be
turned on.

-O2 Highly optimize. As compared to ‘-O’, this option will in-
crease both compilation time and the performance of the gen-
erated code.

All ‘-fflag’ options that control optimization are turned on
when you specify ‘-O2’, except ‘-funroll-loops’ and
‘-funroll-all-loops’.

-O0 Do not optimize.

Options of the form ‘-fflag’ specify machine-independent flags.
Most flags have both positive and negative forms; the negative form
of ‘-ffoo’ would be ‘-fno-foo’. The following list shows only one
form-the one which is not the default. You can figure out the oth-
er form by either removing ‘no-’ or adding it.

-ffloat-store
Do not store floating point variables in registers. This
prevents undesirable excess precision on machines such as the
68000 where the floating registers (of the 68881) keep more
precision than a double is supposed to have.

For most programs, the excess precision does only good, but a
few programs rely on the precise definition of IEEE floating
point. Use ‘-ffloat-store’ for such programs.

-fno-defer-pop
Always pop the arguments to each function call as soon as that
function returns. For machines which must pop arguments after
a function call, the compiler normally lets arguments accumu-
late on the stack for several function calls and pops them all
at once.

-fforce-mem
Force memory operands to be copied into registers before doing
arithmetic on them. This may produce better code by making
all memory references potential common subexpressions. When
they are not common subexpressions, instruction combination
should eliminate the separate register-load. I am interested
in hearing about the difference this makes.

-fforce-addr
Force memory address constants to be copied into registers be-
fore doing arithmetic on them. This may produce better code
just as ‘-fforce-mem’ may. I am interested in hearing about
the difference this makes.

-fomit-frame-pointer
Don’t keep the frame pointer in a register for functions that
don’t need one. This avoids the instructions to save, set up
and restore frame pointers; it also makes an extra register
available in many functions. It also makes debugging impossi-
ble on most machines.

On some machines, such as the Vax, this flag has no effect,
because the standard calling sequence automatically handles
the frame pointer and nothing is saved by pretending it
doesn’t exist. The machine-description macro
FRAME_POINTER_REQUIRED controls whether a target machine sup-
ports this flag.

-fno-inline
Don’t pay attention the inline keyword. Normally this option
is used to keep the compiler from expanding any functions in-
line. Note that is you are not optimizing, no functions can
be expanded inline. -fno-inline’ is used to keep the compiler
from expanding any functions inline. However, the opposite
effect may be desirable when compiling with ‘-g’, since ‘-g’
normally turns off all inline function expansion.

-finline-functions
Integrate all simple functions into their callers. The com-
piler heuristically decides which functions are simple enough
to be worth integrating in this way.

If all calls to a given function are integrated, and the func-
tion is declared static, then GCC normally does not output the
function as assembler code in its own right.

-fkeep-inline-functions
Even if all calls to a given function are integrated, and the
function is declared static, nevertheless output a separate
run-time callable version of the function.

-fno-default-inline
(C++ only.) If ‘-fdefault-inline’ is enabled then member func-
tions defined inside class scope are compiled inline by de-
fault; i.e., you don’t need to add ‘inline’ in front of the
member function name. By popular demand, this option is now
the default. To keep GNU C++ from inlining these member func-
tions, specify ‘-fno-default-inline’.

-fno-function-cse
Do not put function addresses in registers; make each instruc-
tion that calls a constant function contain the function’s ad-
dress explicitly.

This option results in less efficient code, but some strange
hacks that alter the assembler output may be confused by the
optimizations performed when this option is not used.

-felide-constructors
(C++ only.) Use this option to instruct the compiler to be
smarter about when it can elide constructors. Without this
flag, GNU C++ and cfront both generate effectively the same
code for:

A foo ();
A x (foo ()); // x initialized by ‘foo ()’, no ctor called
A y = foo (); // call to ‘foo ()’ heads to temporary,
// y is initialized from the temporary.

Note the difference! With this flag, GNU C++ initializes ‘y’
directly from the call to foo () without going through a tem-
porary.

-fmemoize-lookups

-fsave-memoized
(C++ only.) These flags are used to get the compiler to com-
pile programs faster using heuristics. They are not on by de-
fault since they are only effective about half the time. The
other half of the time programs compile more slowly (and take
more memory).

The first time the compiler must build a call to a member
function (or reference to a data member), it must (1) deter-
mine whether the class implements member functions of that
name; (2) resolve which member function to call (which in-
volves figuring out what sorts of type conversions need to be
made); and (3) check the visibility of the member function to
the caller. All of this adds up to slower compilation. Nor-
mally, the second time a call is made to that member function
(or reference to that data member), it must go through the
same lengthy process again. This means that code like this

cout << "This " << p << " has " << n << " legs.0;

makes six passes through all three steps. By using a software
cache, a "hit" significantly reduces this cost. Unfor-
tunately, using the cache introduces another layer of mechan-
isms which must be implemented, and so incurs its own over-
head. ‘-fmemoize-lookups’ enables the software cache.

Because access privileges (visibility) to members and member
functions may differ from one function context to the next,
g++ may need to flush the cache. With the ‘-fmemoize-lookups’
flag, the cache is flushed after every function that is com-
piled. The ‘-fsave-memoized’ flag enables the same software
cache, but when the compiler determines that the context of
the last function compiled would yield the same access
privileges of the next function to compile, it preserves the
cache. This is most helpful when defining many member func-
tions for the same class: with the exception of member func-
tions which are friends of other classes, each member function
has exactly the same access privileges as every other, and the
cache need not be flushed.

The following options control specific optimizations. The ‘-O2’
option turns on all of these optimizations except ‘-funroll-loops’
and ‘-funroll-all-loops’.

The ‘-O’ option usually turns on the ‘-fthread-jumps’ and
‘-fdelayed-branch’ options, but specific machines may change the
default optimizations.

You can use the following flags in the rare cases when "fine-
tuning" of optimizations to be performed is desired.

-fstrength-reduce
Perform the optimizations of loop strength reduction and elim-
ination of iteration variables.

-fthread-jumps
Perform optimizations where we check to see if a jump branches
to a location where another comparison subsumed by the first
is found. If so, the first branch is redirected to either the
destination of the second branch or a point immediately fol-
lowing it, depending on whether the condition is known to be
true or false.

-fcse-follow-jumps
In common subexpression elimination, scan through jump in-
structions in certain cases. This is not as powerful as com-
pletely global CSE, but not as slow either.

-frerun-cse-after-loop
Re-run common subexpression elimination after loop optimiza-
tions has been performed.

-fexpensive-optimizations
Perform a number of minor optimizations that are relatively
expensive.

-fdelayed-branch
If supported for the target machine, attempt to reorder in-
structions to exploit instruction slots available after de-
layed branch instructions.

-fschedule-insns
If supported for the target machine, attempt to reorder in-
structions to eliminate execution stalls due to required data
being unavailable. This helps machines that have slow float-
ing point or memory load instructions by allowing other in-
structions to be issued until the result of the load or float-
ing point instruction is required.

-fschedule-insns2
Similar to ‘-fschedule-insns’, but requests an additional pass
of instruction scheduling after register allocation has been
done. This is especially useful on machines with a relatively
small number of registers and where memory load instructions
take more than one cycle.

-fcaller-saves
Enable values to be allocated in registers that will be clob-
bered by function calls, by emitting extra instructions to
save and restore the registers around such calls. Such allo-
cation is done only when it seems to result in better code
than would otherwise be produced.

This option is enabled by default on certain machines, usually
those which have no call-preserved registers to use instead.

-funroll-loops
Perform the optimization of loop unrolling. This is only done
for loops whose number of iterations can be determined at com-
pile time or run time.

-funroll-all-loops
Perform the optimization of loop unrolling. This is done for
all loops. This usually makes programs run more slowly.

TARGET OPTIONS
By default, GNU CC compiles code for the same type of machine that
you are using. However, it can also be installed as a cross-
compiler, to compile for some other type of machine. In fact,
several different configurations of GNU CC, for different target
machines, can be installed side by side. Then you specify which
one to use with the ‘-b’ option.

In addition, older and newer versions of GNU CC can be installed

side by side. One of them (probably the newest) will be the de-
fault, but you may sometimes wish to use another.

-b machine
The argument machine specifies the target machine for compi-
lation. This is useful when you have installed GNU CC as a
cross-compiler.

The value to use for machine is the same as was specified as
the machine type when configuring GNU CC as a cross-compiler.
For example, if a cross-compiler was configured with ‘config-
ure i386v’, meaning to compile for an 80386 running System V,
then you would specify ‘-b i386v’ to run that cross compiler.

When you do not specify ‘-b’, it normally means to compile for
the same type of machine that you are using.

-V version
The argument version specifies which version of GNU CC to
run. This is useful when multiple versions are installed.
For example, version might be ‘2.0’, meaning to run GNU CC
version 2.0.

The default version, when you do not specify ‘-V’, is con-
trolled by the way GNU CC is installed. Normally, it will be
a version that is recommended for general use.

MACHINE DEPENDENT OPTIONS
Each of the target machine types can have its own special options,
starting with ‘-m’, to choose among various hardware models or
configurations-for example, 68010 vs 68020, floating coprocessor or
none. A single installed version of the compiler can compile for
any model or configuration, according to the options specified.

These are the ‘-m’ options defined for the 68000 series:

-m68020

-mc68020
Generate output for a 68020 (rather than a 68000). This is
the default if you use the unmodified sources.

-m68000

-mc68000
Generate output for a 68000 (rather than a 68020).

-m68881
Generate output containing 68881 instructions for floating
point. This is the default if you use the unmodified sources.

-mfpa
Generate output containing Sun FPA instructions for floating
point.

-msoft-float
Generate output containing library calls for floating point.
WARNING: the requisite libraries are not part of GNU CC. Nor-
mally the facilities of the machine’s usual C compiler are
used, but this can’t be done directly in cross-compilation.
You must make your own arrangements to provide suitable li-
brary functions for cross-compilation.

-mshort
Consider type int to be 16 bits wide, like short int.

-mnobitfield
Do not use the bit-field instructions. ‘-m68000’ implies
‘-mnobitfield’.

-mbitfield
Do use the bit-field instructions. ‘-m68020’ implies ‘-mbit-
field’. This is the default if you use the unmodified
sources.

-mrtd
Use a different function-calling convention, in which func-
tions that take a fixed number of arguments return with the
rtd instruction, which pops their arguments while returning.
This saves one instruction in the caller since there is no
need to pop the arguments there.

This calling convention is incompatible with the one normally
used on Unix, so you cannot use it if you need to call li-
braries compiled with the Unix compiler.

Also, you must provide function prototypes for all functions
that take variable numbers of arguments (including printf);
otherwise incorrect code will be generated for calls to those
functions.

In addition, seriously incorrect code will result if you call
a function with too many arguments. (Normally, extra argu-
ments are harmlessly ignored.)

The rtd instruction is supported by the 68010 and 68020 pro-
cessors, but not by the 68000.

These options are defined for the IBM RS6000:

-mfp-in-toc

-mno-fp-in-toc
Control whether or not floating-point constants go in the
Table of Contents (TOC), a table of all global variable and
function addresses. By default GCC puts floating-point con-
stants there; if the TOC overflows, ‘-mno-fp-in-toc’ will
reduce the size of the TOC, which may avoid the overflow.

CODE GENERATION OPTIONS
These machine-independent options control the interface conventions
used in code generation.

Most of them begin with ‘-f’. These options have both positive and
negative forms; the negative form of ‘-ffoo’ would be ‘-fno-foo’.
In the table below, only one of the forms is listed-the one which
is not the default. You can figure out the other form by either
removing ‘no-’ or adding it.

+eN (C++ only.) control whether virtual function definitions in
classes are used to generate code, or only to define inter-
faces for their callers. These options are provided for com-
patibility with cfront 1.x usage; the recommended GNU C++
usage is to use #pragma interface and #pragma implementation,
instead.

With ‘+e0’, virtual function definitions in classes are de-
clared extern; the declaration is used only as an interface
specification, not to generate code for the virtual functions
(in this compilation).

With ‘+e1’, g++ actually generates the code implementing vir-
tual functions defined in the code, and makes them publicly
visible.

-fnonnull-objects
(C++ only.) Normally, GNU C++ makes conservative assumptions
about objects reached through references. For example, the
compiler must check that ‘a’ is not null in code like the fol-
lowing:
obj &a = g ();
a.f (2);
Checking that references of this sort have non-null values re-
quires extra code, however, and it is unnecessary for many
programs. You can use ‘-fnonnull-objects’ to omit the checks
for null, if your program doesn’t require the default check-
ing.

-fpcc-struct-return
Use the same convention for returning struct and union values
that is used by the usual C compiler on your system. This
convention is less efficient for small structures, and on many
machines it fails to be reentrant; but it has the advantage of
allowing intercallability between GCC-compiled code and PCC-
compiled code.

-fshort-enums
Allocate to an enum type only as many bytes as it needs for
the declared range of possible values. Specifically, the enum
type will be equivalent to the smallest integer type which has
enough room.

-fshort-double
Use the same size for double as for float .

-fshared-data
Requests that the data and non-const variables of this compi-
lation be shared data rather than private data. The distinc-
tion makes sense only on certain operating systems, where
shared data is shared between processes running the same pro-
gram, while private data exists in one copy per process.

-fno-common
Allocate even uninitialized global variables in the bss sec-
tion of the object file, rather than generating them as common
blocks. This has the effect that if the same variable is de-
clared (without extern) in two different compilations, you
will get an error when you link them. The only reason this
might be useful is if you wish to verify that the program will
work on other systems which always work this way.

-fvolatile
Consider all memory references through pointers to be vola-
tile.

-fpic
If supported for the target machines, generate position-
independent code, suitable for use in a shared library.

-fPIC
If supported for the target machine, emit position-independent
code, suitable for dynamic linking, even if branches need
large displacements.

-ffixed-reg
Treat the register named reg as a fixed register; generated
code should never refer to it (except perhaps as a stack
pointer, frame pointer or in some other fixed role).

reg must be the name of a register. The register names ac-
cepted are machine-specific and are defined in the
REGISTER_NAMES macro in the machine description macro file.

This flag does not have a negative form, because it specifies
a three-way choice.

-fcall-used-reg
Treat the register named reg as an allocatable register that
is clobbered by function calls. It may be allocated for tem-
poraries or variables that do not live across a call. Func-
tions compiled this way will not save and restore the register
reg.

Use of this flag for a register that has a fixed pervasive
role in the machine’s execution model, such as the stack
pointer or frame pointer, will produce disastrous results.

This flag does not have a negative form, because it specifies
a three-way choice.

-fcall-saved-reg
Treat the register named reg as an allocatable register saved
by functions. It may be allocated even for temporaries or
variables that live across a call. Functions compiled this
way will save and restore the register reg if they use it.

Use of this flag for a register that has a fixed pervasive
role in the machine’s execution model, such as the stack
pointer or frame pointer, will produce disastrous results.

A different sort of disaster will result from the use of this
flag for a register in which function values may be returned.

This flag does not have a negative form, because it specifies
a three-way choice.

-fgnu-binutils

-fno-gnu-binutils
(C++ only.) ‘-fgnu-binutils ’ (the default for most, but not
all, platforms) makes GNU C++ emit extra information for stat-
ic initialization and finalization. This information has to
be passed from the assembler to the GNU linker. Some assem-
blers won’t pass this information; you must either use GNU as
or specify the option ‘-fno-gnu-binutils’.

With ‘-fno-gnu-binutils’, you must use the program collect
(part of the GCC distribution) for linking.

PRAGMAS
Two ‘#pragma’ directives are supported for GNU C++, to permit using
the same header file for two purposes: as a definition of inter-
faces to a given object class, and as the full definition of the
contents of that object class.

#pragma interface
(C++ only.) Use this directive in header files that define ob-
ject classes, to save space in most of the object files that
use those classes. Normally, local copies of certain informa-
tion (backup copies of inline member functions, debugging in-
formation, and the internal tables that implement virtual
functions) must be kept in each object file that includes
class definitions. You can use this pragma to avoid such du-
plication. When a header file containing ‘#pragma interface’
is included in a compilation, this auxiliary information will
not be generated (unless the main input source file itself
uses ‘#pragma implementation’). Instead, the object files
will contain references to be resolved at link time.

#pragma implementation

#pragma implementation "objects.h"
(C++ only.) Use this pragma in a main input file, when you
want full output from included header files to be generated
(and made globally visible). The included header file, in
turn, should use ‘#pragma interface’. Backup copies of inline
member functions, debugging information, and the internal
tables used to implement virtual functions are all generated
in implementation files.

If you use ‘#pragma implementation’ with no argument, it ap-
plies to an include file with the same basename as your source
file; for example, in ‘allclass.cc’, ‘#pragma implementation’
by itself is equivalent to ‘#pragma implementation
"allclass.h"’. Use the string argument if you want a single
implementation file to include code from multiple header
files.

There is no way to split up the contents of a single header
file into multiple implementation files.

FILES
file.c C source file
file.h C header (preprocessor) file
file.i preprocessed C source file
file.C C++ source file
file.cc C++ source file
file.cxx C++ source file
file.m Objective-C source file
file.s assembly language file
file.o object file
a.out link edited output
TMPDIR/cc* temporary files
LIBDIR/cpp preprocessor
LIBDIR/cc1 compiler for C
LIBDIR/cc1plus compiler for C++
LIBDIR/collect linker front end needed on some machines
LIBDIR/libgcc.a GCC subroutine library
/lib/crt[01n].o start-up routine
LIBDIR/ccrt0 additional start-up routine for C++
/lib/libc.a standard C library, see intro(3)
/usr/include standard directory for #include files
LIBDIR/include standard gcc directory for #include files
LIBDIR/g++-include additional g++ directory for #include

LIBDIR is usually /usr/local/lib/machine/version.
TMPDIR comes from the environment variable TMPDIR (default /usr/tmp
if available, else /tmp).

SEE ALSO
cpp(1), as(1), ld(1), gdb(1).
‘gcc’, ‘cpp’, ‘as’,‘ld’, and ‘gdb’ entries in info.
Using and Porting GNU CC (for version 2.3), Richard M. Stallman,
December 1992; Using and Porting GNU CC (for version 1.40), Richard
M. Stallman, June 1991; The C Preprocessor (for version 2.0),
Richard M. Stallman, July 1992; The C Preprocessor (for version
1.38), Richard M. Stallman, July 1990; Debugging with GDB: The GNU
Source-Level Debugger, Richard M. Stallman and Roland H. Pesch,
April 1993; Using as: the GNU Assembler, Dean Elsner, Jay Fenlason
& friends, January 1992.

BUGS
Report bugs to tentech@tenon.com; bug-gcc@prep.ai.mit.edu is the
advertised GNU mailbox. Bugs tend actually to be fixed if they can
be isolated, so it is in your interest to report them in such a way
that they can be easily reproduced.

COPYING
Copyright (c) 1991 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission no-
tice are preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided
that the entire resulting derived work is distributed under the
terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modi-
fied versions, except that this permission notice may be included
in translations approved by the Free Software Foundation instead of
in the original English.

AUTHORS
See the GNU CC Manual for the contributors to GNU CC.