.\" Copyright (c) 1991 Free Software Foundation -*-Text-*-
.\" See section COPYING for conditions for redistribution
.\" FIXME: no info here on predefines. Should there be? extra for C++...
.TH G++ 1 "27dec1991" "GNU Tools" "GNU Tools"
g++ \- GNU project C++ Compiler (v2 preliminary)
.IR option " | " filename " ].\|.\|.
The C and C++ compilers are integrated;
.B gcc with options to recognize C++.
through one or more of four stages: preprocessing, compilation,
assembly, and linking. This man page contains full descriptions for
C++ specific aspects of the compiler, though it also contains
summaries of some general-purpose options. For a fuller explanation
C++ source files use one of the suffixes `\|\c
\&\|'; preprocessed C++ files use the suffix `\|\c
There are many command-line options, including options to control
details of optimization, warnings, and code generation, which are
\&. For full information on all options, see
Options must be separate: `\|\c
\&\|' is quite different from `\|\c
\&\|' options have two contrary forms:
\&). Only the non-default forms are shown here.
Compile or assemble the source files, but do not link. The compiler
output is an object file corresponding to each source file.
Stop after the preprocessing stage; do not run the compiler proper. The
output is preprocessed source code, which is sent to the
control whether virtual function definitions in classes
are used to generate code, or only to define interfaces for their
callers. These options are provided for compatibility with cfront
1.x usage; the recommended GNU C++ usage is to use
\&\|', virtual function definitions in classes are declared extern;
the declaration is used only as an interface specification, not to
generate code for the virtual functions (in this compilation).
actually generates the code implementing virtual functions
defined in the code, and makes them publicly visible.
\&\|', all member functions
(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.''
\& 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
\&\|' implicitly virtual using `\|\c
also to all non-constructor methods of any class derived from such a
.B \-fdollars\-in\-identifiers
Traditional C allowed the character `\|\c
\&\|' to form part of identifiers; by default, GNU C also
allows this. However, ANSI C forbids `\|\c
\&\|' in identifiers, and GNU C++ also forbids it by default on most
platforms (though on some platforms it's enabled by default for GNU
.B \-felide\-constructors
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\ 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 `\|\c
without going through a temporary.
Normally GNU C++ allows conversion of
\&, but not the other way around. Use this option if you want GNU C++
\&\|' (the default for most, but not all, platforms) makes GNU C++
emit extra information for static initialization and finalization.
This information has to be passed from the assembler to the GNU
linker. Some assemblers won't pass this information; you must either
or specify the option `\|\c
.B \-fno\-gnu\-binutils\c
.B \-fno\-gnu\-binutils\c
\&\|', you must use the program
(part of the GCC distribution) for linking.
These flags are used to get the compiler to compile programs faster
using heuristics. They are not on by default 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) determine whether the class
implements member functions of that name; (2) resolve which member
function to call (which involves 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.
Normally, 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.\en";
makes six passes through all three steps. By using a software cache,
a ``hit'' significantly reduces this cost. Unfortunately, using the
cache introduces another layer of mechanisms which must be implemented,
and so incurs its own overhead. `\|\c
Because access privileges (visibility) to members and member functions
may differ from one function context to the next,
may need to flush the cache. With the `\|\c
\&\|' flag, the cache is flushed after every
function that is compiled. The `\|\c
\&\|' 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
This is most helpful when defining many member functions for the same
class: with the exception of member functions 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.
.B \-fno\-default\-inline
\&\|' is enabled then member functions defined inside class
scope are compiled inline by default; i.e., you don't need to
\&\|' in front of the member function name. By popular
demand, this option is now the default. To keep GNU C++ from inlining
these member functions, specify `\|\c
.B \-fno\-default\-inline\c
.B \-fno\-strict\-prototype
Consider the declaration \c
\&. In C++, this means that the
\& takes no arguments. In ANSI C, this is declared
.B \-fno\-strict\-prototype\c
declaring functions with no arguments is equivalent to declaring its
argument list to be untyped, i.e., \c
Normally, GNU C++ makes conservative assumptions about objects reached
through references. For example, the compiler must check that `\|\c
\&\|' is not null in code like the following:
\ \ \ \ obj\ &a\ =\ g\ ();
Checking that references of this sort have non-null values requires
extra code, however, and it is unnecessary for many programs. You can
\&\|' to omit the checks for null, if your program doesn't require the
The incorporation of user-defined free store management into C++ has
\& an anachronism. Therefore, by default GNU
C++ treats the type of \c
\& in a member function of \c
\&. In other words, it is illegal to assign to
\& within a class member function. However, for backwards
compatibility, you can invoke the old behavior by using
.B \-fthis\-is\-variable\c
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, `\|\c
of extra debugging information that only GDB can use.
Unlike most other C compilers, GNU CC allows you to use `\|\c
\&\|'. The shortcuts taken by optimized code may occasionally
produce surprising results: some variables you declared may not exist
at all; flow of control may briefly move where you did not expect it;
some statements may not be executed 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.
\& to the list of directories searched for include files.
\& to the list of directories to be searched
\& when linking. (C++ programs often require `\|\c
\&\|' for successful linking.)
Optimize. Optimizing compilation takes somewhat more time, and a lot
more memory for a large function.
\&\|', 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.
\&\|', only variables declared \c
allocated in registers. The resulting compiled code is a little worse
than produced by PCC without `\|\c
\&\|', the compiler tries to reduce code size and execution
Stop after the stage of compilation proper; do not assemble. The output
is an assembler code file for each non-assembler input
On systems that support dynamic linking, this prevents linking with the shared
libraries. On other systems, this option has no effect.
Attempt to support some aspects of traditional C compilers.
Specifically, for both C and C++ programs:
In the preprocessor, comments convert to nothing at all, rather than
to a space. This allows traditional token concatenation.
In the preprocessor, macro arguments are recognized within string
constants in a macro definition (and their values are stringified,
though without additional quote marks, when they appear in such a
context). The preprocessor always considers a string constant to end
The preprocessor does not predefine the macro \c
\&\|', but still predefines\c
\& (since the GNU extensions indicated by
\&\|'). If you need to write header files that work
differently depending on whether `\|\c
testing both of these predefined macros you can distinguish four
situations: GNU C, traditional GNU C, other ANSI C compilers, and
In the preprocessor, comments convert to nothing at all, rather than
to a space. This allows traditional token concatenation.
In the preprocessor, macro arguments are recognized within string
constants in a macro definition (and their values are stringified,
though without additional quote marks, when they appear in such a
context). The preprocessor always considers a string constant to end
The preprocessor does not predefine the macro \c
\&\|', but still predefines\c
\& (since the GNU extensions indicated by
\&\|'). If you need to write header files that work
differently depending on whether `\|\c
testing both of these predefined macros you can distinguish four
situations: GNU C, traditional GNU C, other ANSI C compilers, and
String ``constants'' are not necessarily constant; they are stored in
writable space, and identical looking constants are allocated
separately. (This is the same as the effect of
.B \-fwritable\-strings\c
For C++ programs only (not C), `\|\c
\&\|' has one additional effect: assignment to
is permitted. This is the same as the effect of `\|\c
.B \-fthis\-is\-variable\c
Issue warnings for conditions which pertain to usage that we recommend
avoiding and that we believe is easy to avoid, even in conjunction
Warn when converting between different enumeration types.
.B \-Woverloaded\-virtual
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 warnings 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.
Inhibit all warning messages.
\&\|' directives are supported for GNU C++, to permit using the same
header file for two purposes: as a definition of interfaces to a given
object class, and as the full definition of the contents of that object class.
Use this directive in header files that define object classes, to save
space in most of the object files that use those classes. Normally,
local copies of certain information (backup copies of inline member
functions, debugging information, 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
duplication. When a header file containing `\|\c
\&\|' is included in a compilation, this auxiliary information
will not be generated (unless the main input source file itself uses
.B #pragma implementation\c
\&\|'). Instead, the object files will contain references to be
.B #pragma implementation
.BI "#pragma implementation !" objects .h!
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 `\|\c
Backup copies of inline member functions, debugging information, and
the internal tables used to implement virtual functions are all
generated in implementation files.
.B #pragma implementation\c
\&\|' with no argument, it applies to an include file with the same
basename as your source file; for example, in `\|\c
.B #pragma implementation\c
\&\|' by itself is equivalent to `\|\c
#pragma implementation "allclass.h"\c
\&\|'. 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.
.ta \w'LIBDIR/g++\-include 'u
file.h C header (preprocessor) file
file.i preprocessed C source file
file.s assembly language file
\fITMPDIR\fR/cc\(** temporary files
\fILIBDIR\fR/cpp preprocessor
\fILIBDIR\fR/cc1plus compiler
\fILIBDIR\fR/collect linker front end needed on some machines
\fILIBDIR\fR/libgcc.a GCC subroutine library
/lib/crt[01n].o start-up routine
\fILIBDIR\fR/ccrt0 additional start-up routine for C++
/lib/libc.a standard C library, see
/usr/include standard directory for
\fILIBDIR\fR/include standard gcc directory for
\fILIBDIR\fR/g++\-include additional g++ directory for
comes from the environment variable
gcc(1), cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1).
.RB "`\|" gcc "\|', `\|" cpp \|',
.RB `\| as \|', `\| ld \|',
Using and Porting GNU CC (for version 2.0)\c
, Richard M. Stallman, November 1990;
, Richard M. Stallman, July 1990;
Using GDB: A Guide to the GNU Source-Level Debugger\c
, Richard M. Stallman and Roland H. Pesch, December 1991;
Using as: the GNU Assembler\c
, Dean Elsner, Jay Fenlason & friends, March 1991;
, Steve Chamberlain and Roland Pesch, April 1991.
.BR bug\-g++@prep.ai.mit.edu .
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.
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 notice
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 modified
versions, except that this permission notice may be included in
translations approved by the Free Software Foundation instead of in
See the GNU CC Manual for the contributors to GNU CC.
projects / unix-history / blob