4276 lines
108 KiB
Plaintext
4276 lines
108 KiB
Plaintext
.\" $FreeBSD$
|
|
.\" Copyright (c) 1991, 1992, 1993, 1994 Free Software Foundation -*-Text-*-
|
|
.\" See section COPYING for conditions for redistribution
|
|
.\"
|
|
.\" Set up \*(lq, \*(rq if -man hasn't already set it up.
|
|
.if @@\*(lq@ \{\
|
|
. ds lq "
|
|
. if t .ds lq ``
|
|
. if !@@\(lq@ .ds lq "\(lq
|
|
.\}
|
|
.if @@\*(rq@ \{\
|
|
. ds rq "
|
|
. if t .ds rq ''
|
|
. if !@@\(rq@ .ds rq "\(rq
|
|
.\}
|
|
.de Id
|
|
.ds Rv \\$3
|
|
.ds Dt \\$4
|
|
..
|
|
.de Sp
|
|
.if n .sp
|
|
.if t .sp 0.4
|
|
..
|
|
.Id $Id: gcc.1,v 1.9 1998/12/16 20:55:57 law Exp $
|
|
.TH GCC 1 "\*(Dt" "GNU Tools" "GNU Tools"
|
|
.SH NAME
|
|
gcc, g++ \- GNU project C and C++ Compiler (gcc-3.2.1)
|
|
.SH SYNOPSIS
|
|
.B gcc
|
|
.RI "[ " option " | " filename " ].\|.\|."
|
|
.br
|
|
.B g++
|
|
.RI "[ " option " | " filename " ].\|.\|."
|
|
.SH WARNING
|
|
The information in this man page is an extract from the full
|
|
documentation of the GNU C compiler, and is limited to the meaning of
|
|
the options.
|
|
.PP
|
|
This man page is not kept up to date except when volunteers want to
|
|
maintain it. If you find a discrepancy between the man page and the
|
|
software, please check the Info file, which is the authoritative
|
|
documentation.
|
|
.PP
|
|
If we find that the things in this man page that are out of date cause
|
|
significant confusion or complaints, we will stop distributing the man
|
|
page. The alternative, updating the man page when we update the Info
|
|
file, is impossible because the rest of the work of maintaining GNU CC
|
|
leaves us no time for that. The GNU project regards man pages as
|
|
obsolete and should not let them take time away from other things.
|
|
.PP
|
|
For complete and current documentation, refer to the Info file `\|\c
|
|
.B gcc\c
|
|
\&\|' or the manual
|
|
.I
|
|
Using and Porting GNU CC (for version 2.0)\c
|
|
\&. Both are made from the Texinfo source file
|
|
.BR gcc.texinfo .
|
|
.SH 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:
|
|
.TP
|
|
.B gcc
|
|
assumes preprocessed (\c
|
|
.B .i\c
|
|
\&) files are C and assumes C style linking.
|
|
.TP
|
|
.B g++
|
|
assumes preprocessed (\c
|
|
.B .i\c
|
|
\&) files are C++ and assumes C++ style linking.
|
|
.PP
|
|
Suffixes of source file names indicate the language and kind of
|
|
processing to be done:
|
|
.Sp
|
|
.nf
|
|
.ta \w'\fB.cxx\fP 'u
|
|
\&\fB.c\fP C source; preprocess, compile, assemble
|
|
\&\fB.C\fP C++ source; preprocess, compile, assemble
|
|
\&\fB.cc\fP C++ source; preprocess, compile, assemble
|
|
\&\fB.cxx\fP C++ source; preprocess, compile, assemble
|
|
\&\fB.m\fP Objective-C source; preprocess, compile, assemble
|
|
\&\fB.i\fP preprocessed C; compile, assemble
|
|
\&\fB.ii\fP preprocessed C++; compile, assemble
|
|
\&\fB.s\fP Assembler source; assemble
|
|
\&\fB.S\fP Assembler source; preprocess, assemble
|
|
\&\fB.h\fP Preprocessor file; not usually named on command line
|
|
.Sp
|
|
.fi
|
|
Files with other suffixes are passed to the linker. Common cases include:
|
|
.Sp
|
|
.nf
|
|
\&\fB.o\fP Object file
|
|
\&\fB.a\fP Archive file
|
|
.br
|
|
.fi
|
|
.Sp
|
|
Linking is always the last stage unless you use one of the
|
|
.BR \-c ,
|
|
.BR \-S ,
|
|
or
|
|
.B \-E
|
|
options to avoid it (or unless compilation errors stop the whole
|
|
process). For the link stage, all
|
|
.B .o
|
|
files corresponding to source files,
|
|
.B \-l
|
|
libraries, unrecognized filenames (including named
|
|
.B .o
|
|
object files and
|
|
.B .a
|
|
archives)
|
|
are passed to the linker in command-line order.
|
|
.SH OPTIONS
|
|
Options must be separate: `\|\c
|
|
.B \-dr\c
|
|
\&\|' is quite different from `\|\c
|
|
.B \-d \-r
|
|
\&\|'.
|
|
.PP
|
|
Most `\|\c
|
|
.B \-f\c
|
|
\&\|' and `\|\c
|
|
.B \-W\c
|
|
\&\|' options have two contrary forms:
|
|
.BI \-f name
|
|
and
|
|
.BI \-fno\- name\c
|
|
\& (or
|
|
.BI \-W name
|
|
and
|
|
.BI \-Wno\- name\c
|
|
\&). Only the non-default forms are shown here.
|
|
.PP
|
|
Here is a summary of all the options, grouped by type. Explanations are
|
|
in the following sections.
|
|
.hy 0
|
|
.na
|
|
.TP
|
|
.B Overall Options
|
|
.br
|
|
\-c
|
|
\-S
|
|
\-E
|
|
.RI "\-o " file
|
|
\-pipe
|
|
\-v
|
|
.RI "\-x " language
|
|
.TP
|
|
.B Language Options
|
|
\-ansi
|
|
\-fall\-virtual
|
|
\-fcond\-mismatch
|
|
\-fdollars\-in\-identifiers
|
|
\-fenum\-int\-equiv
|
|
\-fexternal\-templates
|
|
\-fno\-asm
|
|
\-fno\-builtin
|
|
\-fhosted
|
|
\-fno\-hosted
|
|
\-ffreestanding
|
|
\-fno\-freestanding
|
|
\-fno\-strict\-prototype
|
|
\-fsigned\-bitfields
|
|
\-fsigned\-char
|
|
\-fthis\-is\-variable
|
|
\-funsigned\-bitfields
|
|
\-funsigned\-char
|
|
\-fwritable\-strings
|
|
\-traditional
|
|
\-traditional\-cpp
|
|
\-trigraphs
|
|
.TP
|
|
.B Warning Options
|
|
\-fsyntax\-only
|
|
\-pedantic
|
|
\-pedantic\-errors
|
|
\-w
|
|
\-W
|
|
\-Wall
|
|
\-Waggregate\-return
|
|
\-Wcast\-align
|
|
\-Wcast\-qual
|
|
\-Wchar\-subscript
|
|
\-Wcomment
|
|
\-Wconversion
|
|
\-Wenum\-clash
|
|
\-Werror
|
|
\-Wformat
|
|
.RI \-Wid\-clash\- len
|
|
\-Wimplicit
|
|
\-Wimplicit\-int
|
|
\-Wimplicit\-function\-declaration
|
|
\-Winline
|
|
\-Wlong\-long
|
|
\-Wmain
|
|
\-Wmissing\-prototypes
|
|
\-Wmissing\-declarations
|
|
\-Wnested\-externs
|
|
\-Wno\-import
|
|
\-Wparentheses
|
|
\-Wpointer\-arith
|
|
\-Wredundant\-decls
|
|
\-Wreturn\-type
|
|
\-Wshadow
|
|
\-Wstrict\-prototypes
|
|
\-Wswitch
|
|
\-Wtemplate\-debugging
|
|
\-Wtraditional
|
|
\-Wtrigraphs
|
|
\-Wuninitialized
|
|
\-Wunused
|
|
\-Wwrite\-strings
|
|
.TP
|
|
.B Debugging Options
|
|
\-a
|
|
.RI \-d letters
|
|
\-fpretend\-float
|
|
\-g
|
|
.RI \-g level
|
|
\-gcoff
|
|
\-gxcoff
|
|
\-gxcoff+
|
|
\-gdwarf
|
|
\-gdwarf+
|
|
\-gstabs
|
|
\-gstabs+
|
|
\-ggdb
|
|
\-p
|
|
\-pg
|
|
\-save\-temps
|
|
.RI \-print\-file\-name= library
|
|
\-print\-libgcc\-file\-name
|
|
.RI \-print\-prog\-name= program
|
|
.TP
|
|
.B Optimization Options
|
|
\-fcaller\-saves
|
|
\-fcse\-follow\-jumps
|
|
\-fcse\-skip\-blocks
|
|
\-fdelayed\-branch
|
|
\-felide\-constructors
|
|
\-fexpensive\-optimizations
|
|
\-ffast\-math
|
|
\-ffloat\-store
|
|
\-fforce\-addr
|
|
\-fforce\-mem
|
|
\-finline\-functions
|
|
\-fkeep\-inline\-functions
|
|
\-fmemoize\-lookups
|
|
\-fno\-default\-inline
|
|
\-fno\-defer\-pop
|
|
\-fno\-function\-cse
|
|
\-fno\-inline
|
|
\-fno\-peephole
|
|
\-fomit\-frame\-pointer
|
|
\-frerun\-cse\-after\-loop
|
|
\-fschedule\-insns
|
|
\-fschedule\-insns2
|
|
\-fstrength\-reduce
|
|
\-fthread\-jumps
|
|
\-funroll\-all\-loops
|
|
\-funroll\-loops
|
|
\-O
|
|
\-O2
|
|
\-O3
|
|
\-O0
|
|
\-Os
|
|
.TP
|
|
.B Preprocessor Options
|
|
.RI \-A assertion
|
|
\-C
|
|
\-dD
|
|
\-dM
|
|
\-dN
|
|
.RI \-D macro [\|= defn \|]
|
|
\-E
|
|
\-H
|
|
.RI "\-idirafter " dir
|
|
.RI "\-include " file
|
|
.RI "\-imacros " file
|
|
.RI "\-iprefix " file
|
|
.RI "\-iwithprefix " dir
|
|
\-M
|
|
\-MD
|
|
\-MM
|
|
\-MMD
|
|
\-nostdinc
|
|
\-P
|
|
.RI \-U macro
|
|
\-undef
|
|
.TP
|
|
.B Assembler Option
|
|
.RI \-Wa, option
|
|
.TP
|
|
.B Linker Options
|
|
.RI \-l library
|
|
\-nostartfiles
|
|
\-nostdlib
|
|
\-static
|
|
\-shared
|
|
\-symbolic
|
|
.RI "\-Xlinker\ " option
|
|
.RI \-Wl, option
|
|
.RI "\-u " symbol
|
|
.TP
|
|
.B Directory Options
|
|
.RI \-B prefix
|
|
.RI \-I dir
|
|
\-I\-
|
|
.RI \-L dir
|
|
.TP
|
|
.B Target Options
|
|
.RI "\-b " machine
|
|
.RI "\-V " version
|
|
.TP
|
|
.B Configuration Dependent Options
|
|
.I M680x0\ Options
|
|
.br
|
|
\-m68000
|
|
\-m68020
|
|
\-m68020\-40
|
|
\-m68030
|
|
\-m68040
|
|
\-m68881
|
|
\-mbitfield
|
|
\-mc68000
|
|
\-mc68020
|
|
\-mfpa
|
|
\-mnobitfield
|
|
\-mrtd
|
|
\-mshort
|
|
\-msoft\-float
|
|
.Sp
|
|
.I VAX Options
|
|
.br
|
|
\-mg
|
|
\-mgnu
|
|
\-munix
|
|
.Sp
|
|
.I SPARC Options
|
|
.br
|
|
\-mepilogue
|
|
\-mfpu
|
|
\-mhard\-float
|
|
\-mno\-fpu
|
|
\-mno\-epilogue
|
|
\-msoft\-float
|
|
\-msparclite
|
|
\-mv8
|
|
\-msupersparc
|
|
\-mcypress
|
|
.Sp
|
|
.I Convex Options
|
|
.br
|
|
\-margcount
|
|
\-mc1
|
|
\-mc2
|
|
\-mnoargcount
|
|
.Sp
|
|
.I AMD29K Options
|
|
.br
|
|
\-m29000
|
|
\-m29050
|
|
\-mbw
|
|
\-mdw
|
|
\-mkernel\-registers
|
|
\-mlarge
|
|
\-mnbw
|
|
\-mnodw
|
|
\-msmall
|
|
\-mstack\-check
|
|
\-muser\-registers
|
|
.Sp
|
|
.I M88K Options
|
|
.br
|
|
\-m88000
|
|
\-m88100
|
|
\-m88110
|
|
\-mbig\-pic
|
|
\-mcheck\-zero\-division
|
|
\-mhandle\-large\-shift
|
|
\-midentify\-revision
|
|
\-mno\-check\-zero\-division
|
|
\-mno\-ocs\-debug\-info
|
|
\-mno\-ocs\-frame\-position
|
|
\-mno\-optimize\-arg\-area
|
|
\-mno\-serialize\-volatile
|
|
\-mno\-underscores
|
|
\-mocs\-debug\-info
|
|
\-mocs\-frame\-position
|
|
\-moptimize\-arg\-area
|
|
\-mserialize\-volatile
|
|
.RI \-mshort\-data\- num
|
|
\-msvr3
|
|
\-msvr4
|
|
\-mtrap\-large\-shift
|
|
\-muse\-div\-instruction
|
|
\-mversion\-03.00
|
|
\-mwarn\-passed\-structs
|
|
.Sp
|
|
.I RS6000 Options
|
|
.br
|
|
\-mfp\-in\-toc
|
|
\-mno\-fop\-in\-toc
|
|
.Sp
|
|
.I RT Options
|
|
.br
|
|
\-mcall\-lib\-mul
|
|
\-mfp\-arg\-in\-fpregs
|
|
\-mfp\-arg\-in\-gregs
|
|
\-mfull\-fp\-blocks
|
|
\-mhc\-struct\-return
|
|
\-min\-line\-mul
|
|
\-mminimum\-fp\-blocks
|
|
\-mnohc\-struct\-return
|
|
.Sp
|
|
.I MIPS Options
|
|
.br
|
|
\-mcpu=\fIcpu type\fP
|
|
\-mips2
|
|
\-mips3
|
|
\-mint64
|
|
\-mlong64
|
|
\-mlonglong128
|
|
\-mmips\-as
|
|
\-mgas
|
|
\-mrnames
|
|
\-mno\-rnames
|
|
\-mgpopt
|
|
\-mno\-gpopt
|
|
\-mstats
|
|
\-mno\-stats
|
|
\-mmemcpy
|
|
\-mno\-memcpy
|
|
\-mno\-mips\-tfile
|
|
\-mmips\-tfile
|
|
\-msoft\-float
|
|
\-mhard\-float
|
|
\-mabicalls
|
|
\-mno\-abicalls
|
|
\-mhalf\-pic
|
|
\-mno\-half\-pic
|
|
\-G \fInum\fP
|
|
\-nocpp
|
|
.Sp
|
|
.I i386 Options
|
|
.br
|
|
\-m386
|
|
\-m486
|
|
\-mpentium
|
|
\-mpentiumpro
|
|
\-mno\-486
|
|
\-mcpu=\fIcpu type\fP
|
|
\-march=\fIcpu type\fP
|
|
\-msoft\-float
|
|
\-mrtd
|
|
\-mregparm
|
|
\-msvr3\-shlib
|
|
\-mno\-ieee\-fp
|
|
\-mno\-fp\-ret\-in\-387
|
|
\-mfancy\-math\-387
|
|
\-mno\-wide\-multiply
|
|
\-mdebug\-addr
|
|
\-mno\-move
|
|
\-mprofiler\-epilogue
|
|
\-reg\-alloc=LIST
|
|
.Sp
|
|
.I HPPA Options
|
|
.br
|
|
\-mpa\-risc\-1\-0
|
|
\-mpa\-risc\-1\-1
|
|
\-mkernel
|
|
\-mshared\-libs
|
|
\-mno\-shared\-libs
|
|
\-mlong\-calls
|
|
\-mdisable\-fpregs
|
|
\-mdisable\-indexing
|
|
\-mtrailing\-colon
|
|
.Sp
|
|
.I i960 Options
|
|
.br
|
|
\-m\fIcpu-type\fP
|
|
\-mnumerics
|
|
\-msoft\-float
|
|
\-mleaf\-procedures
|
|
\-mno\-leaf\-procedures
|
|
\-mtail\-call
|
|
\-mno\-tail\-call
|
|
\-mcomplex\-addr
|
|
\-mno\-complex\-addr
|
|
\-mcode\-align
|
|
\-mno\-code\-align
|
|
\-mic\-compat
|
|
\-mic2.0\-compat
|
|
\-mic3.0\-compat
|
|
\-masm\-compat
|
|
\-mintel\-asm
|
|
\-mstrict\-align
|
|
\-mno\-strict\-align
|
|
\-mold\-align
|
|
\-mno\-old\-align
|
|
.Sp
|
|
.I DEC Alpha Options
|
|
.br
|
|
\-mfp\-regs
|
|
\-mno\-fp\-regs
|
|
\-mno\-soft\-float
|
|
\-msoft\-float
|
|
.Sp
|
|
.I System V Options
|
|
.br
|
|
\-G
|
|
\-Qy
|
|
\-Qn
|
|
.RI \-YP, paths
|
|
.RI \-Ym, dir
|
|
.TP
|
|
.B Code Generation Options
|
|
.RI \-fcall\-saved\- reg
|
|
.RI \-fcall\-used\- reg
|
|
.RI \-ffixed\- reg
|
|
\-finhibit\-size\-directive
|
|
\-fnonnull\-objects
|
|
\-fno\-common
|
|
\-fno\-ident
|
|
\-fno\-gnu\-linker
|
|
\-fpcc\-struct\-return
|
|
\-fpic
|
|
\-fPIC
|
|
\-freg\-struct\-return
|
|
\-fshared\-data
|
|
\-fshort\-enums
|
|
\-fshort\-double
|
|
\-fvolatile
|
|
\-fvolatile\-global
|
|
\-fverbose\-asm
|
|
.ad b
|
|
.hy 1
|
|
.SH FreeBSD SPECIFIC OPTIONS
|
|
.TP
|
|
.BI "\-pthread"
|
|
Link a user-threaded process against libc_r instead of libc. Objects linked
|
|
into user-threaded processes should be compiled with -D_THREAD_SAFE.
|
|
.TP
|
|
.BI "\-kthread"
|
|
Link a kernel-threaded process against libpthread in addition to libc.
|
|
Objects linked into kernel-threaded processes should be compiled with
|
|
-D_THREAD_SAFE.
|
|
.SH OVERALL OPTIONS
|
|
.TP
|
|
.BI "\-x " "language"
|
|
Specify explicitly the
|
|
.I language\c
|
|
\& 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 `\|\c
|
|
.B \-x\c
|
|
\&\|' option. Possible values of \c
|
|
.I language\c
|
|
\& are
|
|
`\|\c
|
|
.B c\c
|
|
\&\|', `\|\c
|
|
.B objective\-c\c
|
|
\&\|', `\|\c
|
|
.B c\-header\c
|
|
\&\|', `\|\c
|
|
.B c++\c
|
|
\&\|',
|
|
`\|\c
|
|
.B cpp\-output\c
|
|
\&\|', `\|\c
|
|
.B assembler\c
|
|
\&\|', and `\|\c
|
|
.B assembler\-with\-cpp\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-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 `\|\c
|
|
.B \-x\c
|
|
\&\|'
|
|
has not been used at all).
|
|
.PP
|
|
If you want only some of the four stages (preprocess, compile,
|
|
assemble, link), you can use
|
|
`\|\c
|
|
.B \-x\c
|
|
\&\|' (or filename suffixes) to tell \c
|
|
.B gcc\c
|
|
\& where to start, and
|
|
one of the options `\|\c
|
|
.B \-c\c
|
|
\&\|', `\|\c
|
|
.B \-S\c
|
|
\&\|', or `\|\c
|
|
.B \-E\c
|
|
\&\|' to say where
|
|
.B gcc\c
|
|
\& is to stop. Note that some combinations (for example,
|
|
`\|\c
|
|
.B \-x cpp\-output \-E\c
|
|
\&\|') instruct \c
|
|
.B gcc\c
|
|
\& to do nothing at all.
|
|
.TP
|
|
.B \-c
|
|
Compile or assemble the source files, but do not link. The compiler
|
|
output is an object file corresponding to each source file.
|
|
.Sp
|
|
By default, GCC makes the object file name for a source file by replacing
|
|
the suffix `\|\c
|
|
.B .c\c
|
|
\&\|', `\|\c
|
|
.B .i\c
|
|
\&\|', `\|\c
|
|
.B .s\c
|
|
\&\|', etc., with `\|\c
|
|
.B .o\c
|
|
\&\|'. Use
|
|
.B \-o\c
|
|
\& to select another name.
|
|
.Sp
|
|
GCC ignores any unrecognized input files (those that do not require
|
|
compilation or assembly) with the
|
|
.B \-c
|
|
option.
|
|
.TP
|
|
.B \-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.
|
|
.Sp
|
|
By default, GCC makes the assembler file name for a source file by
|
|
replacing the suffix `\|\c
|
|
.B .c\c
|
|
\&\|', `\|\c
|
|
.B .i\c
|
|
\&\|', etc., with `\|\c
|
|
.B .s\c
|
|
\&\|'. Use
|
|
.B \-o\c
|
|
\& to select another name.
|
|
.Sp
|
|
GCC ignores any input files that don't require compilation.
|
|
.TP
|
|
.B \-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.
|
|
.Sp
|
|
GCC ignores input files which don't require preprocessing.
|
|
.TP
|
|
.BI "\-o " file
|
|
Place output in file \c
|
|
.I file\c
|
|
\&. This applies regardless to whatever
|
|
sort of output GCC is producing, whether it be an executable file,
|
|
an object file, an assembler file or preprocessed C code.
|
|
.Sp
|
|
Since only one output file can be specified, it does not make sense to
|
|
use `\|\c
|
|
.B \-o\c
|
|
\&\|' when compiling more than one input file, unless you are
|
|
producing an executable file as output.
|
|
.Sp
|
|
If you do not specify `\|\c
|
|
.B \-o\c
|
|
\&\|', the default is to put an executable file
|
|
in `\|\c
|
|
.B a.out\c
|
|
\&\|', the object file for `\|\c
|
|
.I source\c
|
|
.B \&.\c
|
|
.I suffix\c
|
|
\&\c
|
|
\&\|' in
|
|
`\|\c
|
|
.I source\c
|
|
.B \&.o\c
|
|
\&\|', its assembler file in `\|\c
|
|
.I source\c
|
|
.B \&.s\c
|
|
\&\|', and
|
|
all preprocessed C source on standard output.
|
|
.TP
|
|
.B \-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.
|
|
.TP
|
|
.B \-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.
|
|
.PP
|
|
.SH LANGUAGE OPTIONS
|
|
The following options control the dialect of C that the compiler
|
|
accepts:
|
|
.TP
|
|
.B \-ansi
|
|
Support all ANSI standard C programs.
|
|
.Sp
|
|
This turns off certain features of GNU C that are incompatible with
|
|
ANSI C, such as the \c
|
|
.B asm\c
|
|
\&, \c
|
|
.B inline\c
|
|
\& and \c
|
|
.B typeof
|
|
keywords, and predefined macros such as \c
|
|
.B unix\c
|
|
\& and \c
|
|
.B vax
|
|
that identify the type of system you are using. It also enables the
|
|
undesirable and rarely used ANSI trigraph feature, and disallows `\|\c
|
|
.B $\c
|
|
\&\|' as part of identifiers.
|
|
.Sp
|
|
The alternate keywords \c
|
|
.B _\|_asm_\|_\c
|
|
\&, \c
|
|
.B _\|_extension_\|_\c
|
|
\&,
|
|
.B _\|_inline_\|_\c
|
|
\& and \c
|
|
.B _\|_typeof_\|_\c
|
|
\& continue to work despite
|
|
`\|\c
|
|
.B \-ansi\c
|
|
\&\|'. 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 `\|\c
|
|
.B \-ansi\c
|
|
\&\|'. Alternate predefined macros
|
|
such as \c
|
|
.B _\|_unix_\|_\c
|
|
\& and \c
|
|
.B _\|_vax_\|_\c
|
|
\& are also available, with or
|
|
without `\|\c
|
|
.B \-ansi\c
|
|
\&\|'.
|
|
.Sp
|
|
The `\|\c
|
|
.B \-ansi\c
|
|
\&\|' option does not cause non-ANSI programs to be
|
|
rejected gratuitously. For that, `\|\c
|
|
.B \-pedantic\c
|
|
\&\|' is required in
|
|
addition to `\|\c
|
|
.B \-ansi\c
|
|
\&\|'.
|
|
.Sp
|
|
The preprocessor predefines a macro \c
|
|
.B _\|_STRICT_ANSI_\|_\c
|
|
\& when you use the `\|\c
|
|
.B \-ansi\c
|
|
\&\|'
|
|
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.
|
|
.TP
|
|
.B \-fno\-asm
|
|
Do not recognize \c
|
|
.B asm\c
|
|
\&, \c
|
|
.B inline\c
|
|
\& or \c
|
|
.B typeof\c
|
|
\& as a
|
|
keyword. These words may then be used as identifiers. You can
|
|
use \c
|
|
.B _\|_asm_\|_\c
|
|
\&, \c
|
|
.B _\|_inline_\|_\c
|
|
\& and \c
|
|
.B _\|_typeof_\|_\c
|
|
\& instead.
|
|
`\|\c
|
|
.B \-ansi\c
|
|
\&\|' implies `\|\c
|
|
.B \-fno\-asm\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-fno\-builtin
|
|
Don't recognize built-in functions that do not begin with two leading
|
|
underscores. Currently, the functions affected include \c
|
|
.B _exit\c
|
|
\&,
|
|
.B abort\c
|
|
\&, \c
|
|
.B abs\c
|
|
\&, \c
|
|
.B alloca\c
|
|
\&, \c
|
|
.B cos\c
|
|
\&, \c
|
|
.B exit\c
|
|
\&,
|
|
.B fabs\c
|
|
\&, \c
|
|
.B labs\c
|
|
\&, \c
|
|
.B memcmp\c
|
|
\&, \c
|
|
.B memcpy\c
|
|
\&, \c
|
|
.B sin\c
|
|
\&,
|
|
.B sqrt\c
|
|
\&, \c
|
|
.B strcmp\c
|
|
\&, \c
|
|
.B strcpy\c
|
|
\&, and \c
|
|
.B strlen\c
|
|
\&.
|
|
.Sp
|
|
The `\|\c
|
|
.B \-ansi\c
|
|
\&\|' option prevents \c
|
|
.B alloca\c
|
|
\& and \c
|
|
.B _exit\c
|
|
\& from
|
|
being builtin functions.
|
|
.TP
|
|
.B \-fhosted
|
|
Compile for a hosted environment; this implies the `\|\c
|
|
.B \-fbuiltin\c
|
|
\&\|' option, and implies that suspicious declarations of
|
|
.B main\c
|
|
\& should be warned about.
|
|
.TP
|
|
.B \-ffreestanding
|
|
Compile for a freestanding environment; this implies the `\|\c
|
|
.B \-fno-builtin\c
|
|
\&\|' option, and implies that
|
|
.B main\c
|
|
\& has no special requirements.
|
|
.TP
|
|
.B \-fno\-strict\-prototype
|
|
Treat a function declaration with no arguments, such as `\|\c
|
|
.B int foo
|
|
();\c
|
|
\&\|', as C would treat it\(em\&as saying nothing about the number of
|
|
arguments or their types (C++ only). Normally, such a declaration in
|
|
C++ means that the function \c
|
|
.B foo\c
|
|
\& takes no arguments.
|
|
.TP
|
|
.B \-trigraphs
|
|
Support ANSI C trigraphs. The `\|\c
|
|
.B \-ansi\c
|
|
\&\|' option implies `\|\c
|
|
.B \-trigraphs\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-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.
|
|
.Sp
|
|
But one note about C++ programs only (not C). `\|\c
|
|
.B \-traditional\c
|
|
\&\|' has one additional effect for C++: assignment to
|
|
.B this
|
|
is permitted. This is the same as the effect of `\|\c
|
|
.B \-fthis\-is\-variable\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-traditional\-cpp
|
|
Attempt to support some aspects of traditional C preprocessors.
|
|
This includes the items that specifically mention the preprocessor above,
|
|
but none of the other effects of `\|\c
|
|
.B \-traditional\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-fdollars\-in\-identifiers
|
|
Permit the use of `\|\c
|
|
.B $\c
|
|
\&\|' in identifiers (C++ only). You can also use
|
|
`\|\c
|
|
.B \-fno\-dollars\-in\-identifiers\c
|
|
\&\|' to explicitly prohibit use of
|
|
`\|\c
|
|
.B $\c
|
|
\&\|'. (GNU C++ allows `\|\c
|
|
.B $\c
|
|
\&\|' by default on some target systems
|
|
but not others.)
|
|
.TP
|
|
.B \-fenum\-int\-equiv
|
|
Permit implicit conversion of \c
|
|
.B int\c
|
|
\& to enumeration types (C++
|
|
only). Normally GNU C++ allows conversion of \c
|
|
.B enum\c
|
|
\& to \c
|
|
.B int\c
|
|
\&,
|
|
but not the other way around.
|
|
.TP
|
|
.B \-fexternal\-templates
|
|
Produce smaller code for template declarations, by generating only a
|
|
single copy of each template function where it is defined (C++ only).
|
|
To use this option successfully, you must also mark all files that
|
|
use templates with either `\|\c
|
|
.B #pragma implementation\c
|
|
\&\|' (the definition) or
|
|
`\|\c
|
|
.B #pragma interface\c
|
|
\&\|' (declarations).
|
|
|
|
When your code is compiled with `\|\c
|
|
.B \-fexternal\-templates\c
|
|
\&\|', all
|
|
template instantiations are external. You must arrange for all
|
|
necessary instantiations to appear in the implementation file; you can
|
|
do this with a \c
|
|
.B typedef\c
|
|
\& that references each instantiation needed.
|
|
Conversely, when you compile using the default option
|
|
`\|\c
|
|
.B \-fno\-external\-templates\c
|
|
\&\|', all template instantiations are
|
|
explicitly internal.
|
|
.TP
|
|
.B \-fall\-virtual
|
|
Treat all possible member functions as virtual, implicitly. All
|
|
member functions (except for constructor functions and
|
|
.B new
|
|
or
|
|
.B delete
|
|
member operators) are treated as virtual functions of the class where
|
|
they appear.
|
|
.Sp
|
|
This does not mean that all calls to these member functions will be
|
|
made through the internal table of virtual functions. Under some
|
|
circumstances, the compiler can determine that a call to a given
|
|
virtual function can be made directly; in these cases the calls are
|
|
direct in any case.
|
|
.TP
|
|
.B \-fcond\-mismatch
|
|
Allow conditional expressions with mismatched types in the second and
|
|
third arguments. The value of such an expression is void.
|
|
.TP
|
|
.B \-fthis\-is\-variable
|
|
Permit assignment to \c
|
|
.B this\c
|
|
\& (C++ only). The incorporation of
|
|
user-defined free store management into C++ has made assignment to
|
|
`\|\c
|
|
.B this\c
|
|
\&\|' an anachronism. Therefore, by default it is invalid to
|
|
assign to \c
|
|
.B this\c
|
|
\& within a class member function. However, for
|
|
backwards compatibility, you can make it valid with
|
|
`\|\c
|
|
.B \-fthis-is-variable\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-funsigned\-char
|
|
Let the type \c
|
|
.B char\c
|
|
\& be unsigned, like \c
|
|
.B unsigned char\c
|
|
\&.
|
|
.Sp
|
|
Each kind of machine has a default for what \c
|
|
.B char\c
|
|
\& should
|
|
be. It is either like \c
|
|
.B unsigned char\c
|
|
\& by default or like
|
|
.B signed char\c
|
|
\& by default.
|
|
.Sp
|
|
Ideally, a portable program should always use \c
|
|
.B signed char\c
|
|
\& or
|
|
.B unsigned char\c
|
|
\& when it depends on the signedness of an object.
|
|
But many programs have been written to use plain \c
|
|
.B char\c
|
|
\& and
|
|
expect 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.
|
|
.Sp
|
|
The type \c
|
|
.B char\c
|
|
\& is always a distinct type from each of
|
|
.B signed char\c
|
|
\& and \c
|
|
.B unsigned char\c
|
|
\&, even though its behavior
|
|
is always just like one of those two.
|
|
.TP
|
|
.B \-fsigned\-char
|
|
Let the type \c
|
|
.B char\c
|
|
\& be signed, like \c
|
|
.B signed char\c
|
|
\&.
|
|
.Sp
|
|
Note that this is equivalent to `\|\c
|
|
.B \-fno\-unsigned\-char\c
|
|
\&\|', which is
|
|
the negative form of `\|\c
|
|
.B \-funsigned\-char\c
|
|
\&\|'. Likewise,
|
|
`\|\c
|
|
.B \-fno\-signed\-char\c
|
|
\&\|' is equivalent to `\|\c
|
|
.B \-funsigned\-char\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-fsigned\-bitfields
|
|
.TP
|
|
.B \-funsigned\-bitfields
|
|
.TP
|
|
.B \-fno\-signed\-bitfields
|
|
.TP
|
|
.B \-fno\-unsigned\-bitfields
|
|
These options control whether a bitfield is
|
|
signed or unsigned, when declared with no explicit `\|\c
|
|
.B signed\c
|
|
\&\|' or `\|\c
|
|
.B unsigned\c
|
|
\&\|' qualifier. By default, such a bitfield is
|
|
signed, because this is consistent: the basic integer types such as
|
|
.B int\c
|
|
\& are signed types.
|
|
.Sp
|
|
However, when you specify `\|\c
|
|
.B \-traditional\c
|
|
\&\|', bitfields are all unsigned
|
|
no matter what.
|
|
.TP
|
|
.B \-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. `\|\c
|
|
.B \-traditional\c
|
|
\&\|' also has this
|
|
effect.
|
|
.Sp
|
|
Writing into string constants is a very bad idea; \*(lqconstants\*(rq should
|
|
be constant.
|
|
.SH PREPROCESSOR OPTIONS
|
|
These options control the C preprocessor, which is run on each C source
|
|
file before actual compilation.
|
|
.PP
|
|
If you use the `\|\c
|
|
.B \-E\c
|
|
\&\|' option, GCC does nothing except preprocessing.
|
|
Some of these options make sense only together with `\|\c
|
|
.B \-E\c
|
|
\&\|' because
|
|
they cause the preprocessor output to be unsuitable for actual
|
|
compilation.
|
|
.TP
|
|
.BI "\-include " "file"
|
|
Process \c
|
|
.I file\c
|
|
\& as input before processing the regular input file.
|
|
In effect, the contents of \c
|
|
.I file\c
|
|
\& are compiled first. Any `\|\c
|
|
.B \-D\c
|
|
\&\|'
|
|
and `\|\c
|
|
.B \-U\c
|
|
\&\|' options on the command line are always processed before
|
|
`\|\c
|
|
.B \-include \c
|
|
.I file\c
|
|
\&\c
|
|
\&\|', regardless of the order in which they are
|
|
written. All the `\|\c
|
|
.B \-include\c
|
|
\&\|' and `\|\c
|
|
.B \-imacros\c
|
|
\&\|' options are
|
|
processed in the order in which they are written.
|
|
.TP
|
|
.BI "\-imacros " file
|
|
Process \c
|
|
.I file\c
|
|
\& as input, discarding the resulting output, before
|
|
processing the regular input file. Because the output generated from
|
|
.I file\c
|
|
\& is discarded, the only effect of `\|\c
|
|
.B \-imacros \c
|
|
.I file\c
|
|
\&\c
|
|
\&\|' is to
|
|
make the macros defined in \c
|
|
.I file\c
|
|
\& available for use in the main
|
|
input. The preprocessor evaluates any `\|\c
|
|
.B \-D\c
|
|
\&\|' and `\|\c
|
|
.B \-U\c
|
|
\&\|' options
|
|
on the command line before processing `\|\c
|
|
.B \-imacros\c
|
|
.I file\c
|
|
\&\|', regardless of the order in
|
|
which they are written. All the `\|\c
|
|
.B \-include\c
|
|
\&\|' and `\|\c
|
|
.B \-imacros\c
|
|
\&\|'
|
|
options are processed in the order in which they are written.
|
|
.TP
|
|
.BI "\-idirafter " "dir"
|
|
Add the directory \c
|
|
.I dir\c
|
|
\& to the second include path. The directories
|
|
on the second include path are searched when a header file is not found
|
|
in any of the directories in the main include path (the one that
|
|
`\|\c
|
|
.B \-I\c
|
|
\&\|' adds to).
|
|
.TP
|
|
.BI "\-iprefix " "prefix"
|
|
Specify \c
|
|
.I prefix\c
|
|
\& as the prefix for subsequent `\|\c
|
|
.B \-iwithprefix\c
|
|
\&\|'
|
|
options.
|
|
.TP
|
|
.BI "\-iwithprefix " "dir"
|
|
Add a directory to the second include path. The directory's name is
|
|
made by concatenating \c
|
|
.I prefix\c
|
|
\& and \c
|
|
.I dir\c
|
|
\&, where \c
|
|
.I prefix
|
|
was specified previously with `\|\c
|
|
.B \-iprefix\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-nostdinc
|
|
Do not search the standard system directories for header files. Only
|
|
the directories you have specified with `\|\c
|
|
.B \-I\c
|
|
\&\|' options (and the
|
|
current directory, if appropriate) are searched.
|
|
.Sp
|
|
By using both `\|\c
|
|
.B \-nostdinc\c
|
|
\&\|' and `\|\c
|
|
.B \-I\-\c
|
|
\&\|', you can limit the include-file search file to only those
|
|
directories you specify explicitly.
|
|
.TP
|
|
.B \-nostdinc++
|
|
Do not search for header files in the C++\-specific standard directories,
|
|
but do still search the other standard directories.
|
|
(This option is used when building `\|\c
|
|
.B libg++\c
|
|
\&\|'.)
|
|
.TP
|
|
.B \-undef
|
|
Do not predefine any nonstandard macros. (Including architecture flags).
|
|
.TP
|
|
.B \-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.
|
|
.TP
|
|
.B \-C
|
|
Tell the preprocessor not to discard comments. Used with the
|
|
`\|\c
|
|
.B \-E\c
|
|
\&\|' option.
|
|
.TP
|
|
.B \-P
|
|
Tell the preprocessor not to generate `\|\c
|
|
.B #line\c
|
|
\&\|' commands.
|
|
Used with the `\|\c
|
|
.B \-E\c
|
|
\&\|' option.
|
|
.TP
|
|
.B \-M\ [ \-MG ]
|
|
Tell the preprocessor to output a rule suitable for \c
|
|
.B make
|
|
describing the dependencies of each object file. For each source file,
|
|
the preprocessor outputs one \c
|
|
.B make\c
|
|
\&-rule whose target is the object
|
|
file name for that source file and whose dependencies are all the files
|
|
`\|\c
|
|
.B #include\c
|
|
\&\|'d in it. This rule may be a single line or may be
|
|
continued with `\|\c
|
|
.B \e\c
|
|
\&\|'-newline if it is long. The list of rules is
|
|
printed on standard output instead of the preprocessed C program.
|
|
.Sp
|
|
`\|\c
|
|
.B \-M\c
|
|
\&\|' implies `\|\c
|
|
.B \-E\c
|
|
\&\|'.
|
|
.Sp
|
|
`\|\c
|
|
.B \-MG\c
|
|
\&\|' says to treat missing header files as generated files and assume \c
|
|
they live in the same directory as the source file. It must be specified \c
|
|
in addition to `\|\c
|
|
.B \-M\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-MM\ [ \-MG ]
|
|
Like `\|\c
|
|
.B \-M\c
|
|
\&\|' but the output mentions only the user header files
|
|
included with `\|\c
|
|
.B
|
|
#include "\c
|
|
.I file\c
|
|
.B
|
|
\&"\c
|
|
\&\|'. System header files
|
|
included with `\|\c
|
|
.B
|
|
#include <\c
|
|
.I file\c
|
|
.B
|
|
\&>\c
|
|
\&\|' are omitted.
|
|
.TP
|
|
.B \-MD
|
|
Like `\|\c
|
|
.B \-M\c
|
|
\&\|' but the dependency information is written to files with
|
|
names made by replacing `\|\c
|
|
.B .o\c
|
|
\&\|' with `\|\c
|
|
.B .d\c
|
|
\&\|' at the end of the
|
|
output file names. This is in addition to compiling the file as
|
|
specified\(em\&`\|\c
|
|
.B \-MD\c
|
|
\&\|' does not inhibit ordinary compilation the way
|
|
`\|\c
|
|
.B \-M\c
|
|
\&\|' does.
|
|
.Sp
|
|
The Mach utility `\|\c
|
|
.B md\c
|
|
\&\|' can be used to merge the `\|\c
|
|
.B .d\c
|
|
\&\|' files
|
|
into a single dependency file suitable for using with the `\|\c
|
|
.B make\c
|
|
\&\|'
|
|
command.
|
|
.TP
|
|
.B \-MMD
|
|
Like `\|\c
|
|
.B \-MD\c
|
|
\&\|' except mention only user header files, not system
|
|
header files.
|
|
.TP
|
|
.B \-H
|
|
Print the name of each header file used, in addition to other normal
|
|
activities.
|
|
.TP
|
|
.BI "\-A" "question" ( answer )
|
|
Assert the answer
|
|
.I answer
|
|
for
|
|
.I question\c
|
|
\&, in case it is tested
|
|
with a preprocessor conditional such as `\|\c
|
|
.BI "#if #" question ( answer )\c
|
|
\&\|'. `\|\c
|
|
.B \-A\-\c
|
|
\&\|' disables the standard
|
|
assertions that normally describe the target machine.
|
|
.TP
|
|
.BI "\-A" "question"\c
|
|
\&(\c
|
|
.I answer\c
|
|
\&)
|
|
Assert the answer \c
|
|
.I answer\c
|
|
\& for \c
|
|
.I question\c
|
|
\&, in case it is tested
|
|
with a preprocessor conditional such as `\|\c
|
|
.B #if
|
|
#\c
|
|
.I question\c
|
|
\&(\c
|
|
.I answer\c
|
|
\&)\c
|
|
\&\|'. `\|\c
|
|
.B \-A-\c
|
|
\&\|' disables the standard
|
|
assertions that normally describe the target machine.
|
|
.TP
|
|
.BI \-D macro
|
|
Define macro \c
|
|
.I macro\c
|
|
\& with the string `\|\c
|
|
.B 1\c
|
|
\&\|' as its definition.
|
|
.TP
|
|
.BI \-D macro = defn
|
|
Define macro \c
|
|
.I macro\c
|
|
\& as \c
|
|
.I defn\c
|
|
\&. All instances of `\|\c
|
|
.B \-D\c
|
|
\&\|' on
|
|
the command line are processed before any `\|\c
|
|
.B \-U\c
|
|
\&\|' options.
|
|
.TP
|
|
.BI \-U macro
|
|
Undefine macro \c
|
|
.I macro\c
|
|
\&. `\|\c
|
|
.B \-U\c
|
|
\&\|' options are evaluated after all `\|\c
|
|
.B \-D\c
|
|
\&\|' options, but before any `\|\c
|
|
.B \-include\c
|
|
\&\|' and `\|\c
|
|
.B \-imacros\c
|
|
\&\|' options.
|
|
.TP
|
|
.B \-dM
|
|
Tell the preprocessor to output only a list of the macro definitions
|
|
that are in effect at the end of preprocessing. Used with the `\|\c
|
|
.B \-E\c
|
|
\&\|'
|
|
option.
|
|
.TP
|
|
.B \-dD
|
|
Tell the preprocessor to pass all macro definitions into the output, in
|
|
their proper sequence in the rest of the output.
|
|
.TP
|
|
.B \-dN
|
|
Like `\|\c
|
|
.B \-dD\c
|
|
\&\|' except that the macro arguments and contents are omitted.
|
|
Only `\|\c
|
|
.B #define \c
|
|
.I name\c
|
|
\&\c
|
|
\&\|' is included in the output.
|
|
.SH ASSEMBLER OPTION
|
|
.TP
|
|
.BI "\-Wa," "option"
|
|
Pass \c
|
|
.I option\c
|
|
\& as an option to the assembler. If \c
|
|
.I option
|
|
contains commas, it is split into multiple options at the commas.
|
|
.SH LINKER OPTIONS
|
|
These options come into play when the compiler links object files into
|
|
an executable output file. They are meaningless if the compiler is
|
|
not doing a link step.
|
|
.TP
|
|
.I 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.
|
|
.TP
|
|
.BI \-l library
|
|
Use the library named \c
|
|
.I library\c
|
|
\& when linking.
|
|
.Sp
|
|
The linker searches a standard list of directories for the library,
|
|
which is actually a file named `\|\c
|
|
.B lib\c
|
|
.I library\c
|
|
\&.a\c
|
|
\&\|'. The linker
|
|
then uses this file as if it had been specified precisely by name.
|
|
.Sp
|
|
The directories searched include several standard system directories
|
|
plus any that you specify with `\|\c
|
|
.B \-L\c
|
|
\&\|'.
|
|
.Sp
|
|
Normally the files found this way are library files\(em\&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 `\|\c
|
|
.B \-l\c
|
|
\&\|' option and specifying a file
|
|
name is that `\|\c
|
|
.B \-l\c
|
|
\&\|' surrounds
|
|
.I library
|
|
with `\|\c
|
|
.B lib\c
|
|
\&\|' and `\|\c
|
|
.B .a\c
|
|
\&\|' and searches several directories.
|
|
.TP
|
|
.B \-lobjc
|
|
You need this special case of the
|
|
.B \-l
|
|
option in order to link an Objective C program.
|
|
.TP
|
|
.B \-nostartfiles
|
|
Do not use the standard system startup files when linking.
|
|
The standard libraries are used normally.
|
|
.TP
|
|
.B \-nostdlib
|
|
Don't use the standard system libraries and startup files when linking.
|
|
Only the files you specify will be passed to the linker.
|
|
.TP
|
|
.B \-static
|
|
On systems that support dynamic linking, this prevents linking with the shared
|
|
libraries. On other systems, this option has no effect.
|
|
.TP
|
|
.B \-shared
|
|
Produce a shared object which can then be linked with other objects to
|
|
form an executable. Only a few systems support this option.
|
|
.TP
|
|
.B \-symbolic
|
|
Bind references to global symbols when building a shared object. Warn
|
|
about any unresolved references (unless overridden by the link editor
|
|
option `\|\c
|
|
.B
|
|
\-Xlinker \-z \-Xlinker defs\c
|
|
\&\|'). Only a few systems support
|
|
this option.
|
|
.TP
|
|
.BI "\-Xlinker " "option"
|
|
Pass \c
|
|
.I option
|
|
as an option to the linker. You can use this to
|
|
supply system-specific linker options which GNU CC does not know how to
|
|
recognize.
|
|
.Sp
|
|
If you want to pass an option that takes an argument, you must use
|
|
`\|\c
|
|
.B \-Xlinker\c
|
|
\&\|' twice, once for the option and once for the argument.
|
|
For example, to pass `\|\c
|
|
.B
|
|
\-assert definitions\c
|
|
\&\|', you must write
|
|
`\|\c
|
|
.B
|
|
\-Xlinker \-assert \-Xlinker definitions\c
|
|
\&\|'. It does not work to write
|
|
`\|\c
|
|
.B
|
|
\-Xlinker "\-assert definitions"\c
|
|
\&\|', because this passes the entire
|
|
string as a single argument, which is not what the linker expects.
|
|
.TP
|
|
.BI "\-Wl," "option"
|
|
Pass \c
|
|
.I option\c
|
|
\& as an option to the linker. If \c
|
|
.I option\c
|
|
\& contains
|
|
commas, it is split into multiple options at the commas.
|
|
.TP
|
|
.BI "\-u " "symbol"
|
|
Pretend the symbol
|
|
.I symbol
|
|
is undefined, to force linking of
|
|
library modules to define it. You can use `\|\c
|
|
.B \-u\c
|
|
\&\|' multiple times with
|
|
different symbols to force loading of additional library modules.
|
|
.SH DIRECTORY OPTIONS
|
|
These options specify directories to search for header files, for
|
|
libraries and for parts of the compiler:
|
|
.TP
|
|
.BI "\-I" "dir"
|
|
Append directory \c
|
|
.I dir\c
|
|
\& to the list of directories searched for include files.
|
|
.TP
|
|
.B \-I\-
|
|
Any directories you specify with `\|\c
|
|
.B \-I\c
|
|
\&\|' options before the `\|\c
|
|
.B \-I\-\c
|
|
\&\|'
|
|
option are searched only for the case of `\|\c
|
|
.B
|
|
#include "\c
|
|
.I file\c
|
|
.B
|
|
\&"\c
|
|
\&\|';
|
|
they are not searched for `\|\c
|
|
.B
|
|
#include <\c
|
|
.I file\c
|
|
.B
|
|
\&>\c
|
|
\&\|'.
|
|
.Sp
|
|
If additional directories are specified with `\|\c
|
|
.B \-I\c
|
|
\&\|' options after
|
|
the `\|\c
|
|
.B \-I\-\c
|
|
\&\|', these directories are searched for all `\|\c
|
|
.B #include\c
|
|
\&\|'
|
|
directives. (Ordinarily \c
|
|
.I all\c
|
|
\& `\|\c
|
|
.B \-I\c
|
|
\&\|' directories are used
|
|
this way.)
|
|
.Sp
|
|
In addition, the `\|\c
|
|
.B \-I\-\c
|
|
\&\|' option inhibits the use of the current
|
|
directory (where the current input file came from) as the first search
|
|
directory for `\|\c
|
|
.B
|
|
#include "\c
|
|
.I file\c
|
|
.B
|
|
\&"\c
|
|
\&\|'. There is no way to
|
|
override this effect of `\|\c
|
|
.B \-I\-\c
|
|
\&\|'. With `\|\c
|
|
.B \-I.\c
|
|
\&\|' you can specify
|
|
searching the directory which was current when the compiler was
|
|
invoked. That is not exactly the same as what the preprocessor does
|
|
by default, but it is often satisfactory.
|
|
.Sp
|
|
`\|\c
|
|
.B \-I\-\c
|
|
\&\|' does not inhibit the use of the standard system directories
|
|
for header files. Thus, `\|\c
|
|
.B \-I\-\c
|
|
\&\|' and `\|\c
|
|
.B \-nostdinc\c
|
|
\&\|' are
|
|
independent.
|
|
.TP
|
|
.BI "\-L" "dir"
|
|
Add directory \c
|
|
.I dir\c
|
|
\& to the list of directories to be searched
|
|
for `\|\c
|
|
.B \-l\c
|
|
\&\|'.
|
|
.TP
|
|
.BI "\-B" "prefix"
|
|
This option specifies where to find the executables, libraries and
|
|
data files of the compiler itself.
|
|
.Sp
|
|
The compiler driver program runs one or more of the subprograms
|
|
`\|\c
|
|
.B cpp\c
|
|
\&\|', `\|\c
|
|
.B cc1\c
|
|
\&\|' (or, for C++, `\|\c
|
|
.B cc1plus\c
|
|
\&\|'), `\|\c
|
|
.B as\c
|
|
\&\|' and `\|\c
|
|
.B ld\c
|
|
\&\|'. It tries
|
|
.I prefix\c
|
|
\& as a prefix for each program it tries to run, both with and
|
|
without `\|\c
|
|
.I machine\c
|
|
.B /\c
|
|
.I version\c
|
|
.B /\c
|
|
\&\|'.
|
|
.Sp
|
|
For each subprogram to be run, the compiler driver first tries the
|
|
`\|\c
|
|
.B \-B\c
|
|
\&\|' prefix, if any. If that name is not found, or if `\|\c
|
|
.B \-B\c
|
|
\&\|'
|
|
was not specified, the driver tries two standard prefixes, which are
|
|
`\|\c
|
|
.B /usr/lib/gcc/\c
|
|
\&\|' and `\|\c
|
|
.B /usr/local/lib/gcc-lib/\c
|
|
\&\|'. If neither of
|
|
those results in a file name that is found, the compiler driver
|
|
searches for the unmodified program
|
|
name, using the directories specified in your
|
|
`\|\c
|
|
.B PATH\c
|
|
\&\|' environment variable.
|
|
.Sp
|
|
The run-time support file `\|\c
|
|
.B libgcc.a\c
|
|
\&\|' is also searched for using the
|
|
`\|\c
|
|
.B \-B\c
|
|
\&\|' 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, `\|\c
|
|
.B libgcc.a\c
|
|
\&\|' is not actually necessary.
|
|
.Sp
|
|
You can get a similar result from the environment variable
|
|
.B GCC_EXEC_PREFIX\c
|
|
\&; if it is defined, its value is used as a prefix
|
|
in the same way. If both the `\|\c
|
|
.B \-B\c
|
|
\&\|' option and the
|
|
.B GCC_EXEC_PREFIX\c
|
|
\& variable are present, the `\|\c
|
|
.B \-B\c
|
|
\&\|' option is
|
|
used first and the environment variable value second.
|
|
.SH 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.
|
|
.Sp
|
|
These options control the amount and kinds of warnings produced by GNU
|
|
CC:
|
|
.TP
|
|
.B \-fsyntax\-only
|
|
Check the code for syntax errors, but don't emit any output.
|
|
.TP
|
|
.B \-w
|
|
Inhibit all warning messages.
|
|
.TP
|
|
.B \-Wno\-import
|
|
Inhibit warning messages about the use of
|
|
.BR #import .
|
|
.TP
|
|
.B \-pedantic
|
|
Issue all the warnings demanded by strict ANSI standard C; reject
|
|
all programs that use forbidden extensions.
|
|
.Sp
|
|
Valid ANSI standard C programs should compile properly with or without
|
|
this option (though a rare few will require `\|\c
|
|
.B \-ansi\c
|
|
\&\|'). However,
|
|
without this option, certain GNU extensions and traditional C features
|
|
are supported as well. With this option, they are rejected. There is
|
|
no reason to \c
|
|
.I use\c
|
|
\& this option; it exists only to satisfy pedants.
|
|
.Sp
|
|
`\|\c
|
|
.B \-pedantic\c
|
|
\&\|' does not cause warning messages for use of the
|
|
alternate keywords whose names begin and end with `\|\c
|
|
.B _\|_\c
|
|
\&\|'. Pedantic
|
|
warnings are also disabled in the expression that follows
|
|
.B _\|_extension_\|_\c
|
|
\&. However, only system header files should use
|
|
these escape routes; application programs should avoid them.
|
|
.TP
|
|
.B \-pedantic\-errors
|
|
Like `\|\c
|
|
.B \-pedantic\c
|
|
\&\|', except that errors are produced rather than
|
|
warnings.
|
|
.TP
|
|
.B \-W
|
|
Print extra warning messages for these events:
|
|
.TP
|
|
\ \ \ \(bu
|
|
A nonvolatile automatic variable might be changed by a call to
|
|
.B longjmp\c
|
|
\&. These warnings are possible only in
|
|
optimizing compilation.
|
|
.Sp
|
|
The compiler sees only the calls to \c
|
|
.B setjmp\c
|
|
\&. It cannot know
|
|
where \c
|
|
.B longjmp\c
|
|
\& 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 \c
|
|
.B longjmp\c
|
|
\& cannot
|
|
in fact be called at the place which would cause a problem.
|
|
.TP
|
|
\ \ \ \(bu
|
|
A function can return either with or without a value. (Falling
|
|
off the end of the function body is considered returning without
|
|
a value.) For example, this function would evoke such a
|
|
warning:
|
|
.Sp
|
|
.nf
|
|
foo (a)
|
|
{
|
|
if (a > 0)
|
|
return a;
|
|
}
|
|
.Sp
|
|
.fi
|
|
Spurious warnings can occur because GNU CC does not realize that
|
|
certain functions (including \c
|
|
.B abort\c
|
|
\& and \c
|
|
.B longjmp\c
|
|
\&)
|
|
will never return.
|
|
.TP
|
|
\ \ \ \(bu
|
|
An expression-statement or the left-hand side of a comma expression
|
|
contains no side effects.
|
|
To suppress the warning, cast the unused expression to void.
|
|
For example, an expression such as `\|\c
|
|
.B x[i,j]\c
|
|
\&\|' will cause a warning,
|
|
but `\|\c
|
|
.B x[(void)i,j]\c
|
|
\&\|' will not.
|
|
.TP
|
|
\ \ \ \(bu
|
|
An unsigned value is compared against zero with `\|\c
|
|
.B >\c
|
|
\&\|' or `\|\c
|
|
.B <=\c
|
|
\&\|'.
|
|
.PP
|
|
.TP
|
|
.B \-Wimplicit-int
|
|
Warn whenever a declaration does not specify a type.
|
|
.TP
|
|
.B \-Wimplicit-function-declaration
|
|
Warn whenever a function is used before being declared.
|
|
.TP
|
|
.B \-Wimplicit
|
|
Same as -Wimplicit-int and -Wimplicit-function-declaration.
|
|
.TP
|
|
.B \-Wmain
|
|
Warn if the
|
|
.B main
|
|
function is declared or defined with a suspicious type.
|
|
Typically, it is a function with external linkage, returning
|
|
.B int\c
|
|
\&, and
|
|
taking zero or two arguments.
|
|
|
|
.TP
|
|
.B \-Wreturn\-type
|
|
Warn whenever a function is defined with a return-type that defaults
|
|
to \c
|
|
.B int\c
|
|
\&. Also warn about any \c
|
|
.B return\c
|
|
\& statement with no
|
|
return-value in a function whose return-type is not \c
|
|
.B void\c
|
|
\&.
|
|
.TP
|
|
.B \-Wunused
|
|
Warn whenever a local variable is unused aside from its declaration,
|
|
whenever a function is declared static but never defined, and whenever
|
|
a statement computes a result that is explicitly not used.
|
|
.TP
|
|
.B \-Wswitch
|
|
Warn whenever a \c
|
|
.B switch\c
|
|
\& statement has an index of enumeral type
|
|
and lacks a \c
|
|
.B case\c
|
|
\& for one or more of the named codes of that
|
|
enumeration. (The presence of a \c
|
|
.B default\c
|
|
\& label prevents this
|
|
warning.) \c
|
|
.B case\c
|
|
\& labels outside the enumeration range also
|
|
provoke warnings when this option is used.
|
|
.TP
|
|
.B \-Wcomment
|
|
Warn whenever a comment-start sequence `\|\c
|
|
.B /\(**\c
|
|
\&\|' appears in a comment.
|
|
.TP
|
|
.B \-Wtrigraphs
|
|
Warn if any trigraphs are encountered (assuming they are enabled).
|
|
.TP
|
|
.B \-Wformat
|
|
Check calls to \c
|
|
.B printf\c
|
|
\& and \c
|
|
.B scanf\c
|
|
\&, etc., to make sure that
|
|
the arguments supplied have types appropriate to the format string
|
|
specified.
|
|
.TP
|
|
.B \-Wchar\-subscripts
|
|
Warn if an array subscript has type
|
|
.BR char .
|
|
This is a common cause of error, as programmers often forget that this
|
|
type is signed on some machines.
|
|
.TP
|
|
.B \-Wuninitialized
|
|
An automatic variable is used without first being initialized.
|
|
.Sp
|
|
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 `\|\c
|
|
.B \-O\c
|
|
\&\|', you simply won't
|
|
get these warnings.
|
|
.Sp
|
|
These warnings occur only for variables that are candidates for
|
|
register allocation. Therefore, they do not occur for a variable that
|
|
is declared \c
|
|
.B volatile\c
|
|
\&, 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.
|
|
.Sp
|
|
Note that there may be no warning about a variable that is used only
|
|
to compute a value that itself is never used, because such
|
|
computations may be deleted by data flow analysis before the warnings
|
|
are printed.
|
|
.Sp
|
|
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:
|
|
.Sp
|
|
.nf
|
|
{
|
|
int x;
|
|
switch (y)
|
|
{
|
|
case 1: x = 1;
|
|
break;
|
|
case 2: x = 4;
|
|
break;
|
|
case 3: x = 5;
|
|
}
|
|
foo (x);
|
|
}
|
|
.Sp
|
|
.fi
|
|
If the value of \c
|
|
.B y\c
|
|
\& is always 1, 2 or 3, then \c
|
|
.B x\c
|
|
\& is
|
|
always initialized, but GNU CC doesn't know this. Here is
|
|
another common case:
|
|
.Sp
|
|
.nf
|
|
{
|
|
int save_y;
|
|
if (change_y) save_y = y, y = new_y;
|
|
.\|.\|.
|
|
if (change_y) y = save_y;
|
|
}
|
|
.Sp
|
|
.fi
|
|
This has no bug because \c
|
|
.B save_y\c
|
|
\& is used only if it is set.
|
|
.Sp
|
|
Some spurious warnings can be avoided if you declare as
|
|
.B volatile\c
|
|
\& all the functions you use that never return.
|
|
.TP
|
|
.B \-Wparentheses
|
|
Warn if parentheses are omitted in certain contexts.
|
|
.TP
|
|
.B \-Wtemplate\-debugging
|
|
When using templates in a C++ program, warn if debugging is not yet
|
|
fully available (C++ only).
|
|
.TP
|
|
.B \-Wall
|
|
All of the above `\|\c
|
|
.B \-W\c
|
|
\&\|' options combined. These are all the
|
|
options which pertain to usage that we recommend avoiding and that we
|
|
believe is easy to avoid, even in conjunction with macros.
|
|
.PP
|
|
The remaining `\|\c
|
|
.B \-W.\|.\|.\c
|
|
\&\|' options are not implied by `\|\c
|
|
.B \-Wall\c
|
|
\&\|'
|
|
because they warn about constructions that we consider reasonable to
|
|
use, on occasion, in clean programs.
|
|
.TP
|
|
.B \-Wtraditional
|
|
Warn about certain constructs that behave differently in traditional and
|
|
ANSI C.
|
|
.TP
|
|
\ \ \ \(bu
|
|
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.
|
|
.TP
|
|
\ \ \ \(bu
|
|
A function declared external in one block and then used after the end of
|
|
the block.
|
|
.TP
|
|
\ \ \ \(bu
|
|
A \c
|
|
.B switch\c
|
|
\& statement has an operand of type \c
|
|
.B long\c
|
|
\&.
|
|
.PP
|
|
.TP
|
|
.B \-Wshadow
|
|
Warn whenever a local variable shadows another local variable.
|
|
.TP
|
|
.BI "\-Wid\-clash\-" "len"
|
|
Warn whenever two distinct identifiers match in the first \c
|
|
.I len
|
|
characters. This may help you prepare a program that will compile
|
|
with certain obsolete, brain-damaged compilers.
|
|
.TP
|
|
.B \-Wpointer\-arith
|
|
Warn about anything that depends on the \*(lqsize of\*(rq a function type or
|
|
of \c
|
|
.B void\c
|
|
\&. GNU C assigns these types a size of 1, for
|
|
convenience in calculations with \c
|
|
.B void \(**\c
|
|
\& pointers and pointers
|
|
to functions.
|
|
.TP
|
|
.B \-Wcast\-qual
|
|
Warn whenever a pointer is cast so as to remove a type qualifier from
|
|
the target type. For example, warn if a \c
|
|
.B const char \(**\c
|
|
\& is cast
|
|
to an ordinary \c
|
|
.B char \(**\c
|
|
\&.
|
|
.TP
|
|
.B \-Wcast\-align
|
|
Warn whenever a pointer is cast such that the required alignment of the
|
|
target is increased. For example, warn if a \c
|
|
.B char \(**\c
|
|
\& is cast to
|
|
an \c
|
|
.B int \(**\c
|
|
\& on machines where integers can only be accessed at
|
|
two- or four-byte boundaries.
|
|
.TP
|
|
.B \-Wwrite\-strings
|
|
Give string constants the type \c
|
|
.B const char[\c
|
|
.I length\c
|
|
.B ]\c
|
|
\& so that
|
|
copying the address of one into a non-\c
|
|
.B const\c
|
|
\& \c
|
|
.B char \(**
|
|
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 \-Wmissing\-declarations
|
|
Warn if a global function is defined without a previous declaration.
|
|
Do so even if the definition itself provides a prototype.
|
|
Use this option to detect global functions that are not declared in
|
|
header files.
|
|
.TP
|
|
.B \-Wredundant-decls
|
|
Warn if anything is declared more than once in the same scope, even in
|
|
cases where multiple declaration is valid and changes nothing.
|
|
.TP
|
|
.B \-Wnested-externs
|
|
Warn if an \c
|
|
.B extern\c
|
|
\& declaration is encountered within a function.
|
|
.TP
|
|
.B \-Wenum\-clash
|
|
Warn about conversion between different enumeration types (C++ only).
|
|
.TP
|
|
.B \-Wlong-long
|
|
Warn if
|
|
.B long long \c
|
|
type is used. This is default. To inhibit
|
|
the warning messages, use flag `\|\c
|
|
.B \-Wno\-long\-long\c
|
|
\&\|'. Flags `\|\c
|
|
.B \-W\-long\-long\c
|
|
\&\|' and `\|\c
|
|
.B \-Wno\-long\-long\c
|
|
\&\|' are taken into account only when flag `\|\c
|
|
.B \-pedantic\c
|
|
\&\|' is used.
|
|
.TP
|
|
.B \-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 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.
|
|
.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
|
|
(stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging
|
|
information.
|
|
.Sp
|
|
On most systems that use stabs format, `\|\c
|
|
.B \-g\c
|
|
\&\|' enables use of extra
|
|
debugging information that only GDB can use; this extra information
|
|
makes debugging work better in GDB but will probably make other debuggers
|
|
crash or
|
|
refuse to read the program. If you want to control for certain whether
|
|
to generate the extra information, use `\|\c
|
|
.B \-gstabs+\c
|
|
\&\|', `\|\c
|
|
.B \-gstabs\c
|
|
\&\|',
|
|
`\|\c
|
|
.B \-gxcoff+\c
|
|
\&\|', `\|\c
|
|
.B \-gxcoff\c
|
|
\&\|', `\|\c
|
|
.B \-gdwarf+\c
|
|
\&\|', or `\|\c
|
|
.B \-gdwarf\c
|
|
\&\|'
|
|
(see below).
|
|
.Sp
|
|
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.
|
|
.Sp
|
|
Nevertheless it proves possible to debug optimized output. This makes
|
|
it reasonable to use the optimizer for programs that might have bugs.
|
|
.PP
|
|
The following options are useful when GNU CC is generated with the
|
|
capability for more than one debugging format.
|
|
.TP
|
|
.B \-ggdb
|
|
Produce debugging information in the native format (if that is supported),
|
|
including GDB extensions if at all possible.
|
|
.TP
|
|
.B \-gstabs
|
|
Produce debugging information in stabs format (if that is supported),
|
|
without GDB extensions. This is the format used by DBX on most BSD
|
|
systems.
|
|
.TP
|
|
.B \-gstabs+
|
|
Produce debugging information in stabs format (if that is supported),
|
|
using GNU extensions understood only by the GNU debugger (GDB). The
|
|
use of these extensions is likely to make other debuggers crash or
|
|
refuse to read the program.
|
|
.TP
|
|
.B \-gcoff
|
|
Produce debugging information in COFF format (if that is supported).
|
|
This is the format used by SDB on most System V systems prior to
|
|
System V Release 4.
|
|
.TP
|
|
.B \-gxcoff
|
|
Produce debugging information in XCOFF format (if that is supported).
|
|
This is the format used by the DBX debugger on IBM RS/6000 systems.
|
|
.TP
|
|
.B \-gxcoff+
|
|
Produce debugging information in XCOFF format (if that is supported),
|
|
using GNU extensions understood only by the GNU debugger (GDB). The
|
|
use of these extensions is likely to make other debuggers crash or
|
|
refuse to read the program.
|
|
.TP
|
|
.B \-gdwarf
|
|
Produce debugging information in DWARF format (if that is supported).
|
|
This is the format used by SDB on most System V Release 4 systems.
|
|
.TP
|
|
.B \-gdwarf+
|
|
Produce debugging information in DWARF format (if that is supported),
|
|
using GNU extensions understood only by the GNU debugger (GDB). The
|
|
use of these extensions is likely to make other debuggers crash or
|
|
refuse to read the program.
|
|
.PP
|
|
.BI "\-g" "level"
|
|
.br
|
|
.BI "\-ggdb" "level"
|
|
.br
|
|
.BI "\-gstabs" "level"
|
|
.br
|
|
.BI "\-gcoff" "level"
|
|
.BI "\-gxcoff" "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.
|
|
.Sp
|
|
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.
|
|
.Sp
|
|
Level 3 includes extra information, such as all the macro definitions
|
|
present in the program. Some debuggers support macro expansion when
|
|
you use `\|\c
|
|
.B \-g3\c
|
|
\&\|'.
|
|
.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
|
|
.B \-ax
|
|
Generate extra code to read basic block profiling parameters from
|
|
file `bb.in' and write profiling results to file `bb.out'.
|
|
`bb.in' contains a list of functions. Whenever a function on the list
|
|
is entered, profiling is turned on. When the outmost function is left,
|
|
profiling is turned off. If a function name is prefixed with `-'
|
|
the function is excluded from profiling. If a function name is not
|
|
unique it can be disambiguated by writing
|
|
`/path/filename.d:functionname'. `bb.out' will list some available
|
|
filenames.
|
|
Four function names have a special meaning:
|
|
`__bb_jumps__' will cause jump frequencies to be written to `bb.out'.
|
|
`__bb_trace__' will cause the sequence of basic blocks to be piped
|
|
into `gzip' and written to file `bbtrace.gz'.
|
|
`__bb_hidecall__' will cause call instructions to be excluded from
|
|
the trace.
|
|
`__bb_showret__' will cause return instructions to be included in
|
|
the trace.
|
|
.TP
|
|
.BI "\-d" "letters"
|
|
Says to make debugging dumps during compilation at times specified by
|
|
.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 standard error.
|
|
.TP
|
|
.B \-dr
|
|
Dump after RTL generation, to `\|\c
|
|
.I file\c
|
|
.B \&.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
|
|
.I file\c
|
|
.B \&.jump\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-ds
|
|
Dump after CSE (including the jump optimization that sometimes
|
|
follows CSE), to `\|\c
|
|
.I file\c
|
|
.B \&.cse\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dL
|
|
Dump after loop optimization, to `\|\c
|
|
.I file\c
|
|
.B \&.loop\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dt
|
|
Dump after the second CSE pass (including the jump optimization that
|
|
sometimes follows CSE), to `\|\c
|
|
.I file\c
|
|
.B \&.cse2\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-df
|
|
Dump after flow analysis, to `\|\c
|
|
.I file\c
|
|
.B \&.flow\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dc
|
|
Dump after instruction combination, to `\|\c
|
|
.I file\c
|
|
.B \&.combine\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dS
|
|
Dump after the first instruction scheduling pass, to
|
|
`\|\c
|
|
.I file\c
|
|
.B \&.sched\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dl
|
|
Dump after local register allocation, to `\|\c
|
|
.I file\c
|
|
.B \&.lreg\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dg
|
|
Dump after global register allocation, to `\|\c
|
|
.I file\c
|
|
.B \&.greg\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dR
|
|
Dump after the second instruction scheduling pass, to
|
|
`\|\c
|
|
.I file\c
|
|
.B \&.sched2\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dJ
|
|
Dump after last jump optimization, to `\|\c
|
|
.I file\c
|
|
.B \&.jump2\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dd
|
|
Dump after delayed branch scheduling, to `\|\c
|
|
.I file\c
|
|
.B \&.dbr\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-dk
|
|
Dump after conversion from registers to stack, to `\|\c
|
|
.I file\c
|
|
.B \&.stack\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-da
|
|
Produce all the dumps listed above.
|
|
.TP
|
|
.B \-dm
|
|
Print statistics on memory usage, at the end of the run, to
|
|
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 \*(lqtemporary\*(rq 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
|
|
\&\|'.
|
|
.TP
|
|
.BI "\-print\-file\-name=" "library"
|
|
Print the full absolute name of the library file \|\c
|
|
.nh
|
|
.I library
|
|
.hy
|
|
\&\| that
|
|
would be used when linking\(em\&and do not do anything else. With this
|
|
option, GNU CC does not compile or link anything; it just prints the
|
|
file name.
|
|
.TP
|
|
.B \-print\-libgcc\-file\-name
|
|
Same as `\|\c
|
|
.B \-print\-file\-name=libgcc.a\c
|
|
\&\|'.
|
|
.TP
|
|
.BI "\-print\-prog\-name=" "program"
|
|
Like `\|\c
|
|
.B \-print\-file\-name\c
|
|
\&\|', but searches for a program such as `\|\c
|
|
cpp\c
|
|
\&\|'.
|
|
.SH OPTIMIZATION OPTIONS
|
|
These options control various sorts of optimizations:
|
|
.TP
|
|
.B \-O
|
|
.TP
|
|
.B \-O1
|
|
Optimize. Optimizing compilation takes somewhat more time, and a lot
|
|
more memory for a large function.
|
|
.Sp
|
|
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.
|
|
.Sp
|
|
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
|
|
\&\|'.
|
|
.Sp
|
|
With `\|\c
|
|
.B \-O\c
|
|
\&\|', the compiler tries to reduce code size and execution
|
|
time.
|
|
.Sp
|
|
When you specify `\|\c
|
|
.B \-O\c
|
|
\&\|', the two options `\|\c
|
|
.B \-fthread\-jumps\c
|
|
\&\|' and `\|\c
|
|
.B \-fdefer\-pop\c
|
|
\&\|' are turned on. On machines that have delay slots, the `\|\c
|
|
.B \-fdelayed\-branch\c
|
|
\&\|' option is turned on. For those machines that can support debugging even
|
|
without a frame pointer, the `\|\c
|
|
.B \-fomit\-frame\-pointer\c
|
|
\&\|' option is turned on. On some machines other flags may also be turned on.
|
|
.TP
|
|
.B \-O2
|
|
Optimize even more. Nearly all supported optimizations that do not
|
|
involve a space-speed tradeoff are performed. Loop unrolling and function
|
|
inlining are not done, for example. As compared to
|
|
.B \-O\c
|
|
\&,
|
|
this option increases both compilation time and the performance of the
|
|
generated code.
|
|
.TP
|
|
.B \-O3
|
|
Optimize yet more. This turns on everything
|
|
.B \-O2
|
|
does, along with also turning on
|
|
.B \-finline\-functions.
|
|
.TP
|
|
.B \-Os
|
|
Optimize for size. This enables all
|
|
.B \-O2
|
|
optimizations that do not typically increase code size. It also performs
|
|
further optimizations designed to reduce code size.
|
|
.TP
|
|
.B \-O0
|
|
Do not optimize.
|
|
.Sp
|
|
If you use multiple
|
|
.B \-O
|
|
options, with or without level numbers, the last such option is the
|
|
one that is effective.
|
|
.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.
|
|
.Sp
|
|
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
|
|
Use heuristics to compile faster (C++ only). These heuristics are not
|
|
enabled by default, since they are only effective for certain input
|
|
files. Other input files compile more slowly.
|
|
.Sp
|
|
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
|
|
\& cout << "This " << p << " has " << n << " legs.\en";
|
|
.Sp
|
|
makes six passes through all three steps. By using a software cache,
|
|
a \*(lqhit\*(rq 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.
|
|
.Sp
|
|
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
|
|
Don't make member functions inline by default merely because they are
|
|
defined inside the class scope (C++ only).
|
|
.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
|
|
\&.
|
|
.Sp
|
|
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\-functions
|
|
Integrate all simple functions into their callers. The compiler
|
|
heuristically decides which functions are simple enough to be worth
|
|
integrating in this way.
|
|
.Sp
|
|
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
|
|
function calls, by emitting extra instructions to save and restore the
|
|
registers around such calls. Such allocation is done only when it
|
|
seems to result in better code than would otherwise be produced.
|
|
.Sp
|
|
This option is enabled by default on certain machines, usually those
|
|
which have no call-preserved registers to use instead.
|
|
.TP
|
|
.B \-fkeep\-inline\-functions
|
|
Even if all calls to a given function are integrated, and the function
|
|
is declared \c
|
|
.B static\c
|
|
\&, nevertheless output a separate run-time
|
|
callable version of the function.
|
|
.TP
|
|
.B \-fno\-function\-cse
|
|
Do not put function addresses in registers; make each instruction that
|
|
calls a constant function contain the function's address explicitly.
|
|
.Sp
|
|
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.
|
|
.TP
|
|
.B \-fno\-peephole
|
|
Disable any machine-specific peephole optimizations.
|
|
.TP
|
|
.B \-ffast-math
|
|
This option allows GCC to violate some ANSI or IEEE rules/specifications
|
|
in the interest of optimizing code for speed. For example, it allows
|
|
the compiler to assume arguments to the \c
|
|
.B sqrt\c
|
|
\& function are
|
|
non-negative numbers.
|
|
.Sp
|
|
This option should never be turned on by any `\|\c
|
|
.B \-O\c
|
|
\&\|' option since
|
|
it can result in incorrect output for programs which depend on
|
|
an exact implementation of IEEE or ANSI rules/specifications for
|
|
math functions.
|
|
.PP
|
|
The following options control specific optimizations. The `\|\c
|
|
.B \-O2\c
|
|
\&\|'
|
|
option turns on all of these optimizations except `\|\c
|
|
.B \-funroll\-loops\c
|
|
\&\|'
|
|
and `\|\c
|
|
.B \-funroll\-all\-loops\c
|
|
\&\|'.
|
|
.PP
|
|
The `\|\c
|
|
.B \-O\c
|
|
\&\|' option usually turns on
|
|
the `\|\c
|
|
.B \-fthread\-jumps\c
|
|
\&\|' and `\|\c
|
|
.B \-fdelayed\-branch\c
|
|
\&\|' options, but
|
|
specific machines may change the default optimizations.
|
|
.PP
|
|
You can use the following flags in the rare cases when \*(lqfine-tuning\*(rq
|
|
of optimizations to be performed is desired.
|
|
.TP
|
|
.B \-fstrength\-reduce
|
|
Perform the optimizations of loop strength reduction and
|
|
elimination of iteration variables.
|
|
.TP
|
|
.B \-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 following it, depending on whether
|
|
the condition is known to be true or false.
|
|
.TP
|
|
.B \-funroll\-loops
|
|
Perform the optimization of loop unrolling. This is only done for loops
|
|
whose number of iterations can be determined at compile time or run time.
|
|
.TP
|
|
.B \-funroll\-all\-loops
|
|
Perform the optimization of loop unrolling. This is done for all loops.
|
|
This usually makes programs run more slowly.
|
|
.TP
|
|
.B \-fcse\-follow\-jumps
|
|
In common subexpression elimination, scan through jump instructions
|
|
when the target of the jump is not reached by any other path. For
|
|
example, when CSE encounters an \c
|
|
.B if\c
|
|
\& statement with an
|
|
.B else\c
|
|
\& clause, CSE will follow the jump when the condition
|
|
tested is false.
|
|
.TP
|
|
.B \-fcse\-skip\-blocks
|
|
This is similar to `\|\c
|
|
.B \-fcse\-follow\-jumps\c
|
|
\&\|', but causes CSE to
|
|
follow jumps which conditionally skip over blocks. When CSE
|
|
encounters a simple \c
|
|
.B if\c
|
|
\& statement with no else clause,
|
|
`\|\c
|
|
.B \-fcse\-skip\-blocks\c
|
|
\&\|' causes CSE to follow the jump around the
|
|
body of the \c
|
|
.B if\c
|
|
\&.
|
|
.TP
|
|
.B \-frerun\-cse\-after\-loop
|
|
Re-run common subexpression elimination after loop optimizations has been
|
|
performed.
|
|
.TP
|
|
.B \-felide\-constructors
|
|
Elide constructors when this seems plausible (C++ only). With this
|
|
flag, GNU C++ initializes \c
|
|
.B y\c
|
|
\& directly from the call to \c
|
|
.B foo
|
|
without going through a temporary in the following code:
|
|
.Sp
|
|
A foo ();
|
|
A y = foo ();
|
|
.Sp
|
|
Without this option, GNU C++ first initializes \c
|
|
.B y\c
|
|
\& by calling the
|
|
appropriate constructor for type \c
|
|
.B A\c
|
|
\&; then assigns the result of
|
|
.B foo\c
|
|
\& to a temporary; and, finally, replaces the initial value of
|
|
`\|\c
|
|
.B y\c
|
|
\&\|' with the temporary.
|
|
.Sp
|
|
The default behavior (`\|\c
|
|
.B \-fno\-elide\-constructors\c
|
|
\&\|') is specified by
|
|
the draft ANSI C++ standard. If your program's constructors have side
|
|
effects, using `\|\c
|
|
.B \-felide-constructors\c
|
|
\&\|' can make your program act
|
|
differently, since some constructor calls may be omitted.
|
|
.TP
|
|
.B \-fexpensive\-optimizations
|
|
Perform a number of minor optimizations that are relatively expensive.
|
|
.TP
|
|
.B \-fdelayed\-branch
|
|
If supported for the target machine, attempt to reorder instructions
|
|
to exploit instruction slots available after delayed branch
|
|
instructions.
|
|
.TP
|
|
.B \-fschedule\-insns
|
|
If supported for the target machine, attempt to reorder instructions to
|
|
eliminate execution stalls due to required data being unavailable. This
|
|
helps machines that have slow floating point or memory load instructions
|
|
by allowing other instructions to be issued until the result of the load
|
|
or floating point instruction is required.
|
|
.TP
|
|
.B \-fschedule\-insns2
|
|
Similar to `\|\c
|
|
.B \-fschedule\-insns\c
|
|
\&\|', 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.
|
|
.SH 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
|
|
`\|\c
|
|
.B \-b\c
|
|
\&\|' option.
|
|
.PP
|
|
In addition, older and newer versions of GNU CC can be installed side
|
|
by side. One of them (probably the newest) will be the default, but
|
|
you may sometimes wish to use another.
|
|
.TP
|
|
.BI "\-b " "machine"
|
|
The argument \c
|
|
.I machine\c
|
|
\& specifies the target machine for compilation.
|
|
This is useful when you have installed GNU CC as a cross-compiler.
|
|
.Sp
|
|
The value to use for \c
|
|
.I machine\c
|
|
\& 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 `\|\c
|
|
.B configure
|
|
i386v\c
|
|
\&\|', meaning to compile for an 80386 running System V, then you
|
|
would specify `\|\c
|
|
.B \-b i386v\c
|
|
\&\|' to run that cross compiler.
|
|
.Sp
|
|
When you do not specify `\|\c
|
|
.B \-b\c
|
|
\&\|', it normally means to compile for
|
|
the same type of machine that you are using.
|
|
.TP
|
|
.BI "\-V " "version"
|
|
The argument \c
|
|
.I version\c
|
|
\& specifies which version of GNU CC to run.
|
|
This is useful when multiple versions are installed. For example,
|
|
.I version\c
|
|
\& might be `\|\c
|
|
.B 2.0\c
|
|
\&\|', meaning to run GNU CC version 2.0.
|
|
.Sp
|
|
The default version, when you do not specify `\|\c
|
|
.B \-V\c
|
|
\&\|', is controlled
|
|
by the way GNU CC is installed. Normally, it will be a version that
|
|
is recommended for general use.
|
|
.SH MACHINE DEPENDENT OPTIONS
|
|
Each of the target machine types can have its own special options,
|
|
starting with `\|\c
|
|
.B \-m\c
|
|
\&\|', to choose among various hardware models or
|
|
configurations\(em\&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.
|
|
.PP
|
|
Some configurations of the compiler also support additional special
|
|
options, usually for command-line compatibility with other compilers on
|
|
the same platform.
|
|
.PP
|
|
These are the `\|\c
|
|
.B \-m\c
|
|
\&\|' options defined for the 68000 series:
|
|
.TP
|
|
.B \-m68000
|
|
.TP
|
|
.B \-mc68000
|
|
Generate output for a 68000. This is the default when the compiler is
|
|
configured for 68000-based systems.
|
|
.TP
|
|
.B \-m68020
|
|
.TP
|
|
.B \-mc68020
|
|
Generate output for a 68020 (rather than a 68000). This is the
|
|
default when the compiler is configured for 68020-based systems.
|
|
.TP
|
|
.B \-m68881
|
|
Generate output containing 68881 instructions for floating point.
|
|
This is the default for most 68020-based systems unless
|
|
.B \-nfp
|
|
was specified when the compiler was configured.
|
|
.TP
|
|
.B \-m68030
|
|
Generate output for a 68030. This is the default when the compiler is
|
|
configured for 68030-based systems.
|
|
.TP
|
|
.B \-m68040
|
|
Generate output for a 68040. This is the default when the compiler is
|
|
configured for 68040-based systems.
|
|
.TP
|
|
.B \-m68020\-40
|
|
Generate output for a 68040, without using any of the new instructions.
|
|
This results in code which can run relatively efficiently on either a
|
|
68020/68881 or a 68030 or a 68040.
|
|
.TP
|
|
.B \-mfpa
|
|
Generate output containing Sun FPA instructions for floating point.
|
|
.TP
|
|
.B \-msoft\-float
|
|
Generate output containing library calls for floating point.
|
|
.I
|
|
WARNING:
|
|
the requisite libraries are not part of GNU CC. Normally 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 library functions for cross-compilation.
|
|
.TP
|
|
.B \-mshort
|
|
Consider type \c
|
|
.B int\c
|
|
\& to be 16 bits wide, like \c
|
|
.B short int\c
|
|
\&.
|
|
.TP
|
|
.B \-mnobitfield
|
|
Do not use the bit-field instructions. `\|\c
|
|
.B \-m68000\c
|
|
\&\|' implies
|
|
`\|\c
|
|
.B \-mnobitfield\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-mbitfield
|
|
Do use the bit-field instructions. `\|\c
|
|
.B \-m68020\c
|
|
\&\|' implies
|
|
`\|\c
|
|
.B \-mbitfield\c
|
|
\&\|'. This is the default if you use the unmodified
|
|
sources.
|
|
.TP
|
|
.B \-mrtd
|
|
Use a different function-calling convention, in which functions
|
|
that take a fixed number of arguments return with the \c
|
|
.B 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.
|
|
.Sp
|
|
This calling convention is incompatible with the one normally
|
|
used on Unix, so you cannot use it if you need to call libraries
|
|
compiled with the Unix compiler.
|
|
.Sp
|
|
Also, you must provide function prototypes for all functions that
|
|
take variable numbers of arguments (including \c
|
|
.B printf\c
|
|
\&);
|
|
otherwise incorrect code will be generated for calls to those
|
|
functions.
|
|
.Sp
|
|
In addition, seriously incorrect code will result if you call a
|
|
function with too many arguments. (Normally, extra arguments are
|
|
harmlessly ignored.)
|
|
.Sp
|
|
The \c
|
|
.B rtd\c
|
|
\& instruction is supported by the 68010 and 68020
|
|
processors, but not by the 68000.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the Vax:
|
|
.TP
|
|
.B \-munix
|
|
Do not output certain jump instructions (\c
|
|
.B aobleq\c
|
|
\& and so on)
|
|
that the Unix assembler for the Vax cannot handle across long
|
|
ranges.
|
|
.TP
|
|
.B \-mgnu
|
|
Do output those jump instructions, on the assumption that you
|
|
will assemble with the GNU assembler.
|
|
.TP
|
|
.B \-mg
|
|
Output code for g-format floating point numbers instead of d-format.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' switches are supported on the SPARC:
|
|
.PP
|
|
.B \-mfpu
|
|
.TP
|
|
.B \-mhard\-float
|
|
Generate output containing floating point instructions. This is the
|
|
default.
|
|
.PP
|
|
.B \-mno\-fpu
|
|
.TP
|
|
.B \-msoft\-float
|
|
Generate output containing library calls for floating point.
|
|
.I Warning:
|
|
there is no GNU floating-point library for SPARC.
|
|
Normally the facilities of the machine's usual C compiler are used, but
|
|
this cannot be done directly in cross-compilation. You must make your
|
|
own arrangements to provide suitable library functions for
|
|
cross-compilation.
|
|
.Sp
|
|
.B \-msoft\-float
|
|
changes the calling convention in the output file;
|
|
therefore, it is only useful if you compile
|
|
.I all
|
|
of a program with this option.
|
|
.PP
|
|
.B \-mno\-epilogue
|
|
.TP
|
|
.B \-mepilogue
|
|
With
|
|
.B \-mepilogue
|
|
(the default), the compiler always emits code for
|
|
function exit at the end of each function. Any function exit in
|
|
the middle of the function (such as a return statement in C) will
|
|
generate a jump to the exit code at the end of the function.
|
|
.Sp
|
|
With
|
|
.BR \-mno\-epilogue ,
|
|
the compiler tries to emit exit code inline at every function exit.
|
|
.PP
|
|
.B \-mno\-v8
|
|
.TP
|
|
.B \-mv8
|
|
.TP
|
|
.B \-msparclite
|
|
These three options select variations on the SPARC architecture.
|
|
.Sp
|
|
By default (unless specifically configured for the Fujitsu SPARClite),
|
|
GCC generates code for the v7 variant of the SPARC architecture.
|
|
.Sp
|
|
.B \-mv8
|
|
will give you SPARC v8 code. The only difference from v7
|
|
code is that the compiler emits the integer multiply and integer
|
|
divide instructions which exist in SPARC v8 but not in SPARC v7.
|
|
.Sp
|
|
.B \-msparclite
|
|
will give you SPARClite code. This adds the integer
|
|
multiply, integer divide step and scan (ffs) instructions which
|
|
exist in SPARClite but not in SPARC v7.
|
|
.PP
|
|
.B \-mcypress
|
|
.TP
|
|
.B \-msupersparc
|
|
These two options select the processor for which the code is optimized.
|
|
.Sp
|
|
With
|
|
.B \-mcypress
|
|
(the default), the compiler optimizes code for the Cypress CY7C602 chip, as
|
|
used in the SparcStation/SparcServer 3xx series. This is also appropriate for
|
|
the older SparcStation 1, 2, IPX etc.
|
|
.Sp
|
|
With
|
|
.B \-msupersparc
|
|
the compiler optimizes code for the SuperSparc cpu, as used in the SparcStation
|
|
10, 1000 and 2000 series. This flag also enables use of the full SPARC v8
|
|
instruction set.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the Convex:
|
|
.TP
|
|
.B \-mc1
|
|
Generate output for a C1. This is the default when the compiler is
|
|
configured for a C1.
|
|
.TP
|
|
.B \-mc2
|
|
Generate output for a C2. This is the default when the compiler is
|
|
configured for a C2.
|
|
.TP
|
|
.B \-margcount
|
|
Generate code which puts an argument count in the word preceding each
|
|
argument list. Some nonportable Convex and Vax programs need this word.
|
|
(Debuggers don't, except for functions with variable-length argument
|
|
lists; this info is in the symbol table.)
|
|
.TP
|
|
.B \-mnoargcount
|
|
Omit the argument count word. This is the default if you use the
|
|
unmodified sources.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the AMD Am29000:
|
|
.TP
|
|
.B \-mdw
|
|
Generate code that assumes the DW bit is set, i.e., that byte and
|
|
halfword operations are directly supported by the hardware. This is the
|
|
default.
|
|
.TP
|
|
.B \-mnodw
|
|
Generate code that assumes the DW bit is not set.
|
|
.TP
|
|
.B \-mbw
|
|
Generate code that assumes the system supports byte and halfword write
|
|
operations. This is the default.
|
|
.TP
|
|
.B \-mnbw
|
|
Generate code that assumes the systems does not support byte and
|
|
halfword write operations. This implies `\|\c
|
|
.B \-mnodw\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-msmall
|
|
Use a small memory model that assumes that all function addresses are
|
|
either within a single 256 KB segment or at an absolute address of less
|
|
than 256K. This allows the \c
|
|
.B call\c
|
|
\& instruction to be used instead
|
|
of a \c
|
|
.B const\c
|
|
\&, \c
|
|
.B consth\c
|
|
\&, \c
|
|
.B calli\c
|
|
\& sequence.
|
|
.TP
|
|
.B \-mlarge
|
|
Do not assume that the \c
|
|
.B call\c
|
|
\& instruction can be used; this is the
|
|
default.
|
|
.TP
|
|
.B \-m29050
|
|
Generate code for the Am29050.
|
|
.TP
|
|
.B \-m29000
|
|
Generate code for the Am29000. This is the default.
|
|
.TP
|
|
.B \-mkernel\-registers
|
|
Generate references to registers \c
|
|
.B gr64-gr95\c
|
|
\& instead of
|
|
.B gr96-gr127\c
|
|
\&. This option can be used when compiling kernel code
|
|
that wants a set of global registers disjoint from that used by
|
|
user-mode code.
|
|
.Sp
|
|
Note that when this option is used, register names in `\|\c
|
|
.B \-f\c
|
|
\&\|' flags
|
|
must use the normal, user-mode, names.
|
|
.TP
|
|
.B \-muser\-registers
|
|
Use the normal set of global registers, \c
|
|
.B gr96-gr127\c
|
|
\&. This is the
|
|
default.
|
|
.TP
|
|
.B \-mstack\-check
|
|
Insert a call to \c
|
|
.B _\|_msp_check\c
|
|
\& after each stack adjustment. This
|
|
is often used for kernel code.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for Motorola 88K architectures:
|
|
.TP
|
|
.B \-m88000
|
|
Generate code that works well on both the m88100 and the
|
|
m88110.
|
|
.TP
|
|
.B \-m88100
|
|
Generate code that works best for the m88100, but that also
|
|
runs on the m88110.
|
|
.TP
|
|
.B \-m88110
|
|
Generate code that works best for the m88110, and may not run
|
|
on the m88100.
|
|
.TP
|
|
.B \-midentify\-revision
|
|
Include an \c
|
|
.B ident\c
|
|
\& directive in the assembler output recording the
|
|
source file name, compiler name and version, timestamp, and compilation
|
|
flags used.
|
|
.TP
|
|
.B \-mno\-underscores
|
|
In assembler output, emit symbol names without adding an underscore
|
|
character at the beginning of each name. The default is to use an
|
|
underscore as prefix on each name.
|
|
.TP
|
|
.B \-mno\-check\-zero\-division
|
|
.TP
|
|
.B \-mcheck\-zero\-division
|
|
Early models of the 88K architecture had problems with division by zero;
|
|
in particular, many of them didn't trap. Use these options to avoid
|
|
including (or to include explicitly) additional code to detect division
|
|
by zero and signal an exception. All GCC configurations for the 88K use
|
|
`\|\c
|
|
.B \-mcheck\-zero\-division\c
|
|
\&\|' by default.
|
|
.TP
|
|
.B \-mocs\-debug\-info
|
|
.TP
|
|
.B \-mno\-ocs\-debug\-info
|
|
Include (or omit) additional debugging information (about
|
|
registers used in each stack frame) as specified in the 88Open Object
|
|
Compatibility Standard, \*(lqOCS\*(rq. This extra information is not needed
|
|
by GDB. The default for DG/UX, SVr4, and Delta 88 SVr3.2 is to
|
|
include this information; other 88k configurations omit this information
|
|
by default.
|
|
.TP
|
|
.B \-mocs\-frame\-position
|
|
.TP
|
|
.B \-mno\-ocs\-frame\-position
|
|
Force (or do not require) register values to be stored in a particular
|
|
place in stack frames, as specified in OCS. The DG/UX, Delta88 SVr3.2,
|
|
and BCS configurations use `\|\c
|
|
.B \-mocs\-frame\-position\c
|
|
\&\|'; other 88k
|
|
configurations have the default `\|\c
|
|
.B \-mno\-ocs\-frame\-position\c
|
|
\&\|'.
|
|
.TP
|
|
.B \-moptimize\-arg\-area
|
|
.TP
|
|
.B \-mno\-optimize\-arg\-area
|
|
Control how to store function arguments in stack frames.
|
|
`\|\c
|
|
.B \-moptimize\-arg\-area\c
|
|
\&\|' saves space, but may break some
|
|
debuggers (not GDB). `\|\c
|
|
.B \-mno\-optimize\-arg\-area\c
|
|
\&\|' conforms better to
|
|
standards. By default GCC does not optimize the argument area.
|
|
.TP
|
|
.BI "\-mshort\-data\-" "num"
|
|
.I num
|
|
Generate smaller data references by making them relative to \c
|
|
.B r0\c
|
|
\&,
|
|
which allows loading a value using a single instruction (rather than the
|
|
usual two). You control which data references are affected by
|
|
specifying \c
|
|
.I num\c
|
|
\& with this option. For example, if you specify
|
|
`\|\c
|
|
.B \-mshort\-data\-512\c
|
|
\&\|', then the data references affected are those
|
|
involving displacements of less than 512 bytes.
|
|
`\|\c
|
|
.B \-mshort\-data\-\c
|
|
.I num\c
|
|
\&\c
|
|
\&\|' is not effective for \c
|
|
.I num\c
|
|
\& greater
|
|
than 64K.
|
|
.PP
|
|
.B \-mserialize-volatile
|
|
.TP
|
|
.B \-mno-serialize-volatile
|
|
Do, or do not, generate code to guarantee sequential consistency of
|
|
volatile memory references.
|
|
.Sp
|
|
GNU CC always guarantees consistency by default, for the preferred
|
|
processor submodel. How this is done depends on the submodel.
|
|
.Sp
|
|
The m88100 processor does not reorder memory references and so always
|
|
provides sequential consistency. If you use `\|\c
|
|
.B \-m88100\c
|
|
\&\|', GNU CC does
|
|
not generate any special instructions for sequential consistency.
|
|
.Sp
|
|
The order of memory references made by the m88110 processor does not
|
|
always match the order of the instructions requesting those references.
|
|
In particular, a load instruction may execute before a preceding store
|
|
instruction. Such reordering violates sequential consistency of
|
|
volatile memory references, when there are multiple processors. When
|
|
you use `\|\c
|
|
.B \-m88000\c
|
|
\&\|' or `\|\c
|
|
.B \-m88110\c
|
|
\&\|', GNU CC generates special
|
|
instructions when appropriate, to force execution in the proper order.
|
|
.Sp
|
|
The extra code generated to guarantee consistency may affect the
|
|
performance of your application. If you know that you can safely forgo
|
|
this guarantee, you may use the option `\|\c
|
|
.B \-mno-serialize-volatile\c
|
|
\&\|'.
|
|
.Sp
|
|
If you use the `\|\c
|
|
.B \-m88100\c
|
|
\&\|' option but require sequential consistency
|
|
when running on the m88110 processor, you should use
|
|
`\|\c
|
|
.B \-mserialize-volatile\c
|
|
\&\|'.
|
|
.PP
|
|
.B \-msvr4
|
|
.TP
|
|
.B \-msvr3
|
|
Turn on (`\|\c
|
|
.B \-msvr4\c
|
|
\&\|') or off (`\|\c
|
|
.B \-msvr3\c
|
|
\&\|') compiler extensions
|
|
related to System V release 4 (SVr4). This controls the following:
|
|
.TP
|
|
\ \ \ \(bu
|
|
Which variant of the assembler syntax to emit (which you can select
|
|
independently using `\|\c
|
|
.B \-mversion\-03.00\c
|
|
\&\|').
|
|
.TP
|
|
\ \ \ \(bu
|
|
`\|\c
|
|
.B \-msvr4\c
|
|
\&\|' makes the C preprocessor recognize `\|\c
|
|
.B #pragma weak\c
|
|
\&\|'
|
|
.TP
|
|
\ \ \ \(bu
|
|
`\|\c
|
|
.B \-msvr4\c
|
|
\&\|' makes GCC issue additional declaration directives used in
|
|
SVr4.
|
|
.PP
|
|
`\|\c
|
|
.B \-msvr3\c
|
|
\&\|' is the default for all m88K configurations except
|
|
the SVr4 configuration.
|
|
.TP
|
|
.B \-mtrap\-large\-shift
|
|
.TP
|
|
.B \-mhandle\-large\-shift
|
|
Include code to detect bit-shifts of more than 31 bits; respectively,
|
|
trap such shifts or emit code to handle them properly. By default GCC
|
|
makes no special provision for large bit shifts.
|
|
.TP
|
|
.B \-muse\-div\-instruction
|
|
Very early models of the 88K architecture didn't have a divide
|
|
instruction, so GCC avoids that instruction by default. Use this option
|
|
to specify that it's safe to use the divide instruction.
|
|
.TP
|
|
.B \-mversion\-03.00
|
|
In the DG/UX configuration, there are two flavors of SVr4. This option
|
|
modifies
|
|
.B \-msvr4
|
|
to select whether the hybrid-COFF or real-ELF
|
|
flavor is used. All other configurations ignore this option.
|
|
.TP
|
|
.B \-mwarn\-passed\-structs
|
|
Warn when a function passes a struct as an argument or result.
|
|
Structure-passing conventions have changed during the evolution of the C
|
|
language, and are often the source of portability problems. By default,
|
|
GCC issues no such warning.
|
|
.PP
|
|
These options are defined for the IBM RS6000:
|
|
.PP
|
|
.B \-mfp\-in\-toc
|
|
.TP
|
|
.B \-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 constants there; if the TOC overflows,
|
|
`\|\c
|
|
.B \-mno\-fp\-in\-toc\c
|
|
\&\|' will reduce the size of the TOC, which may avoid
|
|
the overflow.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the IBM RT PC:
|
|
.TP
|
|
.B \-min\-line\-mul
|
|
Use an in-line code sequence for integer multiplies. This is the
|
|
default.
|
|
.TP
|
|
.B \-mcall\-lib\-mul
|
|
Call \c
|
|
.B lmul$$\c
|
|
\& for integer multiples.
|
|
.TP
|
|
.B \-mfull\-fp\-blocks
|
|
Generate full-size floating point data blocks, including the minimum
|
|
amount of scratch space recommended by IBM. This is the default.
|
|
.TP
|
|
.B \-mminimum\-fp\-blocks
|
|
Do not include extra scratch space in floating point data blocks. This
|
|
results in smaller code, but slower execution, since scratch space must
|
|
be allocated dynamically.
|
|
.TP
|
|
.B \-mfp\-arg\-in\-fpregs
|
|
Use a calling sequence incompatible with the IBM calling convention in
|
|
which floating point arguments are passed in floating point registers.
|
|
Note that \c
|
|
.B varargs.h\c
|
|
\& and \c
|
|
.B stdargs.h\c
|
|
\& will not work with
|
|
floating point operands if this option is specified.
|
|
.TP
|
|
.B \-mfp\-arg\-in\-gregs
|
|
Use the normal calling convention for floating point arguments. This is
|
|
the default.
|
|
.TP
|
|
.B \-mhc\-struct\-return
|
|
Return structures of more than one word in memory, rather than in a
|
|
register. This provides compatibility with the MetaWare HighC (hc)
|
|
compiler. Use `\|\c
|
|
.B \-fpcc\-struct\-return\c
|
|
\&\|' for compatibility with the
|
|
Portable C Compiler (pcc).
|
|
.TP
|
|
.B \-mnohc\-struct\-return
|
|
Return some structures of more than one word in registers, when
|
|
convenient. This is the default. For compatibility with the
|
|
IBM-supplied compilers, use either `\|\c
|
|
.B \-fpcc\-struct\-return\c
|
|
\&\|' or
|
|
`\|\c
|
|
.B \-mhc\-struct\-return\c
|
|
\&\|'.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the MIPS family of computers:
|
|
.TP
|
|
.BI "\-mcpu=" "cpu-type"
|
|
Assume the defaults for the machine type
|
|
.I cpu-type
|
|
when
|
|
scheduling instructions. The default
|
|
.I cpu-type
|
|
is
|
|
.BR default ,
|
|
which picks the longest cycles times for any of the machines, in order
|
|
that the code run at reasonable rates on all MIPS cpu's. Other
|
|
choices for
|
|
.I cpu-type
|
|
are
|
|
.BR r2000 ,
|
|
.BR r3000 ,
|
|
.BR r4000 ,
|
|
and
|
|
.BR r6000 .
|
|
While picking a specific
|
|
.I cpu-type
|
|
will schedule things appropriately for that particular chip, the
|
|
compiler will not generate any code that does not meet level 1 of the
|
|
MIPS ISA (instruction set architecture) without the
|
|
.B \-mips2
|
|
or
|
|
.B \-mips3
|
|
switches being used.
|
|
.TP
|
|
.B \-mips2
|
|
Issue instructions from level 2 of the MIPS ISA (branch likely, square
|
|
root instructions). The
|
|
.B \-mcpu=r4000
|
|
or
|
|
.B \-mcpu=r6000
|
|
switch must be used in conjunction with
|
|
.BR \-mips2 .
|
|
.TP
|
|
.B \-mips3
|
|
Issue instructions from level 3 of the MIPS ISA (64 bit instructions).
|
|
The
|
|
.B \-mcpu=r4000
|
|
switch must be used in conjunction with
|
|
.BR \-mips2 .
|
|
.TP
|
|
.B \-mint64
|
|
.TP
|
|
.B \-mlong64
|
|
.TP
|
|
.B \-mlonglong128
|
|
These options don't work at present.
|
|
.TP
|
|
.B \-mmips\-as
|
|
Generate code for the MIPS assembler, and invoke
|
|
.B mips\-tfile
|
|
to add normal debug information. This is the default for all
|
|
platforms except for the OSF/1 reference platform, using the OSF/rose
|
|
object format. If any of the
|
|
.BR \-ggdb ,
|
|
.BR \-gstabs ,
|
|
or
|
|
.B \-gstabs+
|
|
switches are used, the
|
|
.B mips\-tfile
|
|
program will encapsulate the stabs within MIPS ECOFF.
|
|
.TP
|
|
.B \-mgas
|
|
Generate code for the GNU assembler. This is the default on the OSF/1
|
|
reference platform, using the OSF/rose object format.
|
|
.TP
|
|
.B \-mrnames
|
|
.TP
|
|
.B \-mno\-rnames
|
|
The
|
|
.B \-mrnames
|
|
switch says to output code using the MIPS software names for the
|
|
registers, instead of the hardware names (ie,
|
|
.B a0
|
|
instead of
|
|
.BR $4 ).
|
|
The GNU assembler does not support the
|
|
.B \-mrnames
|
|
switch, and the MIPS assembler will be instructed to run the MIPS C
|
|
preprocessor over the source file. The
|
|
.B \-mno\-rnames
|
|
switch is default.
|
|
.TP
|
|
.B \-mgpopt
|
|
.TP
|
|
.B \-mno\-gpopt
|
|
The
|
|
.B \-mgpopt
|
|
switch says to write all of the data declarations before the
|
|
instructions in the text section, to all the MIPS assembler to
|
|
generate one word memory references instead of using two words for
|
|
short global or static data items. This is on by default if
|
|
optimization is selected.
|
|
.TP
|
|
.B \-mstats
|
|
.TP
|
|
.B \-mno\-stats
|
|
For each non-inline function processed, the
|
|
.B \-mstats
|
|
switch causes the compiler to emit one line to the standard error file
|
|
to print statistics about the program (number of registers saved,
|
|
stack size, etc.).
|
|
.TP
|
|
.B \-mmemcpy
|
|
.TP
|
|
.B \-mno\-memcpy
|
|
The
|
|
.B \-mmemcpy
|
|
switch makes all block moves call the appropriate string function
|
|
.RB ( memcpy
|
|
or
|
|
.BR bcopy )
|
|
instead of possibly generating inline code.
|
|
.TP
|
|
.B \-mmips\-tfile
|
|
.TP
|
|
.B \-mno\-mips\-tfile
|
|
The
|
|
.B \-mno\-mips\-tfile
|
|
switch causes the compiler not postprocess the object file with the
|
|
.B mips\-tfile
|
|
program, after the MIPS assembler has generated it to add debug
|
|
support. If
|
|
.B mips\-tfile
|
|
is not run, then no local variables will be available to the debugger.
|
|
In addition,
|
|
.B stage2
|
|
and
|
|
.B stage3
|
|
objects will have the temporary file names passed to the assembler
|
|
embedded in the object file, which means the objects will not compare
|
|
the same.
|
|
.TP
|
|
.B \-msoft\-float
|
|
Generate output containing library calls for floating point.
|
|
.I
|
|
WARNING:
|
|
the requisite libraries are not part of GNU CC. Normally 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 library functions for cross-compilation.
|
|
.TP
|
|
.B \-mhard\-float
|
|
Generate output containing floating point instructions. This is the
|
|
default if you use the unmodified sources.
|
|
.TP
|
|
.B \-mfp64
|
|
Assume that the
|
|
.B FR
|
|
bit in the status word is on, and that there are 32 64-bit floating
|
|
point registers, instead of 32 32-bit floating point registers. You
|
|
must also specify the
|
|
.B \-mcpu=r4000
|
|
and
|
|
.B \-mips3
|
|
switches.
|
|
.TP
|
|
.B \-mfp32
|
|
Assume that there are 32 32-bit floating point registers. This is the
|
|
default.
|
|
.PP
|
|
.B \-mabicalls
|
|
.TP
|
|
.B \-mno\-abicalls
|
|
Emit (or do not emit) the
|
|
.BR \&.abicalls ,
|
|
.BR \&.cpload ,
|
|
and
|
|
.B \&.cprestore
|
|
pseudo operations that some System V.4 ports use for position
|
|
independent code.
|
|
.TP
|
|
.B \-mhalf\-pic
|
|
.TP
|
|
.B \-mno\-half\-pic
|
|
The
|
|
.B \-mhalf\-pic
|
|
switch says to put pointers to extern references into the data section
|
|
and load them up, rather than put the references in the text section.
|
|
This option does not work at present.
|
|
.B
|
|
.BI \-G num
|
|
Put global and static items less than or equal to
|
|
.I num
|
|
bytes into the small data or bss sections instead of the normal data
|
|
or bss section. This allows the assembler to emit one word memory
|
|
reference instructions based on the global pointer
|
|
.RB ( gp
|
|
or
|
|
.BR $28 ),
|
|
instead of the normal two words used. By default,
|
|
.I num
|
|
is 8 when the MIPS assembler is used, and 0 when the GNU
|
|
assembler is used. The
|
|
.BI \-G num
|
|
switch is also passed to the assembler and linker. All modules should
|
|
be compiled with the same
|
|
.BI \-G num
|
|
value.
|
|
.TP
|
|
.B \-nocpp
|
|
Tell the MIPS assembler to not run its preprocessor over user
|
|
assembler files (with a `\|\c
|
|
.B .s\c
|
|
\&\|' suffix) when assembling them.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the Intel 80386 family of computers:
|
|
.TP
|
|
.B \-m486
|
|
.TP
|
|
.B \-mno\-486
|
|
Control whether or not code is optimized for a 486 instead of an
|
|
386. Code generated for a 486 will run on a 386 and vice versa.
|
|
.TP
|
|
.B \-mpentium
|
|
Synonym for
|
|
.B \-mcpu=pentium
|
|
.TP
|
|
.B \-mpentiumpro
|
|
Synonym for
|
|
.B \-mcpu=pentiumpro
|
|
.TP
|
|
.B \-mcpu=\fIcpu type\fP
|
|
Assume the defaults for the machine type CPU TYPE when scheduling instructions.
|
|
The choices for CPU TYPE are:
|
|
.B i386,
|
|
.B i486,
|
|
.B i586
|
|
(pentium),
|
|
.B pentium,
|
|
.B i686
|
|
(pentiumpro), and
|
|
.B pentiumpro.
|
|
While picking a specific CPU TYPE will schedule things appropriately for that
|
|
particular chip, the compiler will not generate any code that does not run on
|
|
the i386 without the
|
|
.B \-march=\fIcpu type\fP
|
|
option being used.
|
|
.TP
|
|
.B \-march=\fIcpu type\fP
|
|
Generate instructions for the machine type CPU TYPE. The choices for CPU TYPE
|
|
are:
|
|
.B i386,
|
|
.B i486,
|
|
.B pentium,
|
|
and
|
|
.B pentiumpro.
|
|
Specifying
|
|
.B \-march=\fIcpu type\fP
|
|
implies
|
|
.B \-mcpu=\fIcpu type\fP.
|
|
.TP
|
|
.B \-msoft\-float
|
|
Generate output containing library calls for floating point.
|
|
.I Warning:
|
|
the requisite libraries are not part of GNU CC.
|
|
Normally 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 library functions for
|
|
cross-compilation.
|
|
.Sp
|
|
On machines where a function returns floating point results in the 80387
|
|
register stack, some floating point opcodes may be emitted even if
|
|
`\|\c
|
|
.B \-msoft-float\c
|
|
\&\|' is used.
|
|
.TP
|
|
.B \-mno-fp-ret-in-387
|
|
Do not use the FPU registers for return values of functions.
|
|
.Sp
|
|
The usual calling convention has functions return values of types
|
|
.B float\c
|
|
\& and \c
|
|
.B double\c
|
|
\& in an FPU register, even if there
|
|
is no FPU. The idea is that the operating system should emulate
|
|
an FPU.
|
|
.Sp
|
|
The option `\|\c
|
|
.B \-mno-fp-ret-in-387\c
|
|
\&\|' causes such values to be returned
|
|
in ordinary CPU registers instead.
|
|
.TP
|
|
.B \-mprofiler-epilogue
|
|
.TP
|
|
.B \-mno-profiler-epilogue
|
|
Generate extra code to write profile information for function exits.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the HPPA family of computers:
|
|
.TP
|
|
.B \-mpa-risc-1-0
|
|
Generate code for a PA 1.0 processor.
|
|
.TP
|
|
.B \-mpa-risc-1-1
|
|
Generate code for a PA 1.1 processor.
|
|
.TP
|
|
.B \-mkernel
|
|
Generate code which is suitable for use in kernels. Specifically, avoid
|
|
.B add\c
|
|
\& instructions in which one of the arguments is the DP register;
|
|
generate \c
|
|
.B addil\c
|
|
\& instructions instead. This avoids a rather serious
|
|
bug in the HP-UX linker.
|
|
.TP
|
|
.B \-mshared-libs
|
|
Generate code that can be linked against HP-UX shared libraries. This option
|
|
is not fully function yet, and is not on by default for any PA target. Using
|
|
this option can cause incorrect code to be generated by the compiler.
|
|
.TP
|
|
.B \-mno-shared-libs
|
|
Don't generate code that will be linked against shared libraries. This is
|
|
the default for all PA targets.
|
|
.TP
|
|
.B \-mlong-calls
|
|
Generate code which allows calls to functions greater than 256K away from
|
|
the caller when the caller and callee are in the same source file. Do
|
|
not turn this option on unless code refuses to link with \*(lqbranch out of
|
|
range errors\*('' from the linker.
|
|
.TP
|
|
.B \-mdisable-fpregs
|
|
Prevent floating point registers from being used in any manner. This is
|
|
necessary for compiling kernels which perform lazy context switching of
|
|
floating point registers. If you use this option and attempt to perform
|
|
floating point operations, the compiler will abort.
|
|
.TP
|
|
.B \-mdisable-indexing
|
|
Prevent the compiler from using indexing address modes. This avoids some
|
|
rather obscure problems when compiling MIG generated code under MACH.
|
|
.TP
|
|
.B \-mtrailing-colon
|
|
Add a colon to the end of label definitions (for ELF assemblers).
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the Intel 80960 family of computers:
|
|
.TP
|
|
.BI "\-m" "cpu-type"
|
|
Assume the defaults for the machine type
|
|
.I cpu-type
|
|
for instruction and addressing-mode availability and alignment.
|
|
The default
|
|
.I cpu-type
|
|
is
|
|
.BR kb ;
|
|
other choices are
|
|
.BR ka ,
|
|
.BR mc ,
|
|
.BR ca ,
|
|
.BR cf ,
|
|
.BR sa ,
|
|
and
|
|
.BR sb .
|
|
.TP
|
|
.B \-mnumerics
|
|
.TP
|
|
.B \-msoft\-float
|
|
The
|
|
.B \-mnumerics
|
|
option indicates that the processor does support
|
|
floating-point instructions. The
|
|
.B \-msoft\-float
|
|
option indicates
|
|
that floating-point support should not be assumed.
|
|
.TP
|
|
.B \-mleaf\-procedures
|
|
.TP
|
|
.B \-mno\-leaf\-procedures
|
|
Do (or do not) attempt to alter leaf procedures to be callable with the
|
|
.I bal
|
|
instruction as well as
|
|
.IR call .
|
|
This will result in more
|
|
efficient code for explicit calls when the
|
|
.I bal
|
|
instruction can be
|
|
substituted by the assembler or linker, but less efficient code in other
|
|
cases, such as calls via function pointers, or using a linker that doesn't
|
|
support this optimization.
|
|
.TP
|
|
.B \-mtail\-call
|
|
.TP
|
|
.B \-mno\-tail\-call
|
|
Do (or do not) make additional attempts (beyond those of the
|
|
machine-independent portions of the compiler) to optimize tail-recursive
|
|
calls into branches. You may not want to do this because the detection of
|
|
cases where this is not valid is not totally complete. The default is
|
|
.BR \-mno\-tail\-call .
|
|
.TP
|
|
.B \-mcomplex\-addr
|
|
.TP
|
|
.B \-mno\-complex\-addr
|
|
Assume (or do not assume) that the use of a complex addressing mode is a
|
|
win on this implementation of the i960. Complex addressing modes may not
|
|
be worthwhile on the K-series, but they definitely are on the C-series.
|
|
The default is currently
|
|
.B \-mcomplex\-addr
|
|
for all processors except
|
|
the CB and CC.
|
|
.TP
|
|
.B \-mcode\-align
|
|
.TP
|
|
.B \-mno\-code\-align
|
|
Align code to 8-byte boundaries for faster fetching (or don't bother).
|
|
Currently turned on by default for C-series implementations only.
|
|
.TP
|
|
.B \-mic\-compat
|
|
.TP
|
|
.B \-mic2.0\-compat
|
|
.TP
|
|
.B \-mic3.0\-compat
|
|
Enable compatibility with iC960 v2.0 or v3.0.
|
|
.TP
|
|
.B \-masm\-compat
|
|
.TP
|
|
.B \-mintel\-asm
|
|
Enable compatibility with the iC960 assembler.
|
|
.TP
|
|
.B \-mstrict\-align
|
|
.TP
|
|
.B \-mno\-strict\-align
|
|
Do not permit (do permit) unaligned accesses.
|
|
.TP
|
|
.B \-mold\-align
|
|
Enable structure-alignment compatibility with Intel's gcc release version
|
|
1.3 (based on gcc 1.37). Currently this is buggy in that
|
|
.B #pragma align 1
|
|
is always assumed as well, and cannot be turned off.
|
|
.PP
|
|
These `\|\c
|
|
.B \-m\c
|
|
\&\|' options are defined for the DEC Alpha implementations:
|
|
.TP
|
|
.B \-mno-soft-float
|
|
.TP
|
|
.B \-msoft-float
|
|
Use (do not use) the hardware floating-point instructions for
|
|
floating-point operations. When \c
|
|
.B \-msoft-float\c
|
|
\& is specified,
|
|
functions in `\|\c
|
|
.B libgcc1.c\c
|
|
\&\|' will be used to perform floating-point
|
|
operations. Unless they are replaced by routines that emulate the
|
|
floating-point operations, or compiled in such a way as to call such
|
|
emulations routines, these routines will issue floating-point
|
|
operations. If you are compiling for an Alpha without floating-point
|
|
operations, you must ensure that the library is built so as not to call
|
|
them.
|
|
.Sp
|
|
Note that Alpha implementations without floating-point operations are
|
|
required to have floating-point registers.
|
|
.TP
|
|
.B \-mfp-reg
|
|
.TP
|
|
.B \-mno-fp-regs
|
|
Generate code that uses (does not use) the floating-point register set.
|
|
.B \-mno-fp-regs\c
|
|
\& implies \c
|
|
.B \-msoft-float\c
|
|
\&. If the floating-point
|
|
register set is not used, floating point operands are passed in integer
|
|
registers as if they were integers and floating-point results are passed
|
|
in $0 instead of $f0. This is a non-standard calling sequence, so any
|
|
function with a floating-point argument or return value called by code
|
|
compiled with \c
|
|
.B \-mno-fp-regs\c
|
|
\& must also be compiled with that
|
|
option.
|
|
.Sp
|
|
A typical use of this option is building a kernel that does not use,
|
|
and hence need not save and restore, any floating-point registers.
|
|
.PP
|
|
These additional options are available on System V Release 4 for
|
|
compatibility with other compilers on those systems:
|
|
.TP
|
|
.B \-G
|
|
On SVr4 systems, \c
|
|
.B gcc\c
|
|
\& accepts the option `\|\c
|
|
.B \-G\c
|
|
\&\|' (and passes
|
|
it to the system linker), for compatibility with other compilers.
|
|
However, we suggest you use `\|\c
|
|
.B \-symbolic\c
|
|
\&\|' or `\|\c
|
|
.B \-shared\c
|
|
\&\|' as
|
|
appropriate, instead of supplying linker options on the \c
|
|
.B gcc
|
|
command line.
|
|
.TP
|
|
.B \-Qy
|
|
Identify the versions of each tool used by the compiler, in a
|
|
.B .ident\c
|
|
\& assembler directive in the output.
|
|
.TP
|
|
.B \-Qn
|
|
Refrain from adding \c
|
|
.B .ident\c
|
|
\& directives to the output file (this is
|
|
the default).
|
|
.TP
|
|
.BI "\-YP," "dirs"
|
|
Search the directories \c
|
|
.I dirs\c
|
|
\&, and no others, for libraries
|
|
specified with `\|\c
|
|
.B \-l\c
|
|
\&\|'. You can separate directory entries in
|
|
.I dirs\c
|
|
\& from one another with colons.
|
|
.TP
|
|
.BI "\-Ym," "dir"
|
|
Look in the directory \c
|
|
.I dir\c
|
|
\& to find the M4 preprocessor.
|
|
The assembler uses this option.
|
|
.SH CODE GENERATION OPTIONS
|
|
These machine-independent options control the interface conventions
|
|
used in code generation.
|
|
.PP
|
|
Most of them begin with `\|\c
|
|
\-f\c
|
|
\&\|'. These options have both positive and negative forms; the negative form
|
|
of `\|\c
|
|
.B \-ffoo\c
|
|
\&\|' would be `\|\c
|
|
.B \-fno\-foo\c
|
|
\&\|'. In the table below, only
|
|
one of the forms is listed\(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 \-fnonnull\-objects
|
|
Assume that objects reached through references are not null
|
|
(C++ only).
|
|
.Sp
|
|
Normally, GNU C++ makes conservative assumptions about objects reached
|
|
through references. For example, the compiler must check that \c
|
|
.B a
|
|
is not null in code like the following:
|
|
.Sp
|
|
obj &a = g ();
|
|
a.f (2);
|
|
.Sp
|
|
Checking that references of this sort have non-null values requires
|
|
extra code, however, and it is unnecessary for many programs. You can
|
|
use `\|\c
|
|
.B \-fnonnull-objects\c
|
|
\&\|' to omit the checks for null, if your
|
|
program doesn't require checking.
|
|
.TP
|
|
.B \-fpcc\-struct\-return
|
|
Use the same convention for returning \c
|
|
.B struct\c
|
|
\& and \c
|
|
.B 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.
|
|
.TP
|
|
.B \-freg\-struct\-return
|
|
Use the convention that
|
|
.B struct
|
|
and
|
|
.B union
|
|
values are returned in registers when possible. This is more
|
|
efficient for small structures than
|
|
.BR \-fpcc\-struct\-return .
|
|
.Sp
|
|
If you specify neither
|
|
.B \-fpcc\-struct\-return
|
|
nor
|
|
.BR \-freg\-struct\-return ,
|
|
GNU CC defaults to whichever convention is standard for the target.
|
|
If there is no standard convention, GNU CC defaults to
|
|
.BR \-fpcc\-struct\-return .
|
|
.TP
|
|
.B \-fshort\-enums
|
|
Allocate to an \c
|
|
.B enum\c
|
|
\& type only as many bytes as it needs for the
|
|
declared range of possible values. Specifically, the \c
|
|
.B enum\c
|
|
\& type
|
|
will be equivalent to the smallest integer type which has enough room.
|
|
.TP
|
|
.B \-fshort\-double
|
|
Use the same size for
|
|
.B double
|
|
as for
|
|
.B float
|
|
\&.
|
|
.TP
|
|
.B \-fshared\-data
|
|
Requests that the data and non-\c
|
|
.B const\c
|
|
\& variables of this
|
|
compilation be shared data rather than private data. The distinction
|
|
makes sense only on certain operating systems, where shared data is
|
|
shared between processes running the same program, while private data
|
|
exists in one copy per process.
|
|
.TP
|
|
.B \-fno\-common
|
|
Allocate even uninitialized global variables in the bss section of the
|
|
object file, rather than generating them as common blocks. This has the
|
|
effect that if the same variable is declared (without \c
|
|
.B extern\c
|
|
\&) 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.
|
|
.TP
|
|
.B \-fno\-ident
|
|
Ignore the `\|\c
|
|
.B #ident\c
|
|
\&\|' directive.
|
|
.TP
|
|
.B \-fno\-gnu\-linker
|
|
Do not output global initializations (such as C++ constructors and
|
|
destructors) in the form used by the GNU linker (on systems where the GNU
|
|
linker is the standard method of handling them). Use this option when
|
|
you want to use a non-GNU linker, which also requires using the
|
|
.B collect2\c
|
|
\& program to make sure the system linker includes
|
|
constructors and destructors. (\c
|
|
.B collect2\c
|
|
\& is included in the GNU CC
|
|
distribution.) For systems which \c
|
|
.I must\c
|
|
\& use \c
|
|
.B collect2\c
|
|
\&, the
|
|
compiler driver \c
|
|
.B gcc\c
|
|
\& is configured to do this automatically.
|
|
.TP
|
|
.B \-finhibit-size-directive
|
|
Don't output a \c
|
|
.B .size\c
|
|
\& assembler directive, or anything else that
|
|
would cause trouble if the function is split in the middle, and the
|
|
two halves are placed at locations far apart in memory. This option is
|
|
used when compiling `\|\c
|
|
.B crtstuff.c\c
|
|
\&\|'; you should not need to use it
|
|
for anything else.
|
|
.TP
|
|
.B \-fverbose-asm
|
|
Put extra commentary information in the generated assembly code to
|
|
make it more readable. This option is generally only of use to those
|
|
who actually need to read the generated assembly code (perhaps while
|
|
debugging the compiler itself).
|
|
.TP
|
|
.B \-fvolatile
|
|
Consider all memory references through pointers to be volatile.
|
|
.TP
|
|
.B \-fvolatile\-global
|
|
Consider all memory references to extern and global data items to
|
|
be volatile.
|
|
.TP
|
|
.B \-fpic
|
|
If supported for the target machines, generate position-independent code,
|
|
suitable for use in a shared library.
|
|
.TP
|
|
.B \-fPIC
|
|
If supported for the target machine, emit position-independent code,
|
|
suitable for dynamic linking, even if branches need large displacements.
|
|
.TP
|
|
.BI "\-ffixed\-" "reg"
|
|
Treat the register named \c
|
|
.I reg\c
|
|
\& 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).
|
|
.Sp
|
|
.I reg\c
|
|
\& must be the name of a register. The register names accepted
|
|
are machine-specific and are defined in the \c
|
|
.B REGISTER_NAMES
|
|
macro in the machine description macro file.
|
|
.Sp
|
|
This flag does not have a negative form, because it specifies a
|
|
three-way choice.
|
|
.TP
|
|
.BI "\-fcall\-used\-" "reg"
|
|
Treat the register named \c
|
|
.I reg\c
|
|
\& as an allocable register that is
|
|
clobbered by function calls. It may be allocated for temporaries or
|
|
variables that do not live across a call. Functions compiled this way
|
|
will not save and restore the register \c
|
|
.I reg\c
|
|
\&.
|
|
.Sp
|
|
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.
|
|
.Sp
|
|
This flag does not have a negative form, because it specifies a
|
|
three-way choice.
|
|
.TP
|
|
.BI "\-fcall\-saved\-" "reg"
|
|
Treat the register named \c
|
|
.I reg\c
|
|
\& as an allocable 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 \c
|
|
.I reg\c
|
|
\& if they use it.
|
|
.Sp
|
|
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.
|
|
.Sp
|
|
A different sort of disaster will result from the use of this flag for
|
|
a register in which function values may be returned.
|
|
.Sp
|
|
This flag does not have a negative form, because it specifies a
|
|
three-way choice.
|
|
.SH PRAGMAS
|
|
Two `\|\c
|
|
.B #pragma\c
|
|
\&\|' 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.
|
|
.TP
|
|
.B #pragma interface
|
|
(C++ only.)
|
|
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
|
|
.B #pragma interface\c
|
|
\&\|' is included in a compilation, this auxiliary information
|
|
will not be generated (unless the main input source file itself uses
|
|
`\|\c
|
|
.B #pragma implementation\c
|
|
\&\|'). Instead, the object files will contain references to be
|
|
resolved at link time.
|
|
.TP
|
|
.B #pragma implementation
|
|
.TP
|
|
\fB#pragma implementation "\fP\fIobjects\fP\fB.h"\fP
|
|
(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 `\|\c
|
|
.B #pragma interface\c
|
|
\&\|'.
|
|
Backup copies of inline member functions, debugging information, and
|
|
the internal tables used to implement virtual functions are all
|
|
generated in implementation files.
|
|
.Sp
|
|
If you use `\|\c
|
|
.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 allclass.cc\c
|
|
\&\|', `\|\c
|
|
.B #pragma implementation\c
|
|
\&\|' by itself is equivalent to `\|\c
|
|
.B
|
|
#pragma implementation "allclass.h"\c
|
|
\&\|'. Use the string argument if you want a single implementation
|
|
file to include code from multiple header files.
|
|
.Sp
|
|
There is no way to split up the contents of a single header file into
|
|
multiple implementation files.
|
|
.SH FILES
|
|
.nf
|
|
.ta \w'LIBDIR/g++\-include 'u
|
|
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
|
|
\fITMPDIR\fR/cc\(** temporary files
|
|
\fILIBDIR\fR/cpp preprocessor
|
|
\fILIBDIR\fR/cc1 compiler for C
|
|
\fILIBDIR\fR/cc1plus compiler for C++
|
|
\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
|
|
.IR intro (3)
|
|
/usr/include standard directory for \fB#include\fP files
|
|
\fILIBDIR\fR/include standard gcc directory for \fB#include\fP files
|
|
\fILIBDIR\fR/g++\-include additional g++ directory for \fB#include\fP
|
|
.Sp
|
|
.fi
|
|
.I LIBDIR
|
|
is usually
|
|
.B /usr/local/lib/\c
|
|
.IR machine / version .
|
|
.br
|
|
.I TMPDIR
|
|
comes from the environment variable
|
|
.B TMPDIR
|
|
(default
|
|
.B /usr/tmp
|
|
if available, else
|
|
.B /tmp\c
|
|
\&).
|
|
.SH "SEE ALSO"
|
|
as(1), cpp(1), gdb(1), ld(1)
|
|
.br
|
|
.RB "`\|" gcc "\|', `\|" cpp \|',
|
|
.RB "`\|" as "\|', `\|" ld \|',
|
|
and
|
|
.RB `\| gdb \|'
|
|
entries in
|
|
.B info\c
|
|
\&.
|
|
.br
|
|
.I
|
|
Using and Porting GNU CC (for version 2.0)\c
|
|
, Richard M. Stallman;
|
|
.I
|
|
The C Preprocessor\c
|
|
, Richard M. Stallman;
|
|
.I
|
|
Debugging with GDB: the GNU Source-Level Debugger\c
|
|
, Richard M. Stallman and Roland H. Pesch;
|
|
.I
|
|
Using as: the GNU Assembler\c
|
|
, Dean Elsner, Jay Fenlason & friends;
|
|
.I
|
|
ld: the GNU linker\c
|
|
, Steve Chamberlain and Roland Pesch.
|
|
.SH BUGS
|
|
For instructions on reporting bugs, see the GCC manual.
|
|
.SH COPYING
|
|
Copyright
|
|
.if t \(co
|
|
1991, 1992, 1993 Free Software Foundation, Inc.
|
|
.PP
|
|
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.
|
|
.PP
|
|
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.
|
|
.PP
|
|
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
|
|
the original English.
|
|
.SH AUTHORS
|
|
See the GNU CC Manual for the contributors to GNU CC.
|