gcc.1

早期freebsd实现

.B const char[\c
.I length\c
\&]\c
\& so that
copying the address of one into a non-\c
.B const\c
\& \c
.B char *\c
\&
pointer will get a warning.  These warnings will help you find at
compile time code that can try to write into a string constant, but
only if you have been very careful about using \c
.B const\c
\& in
declarations and prototypes.  Otherwise, it will just be a nuisance;
this is why we did not make `\|\c
.B \-Wall\c
\&\|' request these warnings.
.TP
.B \-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.
.TP
.B \-Waggregate\-return
Warn if any functions that return structures or unions are defined or
called.  (In languages where you can return an array, this also elicits
a warning.)
.TP
.B \-Wstrict\-prototypes
Warn if a function is declared or defined without specifying the
argument types.  (An old-style function definition is permitted without
a warning if preceded by a declaration which specifies the argument
types.)
.TP
.B \-Wmissing\-prototypes
Warn if a global function is defined without a previous prototype
declaration.  This warning is issued even if the definition itself
provides a prototype.  The aim is to detect global functions that fail
to be declared in header files.
.TP
.B \-Wenum\-clash
.I (C++ only.)
Warn when converting between different enumeration types.
.TP
.B \-Woverloaded\-virtual
.I (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 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.
.TP
.B \-Winline
Warn if a function can not be inlined, and either it was declared as inline,
or else the
.B \-finline\-functions
option was given.
.TP
.B \-Werror
Treat warnings as errors; abort compilation after any warning.
.PP

.SH DEBUGGING OPTIONS
GNU CC has various special options that are used for debugging
either your program or GCC:
.TP
.B \-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, `\|\c
.B \-g\c
\&\|' enables use
of extra debugging information that only GDB can use; if you want to
control for certain whether to generate this information, use
`\|\c
.B \-ggdb\c
\&\|' or `\|\c
.B \-gdbx\c
\&\|'.

Unlike most other C compilers, GNU CC allows you to use `\|\c
.B \-g\c
\&\|' with
`\|\c
.B \-O\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.

The following options are useful when GNU CC is configured and
compiled with the capability for more than one debugging format. 
.TP
.B \-ggdb
Produce debugging information in DBX format (if that is supported),
including GDB extensions.
.TP
.B \-gdbx
Produce debugging information in DBX format (if that is supported),
without GDB extensions.
.TP
.B \-gsdb
Produce debugging information in SDB format (if that is supported).
.TP
.B \-gdwarf
Produce debugging information in DWARF format (if that is supported).
.PP
.BI "\-g" "level"
.br
.BI "\-ggdb" "level"
.br
.BI "\-gdbx" "level"
.br
.BI "\-gsdb" "level"
.TP
.BI "\-gdwarf" "level"
Request debugging information and also use \c
.I level\c
\& to specify how
much information.  The default level is 2.

Level 1 produces minimal information, enough for making backtraces in
parts of the program that you don't plan to debug.  This includes
descriptions of functions and external variables, but no information
about local variables and no line numbers.
.TP
.B \-p
Generate extra code to write profile information suitable for the
analysis program \c
.B prof\c
\&.
.TP
.B \-pg
Generate extra code to write profile information suitable for the
analysis program \c
.B gprof\c
\&.
.TP
.B \-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 \c
.B tcov\c
\&.  Note,
however, that the format of the data is not what \c
.B tcov\c
\& expects.
Eventually GNU \c
.B gprof\c
\& should be extended to process this data.
.TP
.BI "\-d" "letters"\c
\&
Says to make debugging dumps during compilation at times specified by
\c
.I letters\c
\&.  This is used for debugging the compiler.  The file names
for most of the dumps are made by appending a word to the source file
name (e.g.,  `\|\c
.B foo.c.rtl\c
\&\|' or `\|\c
.B foo.c.jump\c
\&\|').
.TP
.B \-dM
Dump all macro definitions, at the end of preprocessing, and write no
output.
.TP
.B \-dN
Dump all macro names, at the end of preprocessing.
.TP
.B \-dD
Dump all macro definitions, at the end of preprocessing, in addition to
normal output.
.TP
.B \-dy
Dump debugging information during parsing, to the standard error.
.TP
.B \-dr
Dump after RTL generation, to `\|\c
.B \c
.I file\c
\&.rtl\c
\&\|'.
.TP
.B \-dx
Just generate RTL for a function instead of compiling it.  Usually used
with `\|\c
.B r\c
\&\|'.
.TP
.B \-dj
Dump after first jump optimization, to `\|\c
.B \c
.I file\c
\&.jump\c
\&\|'.
.TP
.B \-ds
Dump after CSE (including the jump optimization that sometimes
follows CSE), to `\|\c
.B \c
.I file\c
\&.cse\c
\&\|'.
.TP
.B \-dL
Dump after loop optimization, to `\|\c
.B \c
.I file\c
\&.loop\c
\&\|'.
.TP
.B \-dt
Dump after the second CSE pass (including the jump optimization that
sometimes follows CSE), to `\|\c
.B \c
.I file\c
\&.cse2\c
\&\|'.
.TP
.B \-df
Dump after flow analysis, to `\|\c
.B \c
.I file\c
\&.flow\c
\&\|'.
.TP
.B \-dc
Dump after instruction combination, to `\|\c
.B \c
.I file\c
\&.combine\c
\&\|'.
.TP
.B \-dS
Dump after the first instruction scheduling pass, to
`\|\c
.B \c
.I file\c
\&.sched\c
\&\|'.
.TP
.B \-dl
Dump after local register allocation, to `\|\c
.B \c
.I file\c
\&.lreg\c
\&\|'.
.TP
.B \-dg
Dump after global register allocation, to `\|\c
.B \c
.I file\c
\&.greg\c
\&\|'.
.TP
.B \-dR
Dump after the second instruction scheduling pass, to
`\|\c
.B \c
.I file\c
\&.sched2\c
\&\|'.
.TP
.B \-dJ
Dump after last jump optimization, to `\|\c
.B \c
.I file\c
\&.jump2\c
\&\|'.
.TP
.B \-dd
Dump after delayed branch scheduling, to `\|\c
.B \c
.I file\c
\&.dbr\c
\&\|'.
.TP
.B \-dk
Dump after conversion from registers to stack, to `\|\c
.B \c
.I file\c
\&.stack\c
\&\|'.
.TP
.B \-dm
Print statistics on memory usage, at the end of the run, to
the standard error.
.TP
.B \-dp
Annotate the assembler output with a comment indicating which
pattern and alternative was used.
.TP
.B \-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.
.TP
.B \-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 `\|\c
.B foo.c\c
\&\|' with `\|\c
.B \-c \-save\-temps\c
\&\|' would produce files
`\|\c
.B foo.cpp\c
\&\|' and `\|\c
.B foo.s\c
\&\|', as well as `\|\c
.B foo.o\c
\&\|'.
.PP

.SH OPTIMIZATION OPTIONS
These options control various sorts of optimizations:
.TP
.B \-O
Optimize.  Optimizing compilation takes somewhat more time, and a lot
more memory for a large function.

Without `\|\c
.B \-O\c
\&\|', 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 `\|\c
.B \-O\c
\&\|', only variables declared \c
.B register\c
\& are
allocated in registers.  The resulting compiled code is a little worse
than produced by PCC without `\|\c
.B \-O\c
\&\|'.

With `\|\c
.B \-O\c
\&\|', the compiler tries to reduce code size and execution
time.

When you specify `\|\c
.B \-O\c
\&\|', `\|\c
.B \-fthread\-jumps\c
\&\|' and
`\|\c
.B \-fdelayed\-branch\c
\&\|' are turned on.  On some machines other
flags may also be turned on.
.TP
.B \-O2
Highly optimize.  As compared to `\|\c
.B \-O\c
\&\|', this
option will increase both compilation time and the performance of the
generated code.

All `\|\c
.B \-f\c
.I flag\c
\&\c
\&\|' options that control optimization are turned on
when you specify `\|\c
.B \-O2\c
\&\|', except `\|\c
.B \-funroll\-loops\c
\&\|'
and `\|\c
.B \-funroll\-all\-loops\c
\&\|'.  
.PP

Options of the form `\|\c
.B \-f\c
.I flag\c
\&\c
\&\|' specify machine-independent
flags.  Most flags have both positive and negative forms; the negative
form of `\|\c
.B \-ffoo\c
\&\|' would be `\|\c
.B \-fno\-foo\c
\&\|'.  The following list shows
only one form\(em\&the one which is not the default.
You can figure out the other form by either removing `\|\c
.B no\-\c
\&\|' or
adding it.
.TP
.B \-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 \c
.B double\c
\& 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 `\|\c
.B \-ffloat\-store\c
\&\|' for such programs.
.TP
.B \-fmemoize\-lookups
.TP
.B \-fsave\-memoized
.I
(C++ only.)
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
.sp
.br
\ \ cout\ <<\ "This\ "\ <<\ p\ <<\ "\ has\ "\ <<\ n\ <<\ "\ legs.\en";
.br
.sp
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
.B \-fmemoize\-lookups\c
\&\|' enables
the software cache.

Because access privileges (visibility) to members and member functions
may differ from one function context to the next, 
.B g++
may need to flush the cache. With the `\|\c
.B \-fmemoize\-lookups\c
\&\|' flag, the cache is flushed after every
function that is compiled.  The `\|\c
\-fsave\-memoized\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
preserves the cache. 
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.
.TP
.B \-fno\-default\-inline
.I
(C++ only.)
If `\|\c
.B \-fdefault\-inline\c
\&\|' is enabled then member functions defined inside class
scope are compiled inline by default; i.e., you don't need to
add `\|\c
.B inline\c
\&\|' 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
\&\|'.
.TP
.B \-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 accumulate on the
stack for several function calls and pops them all at once.
.TP
.B \-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.
.TP
.B \-fforce\-addr
Force memory address constants to be copied into registers before
doing arithmetic on them.  This may produce better code just as
`\|\c
.B \-fforce\-mem\c
\&\|' may.  I am interested in hearing about the
difference this makes.
.TP
.B \-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.  \c
.I It also makes debugging impossible on
most machines.\c
\&

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 \c
.B FRAME_POINTER_REQUIRED\c
\& controls
whether a target machine supports this flag.  
.TP
.B \-finline
Pay attention the \c
.B inline\c
\& keyword.  Normally the negation of this
option `\|\c
.B \-fno\-inline\c
\&\|' is used to keep the compiler from expanding
any functions inline.  However, the opposite effect may be desirable
when compiling with `\|\c
.B \-g\c
\&\|', since `\|\c
.B \-g\c
\&\|' normally turns off all
inline function expansion.
.TP
.B \-finline\-functions
Integrate all simple functions into their callers.  The compiler
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 function is
declared \c
.B static\c
\&, then GCC normally does not output the function as
assembler code in its own right.
.TP
.B \-fcaller\-saves
Enable values to be allocated in registers that will be clobbered by