-@c Copyright (C) 1988, 89, 92-98, 1999 Free Software Foundation, Inc.
+@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
+@ignore
+@c man begin COPYRIGHT
+Copyright @copyright{} 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
+1998, 1999, 2000 Free Software Foundation, Inc.
+
+Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+entire resulting derived work is distributed under the terms of a
+permission notice identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that this permission notice may be included in translations
+approved by the Free Software Foundation instead of in the original
+English.
+@c man end
+@c Set file name and title for the man page.
+@setfilename gcc
+@settitle GNU project C and C++ compiler
+@c man begin SYNOPSIS
+gcc [@samp{-c}|@samp{-S}|@samp{-E}] [@samp{-std=}@var{standard}]
+ [@samp{-g}] [@samp{-pg}] [@samp{-O}@var{level}]
+ [@samp{-W}@var{warn}...] [@samp{-pedantic}]
+ [@samp{-I}@var{dir}...] [@samp{-L}@var{dir}...]
+ [@samp{-D}@var{macro}[=@var{defn}]...] [@samp{-U}@var{macro}]
+ [@samp{-f}@var{option}...] [@samp{-m}@var{machine-option}...]
+ [@samp{-o} @var{outfile}] @var{infile}...
+
+Only the most useful options are listed here; see below for the
+remainder. @samp{g++} accepts mostly the same options as @samp{gcc}.
+@c man end
+@c man begin SEEALSO
+cpp(1), gcov(1), g77(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1)
+and the Info entries for @file{gcc}, @file{cpp}, @file{g77}, @file{as},
+@file{ld}, @file{binutils} and @file{gdb}.
+@c man end
+@end ignore
+
@node Invoking GCC
@chapter GCC Command Options
@cindex GCC command options
@cindex command options
@cindex options, GCC command
+@c man begin DESCRIPTION
+
When you invoke GCC, it normally does preprocessing, compilation,
assembly and linking. The ``overall options'' allow you to stop this
process at an intermediate stage. For example, the @samp{-c} option
@cindex grouping options
@cindex options, grouping
The @code{gcc} program accepts options and file names as operands. Many
-options have multiletter names; therefore multiple single-letter options
+options have multi-letter names; therefore multiple single-letter options
may @emph{not} be grouped: @samp{-dr} is very different from @w{@samp{-d
-r}}.
@samp{-ffoo} would be @samp{-fno-foo}. This manual documents
only one of these two forms, whichever one is not the default.
+@c man end
+
@menu
* Option Summary:: Brief list of all options, without explanations.
* Overall Options:: Controlling the kind of output:
* Invoking G++:: Compiling C++ programs.
* C Dialect Options:: Controlling the variant of C language compiled.
* C++ Dialect Options:: Variations on C++.
+* Language Independent Options:: Controlling how diagnostics should be
+ formatted.
* Warning Options:: How picky should the compiler be?
* Debugging Options:: Symbol tables, measurements, and debugging dumps.
* Optimize Options:: How much optimization?
@item Overall Options
@xref{Overall Options,,Options Controlling the Kind of Output}.
@smallexample
--c -S -E -o @var{file} -pipe -pass-exit-codes -v --help -x @var{language}
+-c -S -E -o @var{file} -pipe -pass-exit-codes -x @var{language}
+-v --target-help --help
@end smallexample
@item C Language Options
@xref{C Dialect Options,,Options Controlling C Dialect}.
@smallexample
--ansi -flang-isoc9x -fallow-single-precision -fcond-mismatch -fno-asm
--fno-builtin -ffreestanding -fhosted -fsigned-bitfields -fsigned-char
--funsigned-bitfields -funsigned-char -fwritable-strings
--traditional -traditional-cpp -trigraphs
+-ansi -std=@var{standard} -fno-asm -fno-builtin
+-fhosted -ffreestanding
+-trigraphs -traditional -traditional-cpp
+-fallow-single-precision -fcond-mismatch
+-fsigned-bitfields -fsigned-char
+-funsigned-bitfields -funsigned-char
+-fwritable-strings -fshort-wchar
@end smallexample
@item C++ Language Options
@xref{C++ Dialect Options,,Options Controlling C++ Dialect}.
@smallexample
--fno-access-control -fcheck-new -fconserve-space -fdollars-in-identifiers
--fno-elide-constructors -fexternal-templates -ffor-scope
--fno-for-scope -fno-gnu-keywords -fguiding-decls
--fhonor-std -fhuge-objects -fno-implicit-templates -finit-priority
--fno-implement-inlines -fname-mangling-version-@var{n} -fno-default-inline
--foperator-names -fno-optional-diags -fpermissive -frepo -fstrict-prototype
--fsquangle -ftemplate-depth-@var{n} -fvtable-thunks
--nostdinc++ -Wctor-dtor-privacy -Wno-deprecated -Weffc++
--Wno-non-template-friend
--Wnon-virtual-dtor -Wold-style-cast -Woverloaded-virtual
--Wno-pmf-conversions -Wreorder -Wsign-promo -Wsynth
+-fno-access-control -fcheck-new -fconserve-space
+-fdollars-in-identifiers -fno-elide-constructors
+-fno-enforce-eh-specs -fexternal-templates
+-falt-external-templates
+-ffor-scope -fno-for-scope -fno-gnu-keywords -fhonor-std
+-fhuge-objects -fno-implicit-templates
+-fno-implicit-inline-templates -finit-priority
+-fno-implement-inlines -fms-extensions
+-fname-mangling-version-@var{n} -fno-operator-names
+-fno-optional-diags -fpermissive
+-frepo -fno-rtti -fsquangle -ftemplate-depth-@var{n}
+-fuse-cxa-atexit -fvtable-thunks -nostdinc++
+-fno-default-inline -Wctor-dtor-privacy
+-Wnon-virtual-dtor -Wreorder
+-Weffc++ -Wno-deprecated
+-Wno-non-template-friend -Wold-style-cast
+-Woverloaded-virtual -Wno-pmf-conversions
+-Wsign-promo -Wsynth
+@end smallexample
+
+@item Language Independent Options
+@xref{Language Independent Options,,Options to Control Diagnostic Messages Formatting}.
+@smallexample
+-fmessage-length=@var{n}
+-fdiagnostics-show-location=@r{[}once@r{|}every-line@r{]}
@end smallexample
@item Warning Options
@xref{Warning Options,,Options to Request or Suppress Warnings}.
@smallexample
-fsyntax-only -pedantic -pedantic-errors
--w -W -Wall -Waggregate-return
+-w -W -Wall -Waggregate-return
-Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment
--Wconversion -Werror -Wformat
+-Wconversion -Wdisabled-optimization -Werror
+-Wfloat-equal -Wformat -Wformat=2
+-Wformat-nonliteral -Wformat-security
-Wid-clash-@var{len} -Wimplicit -Wimplicit-int
--Wimplicit-function-declaration -Wimport
--Werror-implicit-function-declaration -Wfloat-equal -Winline
+-Wimplicit-function-declaration
+-Werror-implicit-function-declaration
+-Wimport -Winline
-Wlarger-than-@var{len} -Wlong-long
--Wmain -Wmissing-declarations -Wmissing-noreturn
--Wmultichar -Wno-import
+-Wmain -Wmissing-declarations
+-Wmissing-format-attribute -Wmissing-noreturn
+-Wmultichar -Wno-format-extra-args -Wno-format-y2k
+-Wno-import -Wpacked -Wpadded
-Wparentheses -Wpointer-arith -Wredundant-decls
--Wreturn-type -Wshadow -Wsign-compare -Wswitch
--Wtrigraphs -Wundef -Wuninitialized -Wunknown-pragmas -Wunreachable-code
--Wunused -Wwrite-strings
+-Wreturn-type -Wsequence-point -Wshadow
+-Wsign-compare -Wswitch -Wsystem-headers
+-Wtrigraphs -Wundef -Wuninitialized
+-Wunknown-pragmas -Wunreachable-code
+-Wunused -Wunused-function -Wunused-label -Wunused-parameter
+-Wunused-value -Wunused-variable -Wwrite-strings
@end smallexample
@item C-only Warning Options
-g -g@var{level} -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2
-ggdb -gstabs -gstabs+ -gxcoff -gxcoff+
-p -pg -print-file-name=@var{library} -print-libgcc-file-name
--print-prog-name=@var{program} -print-search-dirs -save-temps -time
+-print-prog-name=@var{program} -print-search-dirs -Q
+-save-temps -time
@end smallexample
@item Optimization Options
@xref{Optimize Options,,Options that Control Optimization}.
@smallexample
--falign-functions=@var{n} -falign-labels=@var{n} -falign-loops=@var{n}
--falign-jumps=@var{n} -fbranch-probabilities
--fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
--fdelayed-branch -fdelete-null-pointer-checks -fexpensive-optimizations
--ffast-math -ffloat-store -fforce-addr -fforce-mem -fno-math-errno
--fdata-sections -ffunction-sections -fgcse
+-falign-functions=@var{n} -falign-jumps=@var{n}
+-falign-labels=@var{n} -falign-loops=@var{n}
+-fbranch-probabilities -fcaller-saves
+-fcse-follow-jumps -fcse-skip-blocks -fdata-sections -fdce
+-fdelayed-branch -fdelete-null-pointer-checks
+-fexpensive-optimizations -ffast-math -ffloat-store
+-fforce-addr -fforce-mem -ffunction-sections -fgcse
-finline-functions -finline-limit=@var{n} -fkeep-inline-functions
--fmove-all-movables -fno-default-inline -fno-defer-pop
--fno-function-cse -fno-inline -fno-peephole
--fomit-frame-pointer -foptimize-register-moves -fregmove
--frerun-cse-after-loop -frerun-loop-opt -freduce-all-givs
--fschedule-insns -fschedule-insns2 -fstrength-reduce
--fstrict-aliasing -fthread-jumps -funroll-all-loops
--funroll-loops
--O -O0 -O1 -O2 -O3 -Os
+-fkeep-static-consts -fmove-all-movables
+-fno-default-inline -fno-defer-pop
+-fno-function-cse -fno-inline -fno-math-errno -fno-peephole
+-fomit-frame-pointer -foptimize-register-move
+-foptimize-sibling-calls -freduce-all-givs
+-fregmove -frename-registers
+-frerun-cse-after-loop -frerun-loop-opt
+-fschedule-insns -fschedule-insns2
+-fsingle-precision-constant -fssa
+-fstrength-reduce -fstrict-aliasing -fthread-jumps -ftrapv
+-funroll-all-loops -funroll-loops
+-O -O0 -O1 -O2 -O3 -Os
@end smallexample
@item Preprocessor Options
-m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
-m68060 -mcpu32 -m5200 -m68881 -mbitfield -mc68000 -mc68020
-mfpa -mnobitfield -mrtd -mshort -msoft-float -mpcrel
--malign-int
+-malign-int -mstrict-align
+
+@emph{M68hc1x Options}
+-m6811 -m6812 -m68hc11 -m68hc12
+-mauto-incdec -mshort -msoft-reg-count=@var{count}
@emph{VAX Options}
-mg -mgnu -munix
-mtune=@var{cpu type}
-mcmodel=@var{code model}
-m32 -m64
--mapp-regs -mbroken-saverestore -mcypress -mepilogue
--mflat -mfpu -mhard-float -mhard-quad-float
--mimpure-text -mlive-g0 -mno-app-regs -mno-epilogue
--mno-flat -mno-fpu -mno-impure-text
--mno-stack-bias -mno-unaligned-doubles
+-mapp-regs -mbroken-saverestore -mcypress
+-mepilogue -mfaster-structs -mflat
+-mfpu -mhard-float -mhard-quad-float
+-mimpure-text -mlive-g0 -mno-app-regs
+-mno-epilogue -mno-faster-structs -mno-flat -mno-fpu
+-mno-impure-text -mno-stack-bias -mno-unaligned-doubles
-msoft-float -msoft-quad-float -msparclite -mstack-bias
-msupersparc -munaligned-doubles -mv8
-mapcs-reentrant -mno-apcs-reentrant
-msched-prolog -mno-sched-prolog
-mlittle-endian -mbig-endian -mwords-little-endian
--mshort-load-bytes -mno-short-load-bytes -mshort-load-words -mno-short-load-words
+-malignment-traps -mno-alignment-traps
-msoft-float -mhard-float -mfpe
-mthumb-interwork -mno-thumb-interwork
-mcpu= -march= -mfpe=
-mstructure-size-boundary=
-mbsd -mxopen -mno-symrename
-mabort-on-noreturn
+-mlong-calls -mno-long-calls
-mnop-fun-dllimport -mno-nop-fun-dllimport
-msingle-pic-base -mno-single-pic-base
-mpic-register=
@emph{MN10300 Options}
-mmult-bug
-mno-mult-bug
+-mam33
+-mno-am33
-mrelax
@emph{M32R/D Options}
-mpowerpc -mpowerpc64 -mno-powerpc
-mpowerpc-gpopt -mno-powerpc-gpopt
-mpowerpc-gfxopt -mno-powerpc-gfxopt
--mnew-mnemonics -mno-new-mnemonics
+-mnew-mnemonics -mold-mnemonics
-mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc
-m64 -m32 -mxl-call -mno-xl-call -mthreads -mpe
-msoft-float -mhard-float -mmultiple -mno-multiple
-mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
-mcall-aix -mcall-sysv -mprototype -mno-prototype
-msim -mmvme -mads -myellowknife -memb -msdata
--msdata=@var{opt} -G @var{num}
+-msdata=@var{opt} -mvxworks -G @var{num}
@emph{RT Options}
-mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs
-mminimum-fp-blocks -mnohc-struct-return
@emph{MIPS Options}
--mabicalls -mcpu=@var{cpu type} -membedded-data
+-mabicalls -mcpu=@var{cpu type}
+-membedded-data -muninit-const-in-rodata
-membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64
-mgpopt -mhalf-pic -mhard-float -mint64 -mips1
-mips2 -mips3 -mips4 -mlong64 -mlong32 -mlong-calls -mmemcpy
-mmips-as -mmips-tfile -mno-abicalls
--mno-embedded-data -mno-embedded-pic
+-mno-embedded-data -mno-uninit-const-in-rodata -mno-embedded-pic
-mno-gpopt -mno-long-calls
-mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats
-mrnames -msoft-float
-m4650 -msingle-float -mmad
-mstats -EL -EB -G @var{num} -nocpp
-mabi=32 -mabi=n32 -mabi=64 -mabi=eabi
+-mfix7000 -mno-crt0
@emph{i386 Options}
--mcpu=@var{cpu type}
--march=@var{cpu type}
--mieee-fp -mno-fancy-math-387
+-mcpu=@var{cpu type} -march=@var{cpu type}
+-mintel-syntax -mieee-fp -mno-fancy-math-387
-mno-fp-ret-in-387 -msoft-float -msvr3-shlib
-mno-wide-multiply -mrtd -malign-double
-mreg-alloc=@var{list} -mregparm=@var{num}
-malign-jumps=@var{num} -malign-loops=@var{num}
-malign-functions=@var{num} -mpreferred-stack-boundary=@var{num}
+-mthreads -mno-align-stringops -minline-all-stringops
+-mpush-args -maccumulate-outgoing-args
@emph{HPPA Options}
-march=@var{architecture type}
-mrelax -mh -ms -mint32 -malign-300
@emph{SH Options}
--m1 -m2 -m3 -m3e -mb -ml -mdalign -mrelax
+-m1 -m2 -m3 -m3e
+-m4-nofpu -m4-single-only -m4-single -m4
+-mb -ml -mdalign -mrelax
+-mbigtable -mfmovd -mhitachi -mnomacsave
+-misize -mpadstruct -mspace
+-mprefergot
+-musermode
@emph{System V Options}
-Qy -Qn -YP,@var{paths} -Ym,@var{dir}
-m32032 -m32332 -m32532 -m32081 -m32381 -mmult-add -mnomult-add
-msoft-float -mrtd -mnortd -mregparam -mnoregparam -msb -mnosb
-mbitfield -mnobitfield -mhimem -mnohimem
+
+@emph{AVR Options}
+-mmcu=@var{mcu} -msize -minit-stack=@var{n} -mno-interrupts
+-mcall-prologues -mno-tablejump -mtiny-stack
+
+@emph{MCore Options}
+-mhardlit, -mno-hardlit -mdiv -mno-div -mrelax-immediates
+-mno-relax-immediates -mwide-bitfields -mno-wide-bitfields
+-m4byte-functions -mno-4byte-functions -mcallgraph-data
+-mno-callgraph-data -mslow-bytes -mno-slow-bytes -mno-lsim
+-mlittle-endian -mbig-endian -m210 -m340 -mstack-increment
@end smallexample
@item Code Generation Options
@xref{Code Gen Options,,Options for Code Generation Conventions}.
@smallexample
-fcall-saved-@var{reg} -fcall-used-@var{reg}
--fexceptions -funwind-tables -ffixed-@var{reg} -finhibit-size-directive
+-fexceptions -funwind-tables -ffixed-@var{reg}
+-finhibit-size-directive -finstrument-functions
-fcheck-memory-usage -fprefix-function-name
-fno-common -fno-ident -fno-gnu-linker
-fpcc-struct-return -fpic -fPIC
-freg-struct-return -fshared-data -fshort-enums
-fshort-double -fvolatile -fvolatile-global -fvolatile-static
--fverbose-asm -fpack-struct -fstack-check
+-fverbose-asm -fpack-struct -fstack-check
+-fstack-limit-register=@var{reg} -fstack-limit-symbol=@var{sym}
-fargument-alias -fargument-noalias
-fargument-noalias-global
-fleading-underscore
or preprocessed source.
* C Dialect Options:: Controlling the variant of C language compiled.
* C++ Dialect Options:: Variations on C++.
+* Language Independent Options:: Controlling how diagnostics should be
+ formatted.
* Warning Options:: How picky should the compiler be?
* Debugging Options:: Symbol tables, measurements, and debugging dumps.
* Optimize Options:: How much optimization?
* Target Options:: Running a cross-compiler, or an old version of GCC.
@end menu
+@c man begin OPTIONS
+
@node Overall Options
@section Options Controlling the Kind of Output
Objective-C source code. Note that you must link with the library
@file{libobjc.a} to make an Objective-C program work.
+@item @var{file}.mi
+Objective-C source code which should not be preprocessed.
+
@item @var{file}.h
C header file (not to be compiled or linked).
@item @var{file}.cc
+@itemx @var{file}.cp
@itemx @var{file}.cxx
@itemx @var{file}.cpp
+@itemx @var{file}.c++
@itemx @var{file}.C
C++ source code which must be preprocessed. Note that in @samp{.cxx},
the last two letters must both be literally @samp{x}. Likewise,
@samp{.C} refers to a literal capital C.
+@item @var{file}.f
+@itemx @var{file}.for
+@itemx @var{file}.FOR
+Fortran source code which should not be preprocessed.
+
+@item @var{file}.F
+@itemx @var{file}.fpp
+@itemx @var{file}.FPP
+Fortran source code which must be preprocessed (with the traditional
+preprocessor).
+
+@item @var{file}.r
+Fortran source code which must be preprocessed with a RATFOR
+preprocessor (not included with GCC).
+
+@xref{Overall Options,,Options Controlling the Kind of Output, g77,
+Using and Porting GNU Fortran}, for more details of the handling of
+Fortran input files.
+
+@c FIXME: Descriptions of Java file types.
+@c @var{file}.java
+@c @var{file}.class
+@c @var{file}.zip
+@c @var{file}.jar
+
+@c GCC also knows about some suffixes for languages not yet included:
+@c Ada:
+@c @var{file}.ads
+@c @var{file}.adb
+@c @var{file}.ada
+@c Pascal:
+@c @var{file}.p
+@c @var{file}.pas
+
+@item @var{file}.ch
+@itemx @var{file}.chi
+CHILL source code (preprocessed with the traditional preprocessor).
+
@item @var{file}.s
Assembler code.
name suffix). This option applies to all following input files until
the next @samp{-x} option. Possible values for @var{language} are:
@example
-c objective-c c++
-c-header cpp-output c++-cpp-output
+c c-header cpp-output
+c++ c++-cpp-output
+objective-c objc-cpp-output
assembler assembler-with-cpp
+f77 f77-cpp-input ratfor
+java chill
@end example
+@c Also f77-version, for internal use only.
@item -x none
Turn off any specification of a language, so that subsequent files are
they accept. If the @code{-W} option is also specified then command
line options which have no documentation associated with them will also
be displayed.
+
+@item --target-help
+Print (on the standard output) a description of target specific command
+line options for each tool.
@end table
@node Invoking G++
or otherwise without a suffix that flags them as C++ programs.
@code{g++} is a program that calls GCC with the default language
set to C++, and automatically specifies linking against the C++
-library. On many systems, the script @code{g++} is also
+library. On many systems, @code{g++} is also
installed with the name @code{c++}.
@cindex invoking @code{g++}
@table @code
@cindex ANSI support
+@cindex ISO support
@item -ansi
-In C mode, support all ANSI standard C programs. In C++ mode,
-remove GNU extensions that conflict with ANSI C++.
-@c shouldn't we be saying "ISO"?
+In C mode, support all ISO C89 programs. In C++ mode,
+remove GNU extensions that conflict with ISO C++.
-This turns off certain features of GCC that are incompatible with ANSI
-C (when compiling C code), or of ANSI standard C++ (when compiling C++ code),
+This turns off certain features of GCC that are incompatible with ISO
+C (when compiling C code), or of standard C++ (when compiling C++ code),
such as the @code{asm} and @code{typeof} keywords, and
predefined macros such as @code{unix} and @code{vax} that identify the
type of system you are using. It also enables the undesirable and
-rarely used ANSI trigraph feature. For the C compiler,
+rarely used ISO trigraph feature. For the C compiler,
it disables recognition of C++ style @samp{//} comments as well as
-the @code{inline} keyword. For the C++ compiler,
-@samp{-foperator-names} is enabled as well.
-
+the @code{inline} keyword.
The alternate keywords @code{__asm__}, @code{__extension__},
@code{__inline__} and @code{__typeof__} continue to work despite
-@samp{-ansi}. You would not want to use them in an ANSI C program, of
+@samp{-ansi}. You would not want to use them in an ISO C program, of
course, but it is useful to put them in header files that might be included
in compilations done with @samp{-ansi}. Alternate predefined macros
such as @code{__unix__} and @code{__vax__} are also available, with or
without @samp{-ansi}.
-The @samp{-ansi} option does not cause non-ANSI programs to be
+The @samp{-ansi} option does not cause non-ISO programs to be
rejected gratuitously. For that, @samp{-pedantic} is required in
addition to @samp{-ansi}. @xref{Warning Options}.
The macro @code{__STRICT_ANSI__} is predefined when the @samp{-ansi}
option is used. 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
+ISO standard doesn't call for; this is to avoid interfering with any
programs that might use these names for other things.
-The functions @code{alloca}, @code{abort}, @code{exit}, and
-@code{_exit} are not builtin functions when @samp{-ansi} is used.
+Functions which would normally be builtin but do not have semantics
+defined by ISO C (such as @code{alloca} and @code{ffs}) are not builtin
+functions with @samp{-ansi} is used. @xref{Other Builtins,,Other
+built-in functions provided by GNU CC}, for details of the functions
+affected.
+
+@item -std=
+Determine the language standard. A value for this option must be provided;
+possible values are
+
+@table @samp
+@item iso9899:1990
+Same as -ansi
+
+@item iso9899:199409
+ISO C as modified in amend. 1
+
+@item iso9899:1999
+ISO C99. Note that this standard is not yet fully supported; see
+@uref{http://gcc.gnu.org/c99status.html} for more information.
+
+@item c89
+same as -std=iso9899:1990
+
+@item c99
+same as -std=iso9899:1999
+
+@item gnu89
+default, iso9899:1990 + gnu extensions
-@item -flang-isoc9x
-Enable support for features found in the C9X standard. In particular,
-enable support for the C9X @code{restrict} keyword.
+@item gnu99
+iso9899:1999 + gnu extensions
-Even when this option is not specified, you can still use some C9X
-features in so far as they do not conflict with previous C standards.
-For example, you may use @code{__restrict__} even when -flang-isoc9x
-is not specified.
+@item iso9899:199x
+same as -std=iso9899:1999, deprecated
+
+@item c9x
+same as -std=iso9899:1999, deprecated
+
+@item gnu9x
+same as -std=gnu99, deprecated
+
+@end table
+
+Even when this option is not specified, you can still use some of the
+features of newer standards in so far as they do not conflict with
+previous C standards. For example, you may use @code{__restrict__} even
+when -std=c99 is not specified.
+
+@xref{Standards,,Language Standards Supported by GCC}, for details of
+these standard versions.
@item -fno-asm
Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
In C++, this switch only affects the @code{typeof} keyword, since
@code{asm} and @code{inline} are standard keywords. You may want to
-use the @samp{-fno-gnu-keywords} flag instead, as it also disables the
-other, C++-specific, extension keywords such as @code{headof}.
+use the @samp{-fno-gnu-keywords} flag instead, which has the same effect.
@item -fno-builtin
@cindex builtin functions
-@findex abort
-@findex abs
-@findex alloca
-@findex cos
-@findex cosf
-@findex cosl
-@findex exit
-@findex _exit
-@findex fabs
-@findex fabsf
-@findex fabsl
-@findex ffs
-@findex labs
-@findex memcmp
-@findex memcpy
-@findex memset
-@findex sin
-@findex sinf
-@findex sinl
-@findex sqrt
-@findex sqrtf
-@findex sqrtl
-@findex strcmp
-@findex strcpy
-@findex strlen
-Don't recognize builtin functions that do not begin with @samp{__builtin_}
-as prefix. Currently, the functions affected include @code{abort},
-@code{abs}, @code{alloca}, @code{cos}, @code{cosf}, @code{cosl},
-@code{exit}, @code{_exit}, @code{fabs}, @code{fabsf}, @code{fabsl},
-@code{ffs}, @code{labs}, @code{memcmp}, @code{memcpy}, @code{memset},
-@code{sin}, @code{sinf}, @code{sinl}, @code{sqrt}, @code{sqrtf},
-@code{sqrtl}, @code{strcmp}, @code{strcpy}, and @code{strlen}.
+Don't recognize builtin functions that do not begin with
+@samp{__builtin_} as prefix. @xref{Other Builtins,,Other built-in
+functions provided by GNU CC}, for details of the functions affected,
+including those which are not builtin functions when @samp{-ansi} is
+used because they do not have an ISO standard meaning.
GCC normally generates special code to handle certain builtin functions
more efficiently; for instance, calls to @code{alloca} may become single
cannot set a breakpoint on those calls, nor can you change the behavior
of the functions by linking with a different library.
-The @samp{-ansi} option prevents @code{alloca}, @code{ffs} and @code{_exit}
-from being builtin functions, since these functions do not have an ANSI
-standard meaning.
-
@item -fhosted
@cindex hosted environment
not necessarily be at @code{main}. The most obvious example is an OS kernel.
This is equivalent to @samp{-fno-hosted}.
+@xref{Standards,,Language Standards Supported by GCC}, for details of
+freestanding and hosted environments.
+
@item -trigraphs
-Support ANSI C trigraphs. You don't want to know about this
+Support ISO C trigraphs. You don't want to know about this
brain-damage. The @samp{-ansi} option implies @samp{-trigraphs}.
@cindex traditional C language
Out-of-range floating point literals are not an error.
@item
-Certain constructs which ANSI regards as a single invalid preprocessing
+Certain constructs which ISO regards as a single invalid preprocessing
number, such as @samp{0xe-0xd}, are treated as expressions instead.
@item
@cindex @code{longjmp} and automatic variables
@item
All automatic variables not declared @code{register} are preserved by
-@code{longjmp}. Ordinarily, GNU C follows ANSI C: automatic variables
+@code{longjmp}. Ordinarily, GNU C follows ISO C: automatic variables
not declared @code{volatile} may be clobbered.
@item
other purposes of its own.
You cannot use @samp{-traditional} if you include any header files that
-rely on ANSI C features. Some vendors are starting to ship systems with
-ANSI C header files and you cannot use @samp{-traditional} on such
+rely on ISO C features. Some vendors are starting to ship systems with
+ISO C header files and you cannot use @samp{-traditional} on such
systems to compile files that include any system headers.
The @samp{-traditional} option also enables @samp{-traditional-cpp},
@samp{-traditional}). If you need to write header files that work
differently depending on whether @samp{-traditional} is in use, by
testing both of these predefined macros you can distinguish four
-situations: GNU C, traditional GNU C, other ANSI C compilers, and other
+situations: GNU C, traditional GNU C, other ISO C compilers, and other
old C compilers. The predefined macro @code{__STDC_VERSION__} is also
not defined when you use @samp{-traditional}. @xref{Standard
Predefined,,Standard Predefined Macros,cpp.info,The C Preprocessor},
other purposes of its own.
You cannot use @samp{-traditional} if you include any header files that
-rely on ANSI C features. Some vendors are starting to ship systems with
-ANSI C header files and you cannot use @samp{-traditional} on such
+rely on ISO C features. Some vendors are starting to ship systems with
+ISO C header files and you cannot use @samp{-traditional} on such
systems to compile files that include any system headers.
@item -fsigned-bitfields
than double precision. If you must use @samp{-traditional}, but want
to use single precision operations when the operands are single
precision, use this option. This option has no effect when compiling
-with ANSI or GNU C conventions (the default).
+with ISO or GNU C conventions (the default).
@item -fshort-wchar
Override the underlying type for @samp{wchar_t} to be @samp{short
@samp{$} with the option @samp{-fno-dollars-in-identifiers}. (GNU C allows
@samp{$} by default on most target systems, but there are a few exceptions.)
Traditional C allowed the character @samp{$} to form part of
-identifiers. However, ANSI C and C++ forbid @samp{$} in identifiers.
+identifiers. However, ISO C and C++ forbid @samp{$} in identifiers.
@item -fno-elide-constructors
The C++ standard allows an implementation to omit creating a temporary
Specifying this option disables that optimization, and forces g++ to
call the copy constructor in all cases.
+@item -fno-enforce-eh-specs
+Don't check for violation of exception specifications at runtime. This
+option violates the C++ standard, but may be useful for reducing code
+size in production builds, much like defining @samp{NDEBUG}. The compiler
+will still optimize based on the exception specifications.
+
@item -fexternal-templates
Cause template instantiations to obey @samp{#pragma interface} and
@samp{implementation}; template instances are emitted or not according
@itemx -fno-for-scope
If -ffor-scope is specified, the scope of variables declared in
a @i{for-init-statement} is limited to the @samp{for} loop itself,
-as specified by the draft C++ standard.
+as specified by the C++ standard.
If -fno-for-scope is specified, the scope of variables declared in
a @i{for-init-statement} extends to the end of the enclosing scope,
as was the case in old versions of gcc, and other (traditional)
otherwise be invalid, or have different behavior.
@item -fno-gnu-keywords
-Do not recognize @code{classof}, @code{headof}, or @code{typeof} as a
-keyword, so that code can use these words as identifiers. You can use
-the keywords @code{__classof__}, @code{__headof__}, and
-@code{__typeof__} instead. @samp{-ansi} implies
-@samp{-fno-gnu-keywords}.
-
-@item -fguiding-decls
-Treat a function declaration with the same type as a potential function
-template instantiation as though it declares that instantiation, not a
-normal function. If a definition is given for the function later in the
-translation unit (or another translation unit if the target supports
-weak symbols), that definition will be used; otherwise the template will
-be instantiated. This behavior reflects the C++ language prior to
-September 1996, when guiding declarations were removed.
-
-This option implies @samp{-fname-mangling-version-0}, and will not work
-with other name mangling versions. Like all options that change the
-ABI, all C++ code, @emph{including libgcc.a} must be built with the same
-setting of this option.
+Do not recognize @code{typeof} as a keyword, so that code can use this
+word as an identifier. You can use the keyword @code{__typeof__} instead.
+@samp{-ansi} implies @samp{-fno-gnu-keywords}.
@item -fhonor-std
Treat the @code{namespace std} as a namespace, instead of ignoring
errors if these functions are not inlined everywhere they are called.
@item -fms-extensions
-Disable pedwarns about constructs used in MFC, such as implicit int and
-getting a pointer to member function via non-standard syntax.
+Disable pedantic warnings about constructs used in MFC, such as implicit
+int and getting a pointer to member function via non-standard syntax.
@item -fname-mangling-version-@var{n}
Control the way in which names are mangled. Version 0 is compatible
Like all options that change the ABI, all C++ code, @emph{including
libgcc} must be built with the same setting of this option.
-@item -foperator-names
-Recognize the operator name keywords @code{and}, @code{bitand},
+@item -fno-operator-names
+Do not treat the operator name keywords @code{and}, @code{bitand},
@code{bitor}, @code{compl}, @code{not}, @code{or} and @code{xor} as
-synonyms for the symbols they refer to. @samp{-ansi} implies
-@samp{-foperator-names}.
+synonyms as keywords.
@item -fno-optional-diags
Disable diagnostics that the standard says a compiler does not need to
exception handling uses the same information, but it will generate it as
needed.
-@item -fstrict-prototype
-Within an @samp{extern "C"} linkage specification, treat a function
-declaration with no arguments, such as @samp{int foo ();}, as declaring
-the function to take no arguments. Normally, such a declaration means
-that the function @code{foo} can take any combination of arguments, as
-in C. @samp{-pedantic} implies @samp{-fstrict-prototype} unless
-overridden with @samp{-fno-strict-prototype}.
-
-Specifying this option will also suppress implicit declarations of
-functions.
-
-This flag no longer affects declarations with C++ linkage.
-
@item -fsquangle
@itemx -fno-squangle
@samp{-fsquangle} will enable a compressed form of name mangling for
endless recursions during template class instantiation. ANSI/ISO C++
conforming programs must not rely on a maximum depth greater than 17.
+@item -fuse-cxa-atexit
+Register destructors for objects with static storage duration with the
+@code{__cxa_atexit} function rather than the @code{atexit} function.
+This option is required for fully standards-compliant handling of static
+destructors, but will only work if your C library supports
+@code{__cxa_atexit}.
+
@item -fvtable-thunks
Use @samp{thunks} to implement the virtual function dispatch table
(@samp{vtable}). The traditional (cfront-style) approach to
function. Because this non-conforming behavior is no longer the default
behavior for g++, @samp{-Wnon-template-friend} allows the compiler to
check existing code for potential trouble spots, and is on by default.
-This new compiler behavior can also be turned off with the flag
-@samp{-fguiding-decls}, which activates the older, non-specification
-compiler code, or with @samp{-Wno-non-template-friend} which keeps the
-conformant compiler code but disables the helpful warning.
+This new compiler behavior can be turned off with
+@samp{-Wno-non-template-friend} which keeps the conformant compiler code
+but disables the helpful warning.
@item -Wold-style-cast (C++ only)
Warn if an old-style (C-style) cast is used within a C++ program. The
(const A&);}, while cfront will use the user-defined @samp{operator =}.
@end table
+@node Language Independent Options
+@section Options to Control Diagnostic Messages Formatting
+@cindex options to control diagnostics formatting
+@cindex diagnostic messages
+@cindex message formatting
+
+Traditionally, diagnostic messages have been formatted irrespective of
+the output device's aspect (e.g. its width, ...). The options described
+below can be used to control the diagnostic messages formatting
+algorithm, e.g. how many characters per line, how often source location
+information should be reported. Right now, only the C++ front-end can
+honor these options. However it is expected, in the near future, that
+the remaining front-ends would be able to digest them correctly.
+
+@table @code
+@item -fmessage-length=@var{n}
+Try to format error messages so that they fit on lines of about @var{n}
+characters. The default is 72 characters for g++ and 0 for the rest of
+the front-ends supported by GCC. If @var{n} is zero, then no
+line-wrapping will be done; each error message will appear on a single
+line.
+
+@item -fdiagnostics-show-location=once
+Only meaningful in line-wrapping mode. Instructs the diagnostic messages
+reporter to emit @emph{once} source location information; that is, in
+case the message is too long to fit on a single physical line and has to
+be wrapped, the source location won't be emitted (as prefix) again,
+over and over, in subsequent continuation lines. This is the default
+behaviour.
+
+@item -fdiagnostics-show-location=every-line
+Only meaningful in line-wrapping mode. Instructs the diagnostic
+messages reporter to emit the same source location information (as
+prefix) for physical lines that result from the process of breaking a
+a message which is too long to fit on a single line.
+
+@end table
+
@node Warning Options
@section Options to Request or Suppress Warnings
@cindex options to control warnings
Check the code for syntax errors, but don't do anything beyond that.
@item -pedantic
-Issue all the warnings demanded by strict ANSI C and ISO C++;
-reject all programs that use forbidden extensions.
+Issue all the warnings demanded by strict ISO C and ISO C++;
+reject all programs that use forbidden extensions, and some other
+programs that do not follow ISO C and ISO C++. For ISO C, follows the
+version of the ISO C standard specified by any @samp{-std} option used.
-Valid ANSI C and ISO C++ programs should compile properly with or without
+Valid ISO C and ISO C++ programs should compile properly with or without
this option (though a rare few will require @samp{-ansi}). However,
without this option, certain GNU extensions and traditional C and C++
features are supported as well. With this option, they are rejected.
these escape routes; application programs should avoid them.
@xref{Alternate Keywords}.
-This option is not intended to be @i{useful}; it exists only to satisfy
-pedants who would otherwise claim that GCC fails to support the ANSI
-standard.
-
-Some users try to use @samp{-pedantic} to check programs for strict ANSI
+Some users try to use @samp{-pedantic} to check programs for strict ISO
C conformance. They soon find that it does not do quite what they want:
-it finds some non-ANSI practices, but not all---only those for which
-ANSI C @emph{requires} a diagnostic.
+it finds some non-ISO practices, but not all---only those for which
+ISO C @emph{requires} a diagnostic, and some others for which
+diagnostics have been added.
-A feature to report any failure to conform to ANSI C might be useful in
+A feature to report any failure to conform to ISO C might be useful in
some instances, but would require considerable additional work and would
be quite different from @samp{-pedantic}. We don't have plans to
support such a feature in the near future.
the arguments supplied have types appropriate to the format string
specified.
+The formats are checked against the format features supported by GNU
+libc version 2.2. These include all ISO C89 and C99 features, as well
+as features from the Single Unix Specification and some BSD and GNU
+extensions. Other library implementations may not support all these
+features; GCC does not support warning about features that go beyond a
+particular library's limitations. However, if @samp{-pedantic} is used
+with @samp{-Wformat}, warnings will be given about format features not
+in the selected standard version. @xref{C Dialect Options,,Options
+Controlling C Dialect}.
+
+@samp{-Wformat} is included in @samp{-Wall}. For more control over some
+aspects of format checking, the options @samp{-Wno-format-y2k},
+@samp{-Wno-format-extra-args}, @samp{-Wformat-nonliteral},
+@samp{-Wformat-security} and @samp{-Wformat=2} are available, but are
+not included in @samp{-Wall}.
+
+@item -Wno-format-y2k
+If @samp{-Wformat} is specified, do not warn about @code{strftime}
+formats which may yield only a two-digit year.
+
+@item -Wno-format-extra-args
+If @samp{-Wformat} is specified, do not warn about excess arguments to a
+@code{printf} or @code{scanf} format function. The C standard specifies
+that such arguments are ignored.
+
+@item -Wformat-nonliteral
+If @samp{-Wformat} is specified, also warn if the format string is not a
+string literal and so cannot be checked, unless the format function
+takes its format arguments as a @code{va_list}.
+
+@item -Wformat-security
+If @samp{-Wformat} is specified, also warn about uses of format
+functions that represent possible security problems. At present, this
+warns about calls to @code{printf} and @code{scanf} functions where the
+format string is not a string literal and there are no format arguments,
+as in @code{printf (foo);}. This may be a security hole if the format
+string came from untrusted input and contains @samp{%n}. (This is
+currently a subset of what @samp{-Wformat-nonliteral} warns about, but
+in future warnings may be added to @samp{-Wformat-security} that are not
+included in @samp{-Wformat-nonliteral}.)
+
+@item -Wformat=2
+Enable @samp{-Wformat} plus format checks not included in
+@samp{-Wformat}. Currently equivalent to @samp{-Wformat
+-Wformat-nonliteral -Wformat-security}.
+
@item -Wimplicit-int
Warn when a declaration does not specify a type.
Warn if a multicharacter constant (@samp{'FOOF'}) is used. Usually they
indicate a typo in the user's code, as they have implementation-defined
values, and should not be used in portable code.
-
+
@item -Wparentheses
Warn if parentheses are omitted in certain contexts, such
as when there is an assignment in a context where a truth value
@}
@end smallexample
+@item -Wsequence-point
+Warn about code that may have undefined semantics because of violations
+of sequence point rules in the C standard.
+
+The C standard defines the order in which expressions in a C program are
+evaluated in terms of @dfn{sequence points}, which represent a partial
+ordering between the execution of parts of the program: those executed
+before the sequence point, and those executed after it. These occur
+after the evaluation of a full expression (one which is not part of a
+larger expression), after the evaluation of the first operand of a
+@code{&&}, @code{||}, @code{? :} or @code{,} (comma) operator, before a
+function is called (but after the evaluation of its arguments and the
+expression denoting the called function), and in certain other places.
+Other than as expressed by the sequence point rules, the order of
+evaluation of subexpressions of an expression is not specified. All
+these rules describe only a partial order rather than a total order,
+since, for example, if two functions are called within one expression
+with no sequence point between them, the order in which the functions
+are called is not specified. However, the standards committee have
+ruled that function calls do not overlap.
+
+It is not specified when between sequence points modifications to the
+values of objects take effect. Programs whose behavior depends on this
+have undefined behavior; the C standard specifies that ``Between the
+previous and next sequence point an object shall have its stored value
+modified at most once by the evaluation of an expression. Furthermore,
+the prior value shall be read only to determine the value to be
+stored.''. If a program breaks these rules, the results on any
+particular implementation are entirely unpredictable.
+
+Examples of code with undefined behavior are @code{a = a++;}, @code{a[n]
+= b[n++]} and @code{a[i++] = i;}. Some more complicated cases are not
+diagnosed by this option, and it may give an occasional false positive
+result, but in general it has been found fairly effective at detecting
+this sort of problem in programs.
+
+The present implementation of this option only works for C programs. A
+future implementation may also work for C++ programs.
+
+There is some controversy over the precise meaning of the sequence point
+rules in subtle cases. Alternative formal definitions may be found in
+Clive Feather's ``Annex S''
+@uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n925.htm} and in
+Michael Norrish's thesis
+@uref{http://www.cl.cam.ac.uk/users/mn200/PhD/thesis-report.ps.gz}.
+Other discussions are by Raymond Mak
+@uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n926.htm} and
+D. Hugh Redelmeier
+@uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n927.htm}.
+
@item -Wreturn-type
-Warn whenever a function is defined with a return-type that defaults
-to @code{int}. Also warn about any @code{return} statement with no
-return-value in a function whose return-type is not @code{void}.
+Warn whenever a function is defined with a return-type that defaults to
+@code{int}. Also warn about any @code{return} statement with no
+return-value in a function whose return-type is not @code{void}.
+
+For C++, a function without return type always produces a diagnostic
+message, even when @samp{-Wno-return-type} is specified. The only
+exceptions are @samp{main} and functions defined in system headers.
@item -Wswitch
Warn whenever a @code{switch} statement has an index of enumeral type
provoke warnings when this option is used.
@item -Wtrigraphs
-Warn if any trigraphs are encountered (assuming they are enabled).
+Warn if any trigraphs are encountered that might change the meaning of
+the program (trigraphs within comments are not warned about).
-@item -Wunused
-Warn whenever a variable is unused aside from its declaration,
-whenever a function is declared static but never defined, whenever a
-label is declared but not used, and whenever a statement computes a
-result that is explicitly not used.
+@item -Wunused-function
+Warn whenever a static function is declared but not defined or a
+non\-inline static function is unused.
-In order to get a warning about an unused function parameter, you must
-specify both @samp{-W} and @samp{-Wunused}.
+@item -Wunused-label
+Warn whenever a label is declared but not used.
+
+To suppress this warning use the @samp{unused} attribute
+(@pxref{Variable Attributes}).
+
+@item -Wunused-parameter
+Warn whenever a function parameter is unused aside from its declaration.
+
+To suppress this warning use the @samp{unused} attribute
+(@pxref{Variable Attributes}).
+
+@item -Wunused-variable
+Warn whenever a local variable or non-constant static variable is unused
+aside from its declaration
-To suppress this warning for an expression, simply cast it to void. For
-unused variables, parameters and labels, use the @samp{unused} attribute
+To suppress this warning use the @samp{unused} attribute
(@pxref{Variable Attributes}).
+@item -Wunused-value
+Warn whenever a statement computes a result that is explicitly not used.
+
+To suppress this warning cast the expression to @samp{void}.
+
+@item -Wunused
+All all the above @samp{-Wunused} options combined.
+
+In order to get a warning about an unused function parameter, you must
+either specify @samp{-W -Wunused} or separately specify
+@samp{-Wunused-parameter}.
+
@item -Wuninitialized
Warn if an automatic variable is used without first being initialized or
if a variable may be clobbered by a @code{setjmp} call.
This has no bug because @code{save_y} is used only if it is set.
@cindex @code{longjmp} warnings
-This option also warns when a nonvolatile automatic variable might be
+This option also warns when a non-volatile automatic variable might be
changed by a call to @code{longjmp}. These warnings as well are possible
only in optimizing compilation.
warnings about constructions that some users consider questionable, and
that are easy to avoid (or modify to prevent the warning), even in
conjunction with macros.
+
+@item -Wsystem-headers
+@cindex warnings from system headers
+@cindex system headers, warnings from
+Print warning messages for constructs found in system header files.
+Warnings from system headers are normally suppressed, on the assumption
+that they usually do not indicate real problems and would only make the
+compiler output harder to read. Using this command line option tells
+GCC to emit warnings from system headers as if they occurred in user
+code. However, note that using @samp{-Wall} in conjunction with this
+option will @emph{not} warn about unknown pragmas in system
+headers---for that, @samp{-Wunknown-pragmas} must also be used.
@end table
The following @samp{-W@dots{}} options are not implied by @samp{-Wall}.
a declaration. According to the C Standard, this usage is obsolescent.
@item
+The return type of a function has a type qualifier such as @code{const}.
+Such a type qualifier has no effect, since the value returned by a
+function is not an lvalue. (But don't warn about the GNU extension of
+@code{volatile void} return types. That extension will be warned about
+if @samp{-pedantic} is specified.)
+
+@item
If @samp{-Wall} or @samp{-Wunused} is also specified, warn about unused
arguments.
@item -Wfloat-equal
Warn if floating point values are used in equality comparisons.
+The idea behind this is that sometimes it is convenient (for the
+programmer) to consider floating-point values as approximations to
+infinitely precise real numbers. If you are doing this, then you need
+to compute (by analysing the code, or in some other way) the maximum or
+likely maximum error that the computation introduces, and allow for it
+when performing comparisons (and when producing output, but that's a
+different problem). In particular, instead of testing for equality, you
+would check to see whether the two values have ranges that overlap; and
+this is done with the relational operators, so equality comparisons are
+probably mistaken.
+
@item -Wtraditional (C only)
Warn about certain constructs that behave differently in traditional and
-ANSI C.
+ISO C.
@itemize @bullet
@item
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.
+the constant in ISO C.
@item
A function declared external in one block and then used after the end of
@item
A non-@code{static} function declaration follows a @code{static} one.
This construct is not accepted by some traditional C compilers.
+
+@item
+The ISO type of an integer constant has a different width or
+signedness from its traditional type. This warning is only issued if
+the base of the constant is ten. I.e. hexadecimal or octal values, which
+typically represent bit patterns, are not warned about.
+
+@item
+Usage of ISO string concatenation is detected.
+
+@item
+A function macro appears without arguments.
+
+@item
+The unary plus operator.
+
+@item
+Initialization of automatic aggregates.
+
+@item
+Identifier conflicts with labels. Traditional C lacks a separate
+namespace for labels.
+
+@item
+Initialization of unions. If the initializer is zero, the warning is
+omitted. This is done under the assumption that the zero initializer in
+user code appears conditioned on e.g. @code{__STDC__} to avoid missing
+initializer warnings and relies on default initialization to zero in the
+traditional C case.
+
+@item
+The `U' integer constant suffix, or the `F' or `L' floating point
+constant suffixes. (Traditonal C does support the `L' suffix on integer
+constants.) Note, these suffixes appear in macros defined in the system
+headers of most modern systems, e.g. the _MIN/_MAX macros in limits.h.
+Use of these macros can lead to spurious warnings as they do not
+necessarily reflect whether the code in question is any less portable to
+traditional C given that suitable backup definitions are provided.
@end itemize
@item -Wundef
adding the @code{noreturn} attribute, otherwise subtle code generation
bugs could be introduced.
+@item -Wmissing-format-attribute
+If @samp{-Wformat} is enabled, also warn about functions which might be
+candidates for @code{format} attributes. Note these are only possible
+candidates, not absolute ones. GCC will guess that @code{format}
+attributes might be appropriate for any function that calls a function
+like @code{vprintf} or @code{vscanf}, but this might not always be the
+case, and some functions for which @code{format} attributes are
+appropriate may not be detected. This option has no effect unless
+@samp{-Wformat} is enabled (possibly by @samp{-Wall}).
+
+@item -Wpacked
+Warn if a structure is given the packed attribute, but the packed
+attribute has no effect on the layout or size of the structure.
+Such structures may be mis-aligned for little benefit. For
+instance, in this code, the variable @code{f.x} in @code{struct bar}
+will be misaligned even though @code{struct bar} does not itself
+have the packed attribute:
+
+@smallexample
+@group
+struct foo @{
+ int x;
+ char a, b, c, d;
+@} __attribute__((packed));
+struct bar @{
+ char z;
+ struct foo f;
+@};
+@end group
+@end smallexample
+
+@item -Wpadded
+Warn if padding is included in a structure, either to align an element
+of the structure or to align the whole structure. Sometimes when this
+happens it is possible to rearrange the fields of the structure to
+reduce the padding and so make the structure smaller.
+
@item -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.
@samp{-Wlong-long} and @samp{-Wno-long-long} are taken into account
only when @samp{-pedantic} flag is used.
+@item -Wdisabled-optimization
+Warn if a requested optimization pass is disabled. This warning does
+not generally indicate that there is anything wrong with your code; it
+merely indicates that GCC's optimizers were unable to handle the code
+effectively. Often, the problem is that your code is too big or too
+complex; GCC will refuse to optimize programs when the optimization
+itself is likely to take inordinate amounts of time.
+
@item -Werror
Make all warnings into errors.
@end table
Says to make debugging dumps during compilation at times specified by
@var{letters}. This is used for debugging the compiler. The file names
for most of the dumps are made by appending a pass number and a word to
-the source file name (e.g. @file{foo.c.00.rtl} or @file{foo.c.01.jump}).
+the source file name (e.g. @file{foo.c.00.rtl} or @file{foo.c.01.sibling}).
Here are the possible letters for use in @var{letters}, and their meanings:
@table @samp
@item A
Annotate the assembler output with miscellaneous debugging information.
@item b
-Dump after computing branch probabilities, to @file{@var{file}.07.bp}.
+Dump after computing branch probabilities, to @file{@var{file}.11.bp}.
+@item B
+Dump after block reordering, to @file{@var{file}.26.bbro}.
@item c
-Dump after instruction combination, to the file @file{@var{file}.09.combine}.
+Dump after instruction combination, to the file @file{@var{file}.14.combine}.
+@item C
+Dump after the first if conversion, to the file @file{@var{file}.15.ce}.
@item d
-Dump after delayed branch scheduling, to @file{@var{file}.19.dbr}.
+Dump after delayed branch scheduling, to @file{@var{file}.29.dbr}.
@item D
Dump all macro definitions, at the end of preprocessing, in addition to
normal output.
-@item F
-Dump after purging ADDRESSOF, to @file{@var{file}.03.addressof}.
+@item e
+Dump after SSA optimizations, to @file{@var{file}.05.ssa} and
+@file{@var{file}.06.ussa}.
+@item E
+Dump after the second if conversion, to @file{@var{file}.24.ce2}.
@item f
-Dump after flow analysis, to @file{@var{file}.08.flow}.
+Dump after life analysis, to @file{@var{file}.13.life}.
+@item F
+Dump after purging @code{ADDRESSOF} codes, to @file{@var{file}.04.addressof}.
@item g
-Dump after global register allocation, to @file{@var{file}.13.greg}.
+Dump after global register allocation, to @file{@var{file}.19.greg}.
+@item o
+Dump after post-reload CSE and other optimizations, to @file{@var{file}.20.postreload}.
@item G
-Dump after GCSE, to @file{@var{file}.04.gcse}.
+Dump after GCSE, to @file{@var{file}.08.gcse}.
+@item i
+Dump after sibling call optimizations, to @file{@var{file}.01.sibling}.
@item j
-Dump after first jump optimization, to @file{@var{file}.01.jump}.
+Dump after the first jump optimization, to @file{@var{file}.02.jump}.
@item J
-Dump after last jump optimization, to @file{@var{file}.17.jump2}.
+Dump after the last jump optimization, to @file{@var{file}.27.jump2}.
@item k
-Dump after conversion from registers to stack, to @file{@var{file}.20.stack}.
+Dump after conversion from registers to stack, to @file{@var{file}.29.stack}.
@item l
-Dump after local register allocation, to @file{@var{file}.12.lreg}.
+Dump after local register allocation, to @file{@var{file}.18.lreg}.
@item L
-Dump after loop optimization, to @file{@var{file}.05.loop}.
+Dump after loop optimization, to @file{@var{file}.09.loop}.
@item M
Dump after performing the machine dependent reorganisation pass, to
-@file{@var{file}.18.mach}.
+@file{@var{file}.28.mach}.
+@item n
+Dump after register renumbering, to @file{@var{file}.23.rnreg}.
@item N
-Dump after the register move pass, to @file{@var{file}.10.regmove}.
+Dump after the register move pass, to @file{@var{file}.16.regmove}.
@item r
Dump after RTL generation, to @file{@var{file}.00.rtl}.
@item R
Dump after the second instruction scheduling pass, to
-@file{@var{file}.16.sched2}.
+@file{@var{file}.25.sched2}.
@item s
Dump after CSE (including the jump optimization that sometimes follows
-CSE), to @file{@var{file}.02.cse}.
+CSE), to @file{@var{file}.03.cse}.
@item S
Dump after the first instruction scheduling pass, to
-@file{@var{file}.11.sched}.
+@file{@var{file}.17.sched}.
@item t
Dump after the second CSE pass (including the jump optimization that
-sometimes follows CSE), to @file{@var{file}.06.cse2}.
+sometimes follows CSE), to @file{@var{file}.10.cse2}.
+@item w
+Dump after the second flow pass, to @file{@var{file}.21.flow2}.
+@item X
+Dump after dead code elimination, to @file{@var{file}.06.dce}.
+@item z
+Dump after the peephole pass, to @file{@var{file}.22.peephole2}.
@item a
Produce all the dumps listed above.
@item m
Annotate the assembler output with a comment indicating which
pattern and alternative was used. The length of each instruction is
also printed.
+@item P
+Dump the RTL in the assembler output as a comment before each instruction.
+Also turns on @samp{-dp} annotation.
@item v
For each of the other indicated dump files (except for
@file{@var{file}.00.rtl}), dump a representation of the control flow graph
-suitible for viewing with VCG to @file{@var{file}.@var{pass}.vcg}.
-@item w
-Dump after the second flow pass to @file{@var{file}.14.flow2}.
+suitable for viewing with VCG to @file{@var{file}.@var{pass}.vcg}.
@item x
Just generate RTL for a function instead of compiling it. Usually used
with @samp{r}.
@item y
Dump debugging information during parsing, to standard error.
-@item z
-Dump after the peephole2 pass to @file{@var{file}.15.peephole2}.
@end table
@item -fdump-unnumbered
When doing debugging dumps (see -d option above), suppress instruction
numbers and line number note output. This makes it more feasible to
-use diff on debugging dumps for compiler invokations with different
+use diff on debugging dumps for compiler invocations with different
options, in particular with and without -g.
-@item -fdump-translation-unit-@var{file} (C++ only)
+@item -fdump-translation-unit-@var{file} (C and C++ only)
Dump a representation of the tree structure for the entire translation
unit to @var{file}.
Store the usual ``temporary'' intermediate files permanently; place them
in the current directory and name them based on the source file. Thus,
compiling @file{foo.c} with @samp{-c -save-temps} would produce files
-@file{foo.i} and @file{foo.s}, as well as @file{foo.o}.
+@file{foo.i} and @file{foo.s}, as well as @file{foo.o}. This creates a
+preprocessed @file{foo.i} output file even though the compiler now
+normally uses an integrated preprocessor.
@item -time
Report the CPU time taken by each subprocess in the compilation
-sequence. For C source files, this is the preprocessor, compiler
-proper, and assembler. The output looks like this:
+sequence. For C source files, this is the compiler proper and assembler
+(plus the linker if linking is done). The output looks like this:
@smallexample
-# cpp 0.04 0.04
# cc1 0.12 0.01
# as 0.00 0.01
@end smallexample
As compared to @samp{-O}, this option increases both compilation time
and the performance of the generated code.
-@samp{-O2} turns on all optional optimizations except for loop unrolling
-and function inlining. It also turns on the @samp{-fforce-mem} option
-on all machines and frame pointer elimination on machines where doing so
-does not interfere with debugging.
+@samp{-O2} turns on all optional optimizations except for loop unrolling,
+function inlining, and register renaming. It also turns on the
+@samp{-fforce-mem} option on all machines and frame pointer elimination
+on machines where doing so does not interfere with debugging.
@item -O3
Optimize yet more. @samp{-O3} turns on all optimizations specified by
-@samp{-O2} and also turns on the @samp{inline-functions} option.
+@samp{-O2} and also turns on the @samp{-finline-functions} and
+@samp{-frename-registers} options.
@item -O0
Do not optimize.
Usage, gcc.info, Using and Porting GCC}.@refill
@end ifclear
+@item -foptimize-sibling-calls
+Optimize sibling and tail recursive calls.
+
+@item -ftrapv
+This option generates traps for signed overflow on addition, subtraction,
+multiplication operations.
+
@item -fno-inline
Don't pay attention to the @code{inline} keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
performed when this option is not used.
@item -ffast-math
-This option allows GCC to violate some ANSI or IEEE rules and/or
+This option allows GCC to violate some ISO or IEEE rules and/or
specifications in the interest of optimizing code for speed. For
example, it allows the compiler to assume arguments to the @code{sqrt}
function are non-negative numbers and that no floating-point values
This option should never be turned on by any @samp{-O} option since
it can result in incorrect output for programs which depend on
-an exact implementation of IEEE or ANSI rules/specifications for
+an exact implementation of IEEE or ISO rules/specifications for
math functions.
@item -fno-math-errno
-fno-delete-null-pointer-checks to disable this optimizing for programs
which depend on that behavior.
-
@item -fexpensive-optimizations
Perform a number of minor optimizations that are relatively expensive.
-@item -foptimize-register-moves
+@item -foptimize-register-move
@itemx -fregmove
Attempt to reassign register numbers in move instructions and as
operands of other simple instructions in order to maximize the amount of
instructions. GCC enables this optimization by default with @samp{-O2}
or higher.
-Note @code{-fregmove} and @code{-foptimize-register-moves} are the same
+Note @code{-fregmove} and @code{-foptimize-register-move} are the same
optimization.
@item -fdelayed-branch
they have helped determine the efficacy of various
approaches to improving loop optimizations.
-Please let us (@code{gcc@@gcc.gnu.org} and @code{fortran@@gnu.org})
+Please let us (@email{gcc@@gcc.gnu.org} and @email{fortran@@gnu.org})
know how use of these options affects
the performance of your production code.
We're very interested in code that runs @emph{slower}
If @var{n} is not specified, use a machine-dependent default.
+@item -fssa
+Perform optimizations in static single assignment form. Each function's
+flow graph is translated into SSA form, optimizations are performed, and
+the flow graph is translated back from SSA form. User's should not
+specify this option, since it is not yet ready for production use.
+
+@item -fdce
+Perform dead-code elimination in SSA form. Requires @samp{-fssa}. Like
+@samp{-fssa}, this is an experimental feature.
+
+@item -fsingle-precision-constant
+Treat floating point constant as single precision constant instead of
+implicitly converting it to double precision constant.
+
+@item -frename-registers
+Attempt to avoid false dependancies in scheduled code by making use
+of registers left over after register allocation. This optimization
+will most benefit processors with lots of registers. It can, however,
+make debugging impossible, since variables will no longer stay in
+a ``home register''.
@end table
@node Preprocessor Options
Only @samp{#define @var{name}} is included in the output.
@item -trigraphs
-Support ANSI C trigraphs. The @samp{-ansi} option also has this effect.
+Support ISO C trigraphs. The @samp{-ansi} option also has this effect.
@item -Wp,@var{option}
Pass @var{option} as an option to the preprocessor. If @var{option}
Only the libraries you specify will be passed to the linker.
The standard startup files are used normally, unless @code{-nostartfiles}
is used. The compiler may generate calls to memcmp, memset, and memcpy
-for System V (and ANSI C) environments or to bcopy and bzero for
+for System V (and ISO C) environments or to bcopy and bzero for
BSD environments. These entries are usually resolved by entries in
libc. These entry points should be supplied through some other
mechanism when this option is specified.
Do not use the standard system startup files or libraries when linking.
No startup files and only the libraries you specify will be passed to
the linker. The compiler may generate calls to memcmp, memset, and memcpy
-for System V (and ANSI C) environments or to bcopy and bzero for
+for System V (and ISO C) environments or to bcopy and bzero for
BSD environments. These entries are usually resolved by entries in
libc. These entry points should be supplied through some other
mechanism when this option is specified.
@item -shared
Produce a shared object which can then be linked with other objects to
-form an executable. Not all systems support this option. You must
-also specify @samp{-fpic} or @samp{-fPIC} on some systems when
-you specify this option.
+form an executable. Not all systems support this option. For predictable
+results, you must also specify the same set of options that were used to
+generate code (@samp{-fpic}, @samp{-fPIC}, or model suboptions)
+when you specify this option.@footnote{On some systems, @code{gcc -shared}
+needs to build supplementary stub code for constructors to work. On
+multi-libbed systems, @code{gcc -shared} must select the correct support
+libraries to link against. Failing to supply the correct flags may lead
+to subtle defects. Supplying them in cases where they are not necessary
+is innocuous.}
@item -symbolic
Bind references to global symbols when building a shared object. Warn
are processed in order, from left to right.
@end table
+@c man end
+
@node Spec Files
@section Specifying subprocesses and the switches to pass to them
@cindex Spec Files
@item %P
Like @samp{%p}, but puts @samp{__} before and after the name of each
predefined macro, except for macros that start with @samp{__} or with
-@samp{_@var{L}}, where @var{L} is an uppercase letter. This is for ANSI
+@samp{_@var{L}}, where @var{L} is an uppercase letter. This is for ISO
C.
@item %I
Like %@{@code{S}*@}, but don't put a blank between a switch and its
argument. Thus %@{^o*@} would only generate one argument, not two.
+@item %@{<@code{S}@}
+Remove all occurrences of @code{-S} from the command line. Note - this
+command is position dependent. @samp{%} commands in the spec string
+before this option will see @code{-S}, @samp{%} commands in the spec
+string after this option will not.
+
@item %@{@code{S}*:@code{X}@}
Substitutes @code{X} if one or more switches whose names start with
@code{-S} are specified to GCC. Note that the tail part of the
treated as compiler output files, and passed to the linker in their
proper position among the other output files.
+@c man begin OPTIONS
+
@node Target Options
@section Specifying Target Machine and Compiler Version
@cindex target options
executables (preprocessor, compiler per se, assembler and linker)
that do the real work. However, since no real work is done in the
driver program, it usually does not matter that the driver program
-in use is not the one for the specified target and version.
+in use is not the one for the specified target. It is common for the
+interface to the other executables to change incompatibly between
+compiler versions, so unless the version specified is very close to that
+of the driver (for example, @samp{-V 3.0} with a driver program from GCC
+version 3.0.1), use of @samp{-V} may not work; for example, using
+@samp{-V 2.95.2} will not work with a driver program from GCC 3.0.
The only way that the driver program depends on the target machine is
in the parsing and handling of special machine-specific options.
However, this is controlled by a file which is found, along with the
other executables, in the directory for the specified version and
target machine. As a result, a single installed driver program adapts
-to any specified target machine and compiler version.
+to any specified target machine, and sufficiently similar compiler
+versions.
The driver program executable does control one significant thing,
however: the default version and target machine. Therefore, you can
@menu
* M680x0 Options::
+* M68hc1x Options::
* VAX Options::
* SPARC Options::
* Convex Options::
* V850 Options::
* ARC Options::
* NS32K Options::
+* AVR Options::
+* MCore Options::
+* D30V Options::
@end menu
@node M680x0 Options
not presently supported with -mpcrel, though this could be supported for
68020 and higher processors.
+@item -mno-strict-align
+@itemx -mstrict-align
+@kindex -mstrict-align
+Do not (do) assume that unaligned memory references will be handled by
+the system.
+
+@end table
+
+@node M68hc1x Options
+@subsection M68hc1x Options
+@cindex M68hc1x options
+
+These are the @samp{-m} options defined for the 68hc11 and 68hc12
+microcontrollers. The default values for these options depends on
+which style of microcontroller was selected when the compiler was configured;
+the defaults for the most common choices are given below.
+
+@table @code
+@item -m6811
+@itemx -m68hc11
+Generate output for a 68HC11. This is the default
+when the compiler is configured for 68HC11-based systems.
+
+@item -m6812
+@itemx -m68hc12
+Generate output for a 68HC12. This is the default
+when the compiler is configured for 68HC12-based systems.
+
+@item -mauto-incdec
+Enable the use of 68HC12 pre and post auto-increment and auto-decrement
+addressing modes.
+
+@item -mshort
+Consider type @code{int} to be 16 bits wide, like @code{short int}.
+
+@item -msoft-reg-count=@var{count}
+Specify the number of pseudo-soft registers which are used for the
+code generation. The maximum number is 32. Using more pseudo-soft
+register may or may not result in better code depending on the program.
+The default is 4 for 68HC11 and 2 for 68HC12.
+
@end table
@node VAX Options
generated by other compilers. It is not the default because it results
in a performance loss, especially for floating point code.
+@item -mno-faster-structs
+@itemx -mfaster-structs
+With @samp{-mfaster-structs}, the compiler assumes that structures
+should have 8 byte alignment. This enables the use of pairs of
+@code{ldd} and @code{std} instructions for copies in structure
+assignment, in place of twice as many @code{ld} and @code{st} pairs.
+However, the use of this changed alignment directly violates the Sparc
+ABI. Thus, it's intended only for use on targets where the developer
+acknowledges that their resulting code will not be directly in line with
+the rules of the ABI.
+
@item -mv8
@itemx -msparclite
These two options select variations on the SPARC architecture.
big-endian ARM processors generated by versions of the compiler prior to
2.8.
+@item -malignment-traps
+@kindex -malignment-traps
+Generate code that will not trap if the MMU has alignment traps enabled.
+On ARM architectures prior to ARMv4, there were no instructions to
+access half-word objects stored in memory. However, when reading from
+memory a feature of the ARM architecture allows a word load to be used,
+even if the address is unaligned, and the processor core will rotate the
+data as it is being loaded. This option tells the compiler that such
+misaligned accesses will cause a MMU trap and that it should instead
+synthesise the access as a series of byte accesses. The compiler can
+still use word accesses to load half-word data if it knows that the
+address is aligned to a word boundary.
+
+This option is ignored when compiling for ARM architecture 4 or later,
+since these processors have instructions to directly access half-word
+objects in memory.
+
+@item -mno-alignment-traps
+@kindex -mno-alignment-traps
+Generate code that assumes that the MMU will not trap unaligned
+accesses. This produces better code when the target instruction set
+does not have half-word memory operations (implementations prior to
+ARMv4).
+
+Note that you cannot use this option to access unaligned word objects,
+since the processor will only fetch one 32-bit aligned object from
+memory.
+
+The default setting for most targets is -mno-alignment-traps, since
+this produces better code when there are no half-word memory
+instructions available.
+
@item -mshort-load-bytes
@kindex -mshort-load-bytes
-Do not try to load half-words (eg @samp{short}s) by loading a word from
-an unaligned address. For some targets the MMU is configured to trap
-unaligned loads; use this option to generate code that is safe in these
-environments.
+This is a deprecated alias for @samp{-malignment-traps}.
@item -mno-short-load-bytes
@kindex -mno-short-load-bytes
-Use unaligned word loads to load half-words (eg @samp{short}s). This
-option produces more efficient code, but the MMU is sometimes configured
-to trap these instructions.
+This is a deprecated alias for @samp{-mno-alignment-traps}.
@item -mshort-load-words
@kindex -mshort-load-words
-This is a synonym for @samp{-mno-short-load-bytes}.
+This is a deprecated alias for @samp{-mno-alignment-traps}.
@item -mno-short-load-words
@kindex -mno-short-load-words
-This is a synonym for @samp{-mshort-load-bytes}.
+This is a deprecated alias for @samp{-malignment-traps}.
@item -mbsd
@kindex -mbsd
@itemx -mfp=<number>
@kindex -mfpe=
@kindex -mfp=
-This specifes the version of the floating point emulation available on
+This specifies the version of the floating point emulation available on
the target. Permissible values are 2 and 3. @samp{-mfp=} is a synonym
for @samp{-mfpe=} to support older versions of GCC.
Generate a call to the function abort at the end of a noreturn function.
It will be executed if the function tries to return.
+@item -mlong-calls
+@itemx -mno-long-calls
+Tells the compiler to perform function calls by first loading the
+address of the function into a register and then performing a subroutine
+call on this register. This switch is needed if the target function
+will lie outside of the 64 megabyte addressing range of the offset based
+version of subroutine call instruction.
+
+Even if this switch is enabled, not all function calls will be turned
+into long calls. The heuristic is that static functions, functions
+which have the @samp{short-call} attribute, functions that are inside
+the scope of a @samp{#pragma no_long_calls} directive and functions whose
+definitions have already been compiled within the current compilation
+unit, will not be turned into long calls. The exception to this rule is
+that weak function definitions, functions with the @samp{long-call}
+attribute or the @samp{section} attribute, and functions that are within
+the scope of a @samp{#pragma long_calls} directive, will always be
+turned into long calls.
+
+This feature is not enabled by default. Specifying
+@samp{--no-long-calls} will restore the default behaviour, as will
+placing the function calls within the scope of a @samp{#pragma
+long_calls_off} directive. Note these switches have no effect on how
+the compiler generates code to handle function calls via function
+pointers.
+
@item -mnop-fun-dllimport
@kindex -mnop-fun-dllimport
Disable the support for the @emph{dllimport} attribute.
Do not generate code to avoid bugs in the multiply instructions for the
MN10300 processors.
+@item -mam33
+Generate code which uses features specific to the AM33 processor.
+
+@item -mno-am33
+Do not generate code which uses features specific to the AM33 processor. This
+is the default.
+
@item -mrelax
Indicate to the linker that it should perform a relaxation optimization pass
to shorten branches, calls and absolute memory addresses. This option only
uses extremely little TOC space. You may wish to use this option
only on files that contain less frequently executed code. @refill
-@item -m64
-@itemx -m32
-@kindex -m64
-@kindex -m32
-Enable 64-bit PowerPC ABI and calling convention: 64-bit pointers, 64-bit
+@item -maix64
+@itemx -maix32
+@kindex -maix64
+@kindex -maix32
+Enable 64-bit AIX ABI and calling convention: 64-bit pointers, 64-bit
@code{long} type, and the infrastructure needed to support them.
-Specifying @samp{-m64} implies @samp{-mpowerpc64} and
-@samp{-mpowerpc}, while @samp{-m32} disables the 64-bit ABI and
-implies @samp{-mno-powerpc64}. GCC defaults to @samp{-m32}.
+Specifying @samp{-maix64} implies @samp{-mpowerpc64} and
+@samp{-mpowerpc}, while @samp{-maix32} disables the 64-bit ABI and
+implies @samp{-mno-powerpc64}. GCC defaults to @samp{-maix32}.
@item -mxl-call
@itemx -mno-xl-call
@file{crt0.o} and the standard C libraries are @file{libyk.a} and
@file{libc.a}.
+@item -mvxworks
+On System V.4 and embedded PowerPC systems, specify that you are
+compiling for a VxWorks system.
+
@item -memb
On embedded PowerPC systems, set the @var{PPC_EMB} bit in the ELF flags
header to indicate that @samp{eabi} extended relocations are used.
Force long, int, and pointer types to be 32 bits wide.
If none of @samp{-mlong32}, @samp{-mlong64}, or @samp{-mint64} are set,
-the size of ints, longs, and pointers depends on the ABI and ISA choosen.
+the size of ints, longs, and pointers depends on the ABI and ISA chosen.
For @samp{-mabi=32}, and @samp{-mabi=n32}, ints and longs are 32 bits
wide. For @samp{-mabi=64}, ints are 32 bits, and longs are 64 bits wide.
For @samp{-mabi=eabi} and either @samp{-mips1} or @samp{-mips2}, ints
slightly slower code than the default, but reduces the amount of RAM required
when executing, and thus may be preferred for some embedded systems.
+@item -muninit-const-in-rodata
+@itemx -mno-uninit-const-in-rodata
+When used together with -membedded-data, it will always store uninitialized
+const variables in the read-only data section.
+
@item -msingle-float
@itemx -mdouble-float
The @samp{-msingle-float} switch tells gcc to assume that the floating
@item -nocpp
Tell the MIPS assembler to not run its preprocessor over user
assembler files (with a @samp{.s} suffix) when assembling them.
+
+@item -mfix7000
+Pass an option to gas which will cause nops to be inserted if
+the read of the destination register of an mfhi or mflo instruction
+occurs in the following two instructions.
+
+@item -no-crt0
+Do not include the default crt0.
@end table
@ifset INTERNALS
@table @code
@item -mcpu=@var{cpu type}
Assume the defaults for the machine type @var{cpu type} when scheduling
-instructions. The choices for @var{cpu type} are:
-
-@multitable @columnfractions .20 .20 .20 .20
-@item @samp{i386} @tab @samp{i486} @tab @samp{i586} @tab @samp{i686}
-@item @samp{pentium} @tab @samp{pentiumpro} @tab @samp{k6}
-@end multitable
+instructions. The choices for @var{cpu type} are @samp{i386},
+@samp{i486}, @samp{i586}, @samp{i686}, @samp{pentium},
+@samp{pentiumpro}, @samp{k6}, and @samp{athlon}
While picking a specific @var{cpu type} will schedule things appropriately
for that particular chip, the compiler will not generate any code that
Synonyms for -mcpu=i386, -mcpu=i486, -mcpu=pentium, and -mcpu=pentiumpro
respectively. These synonyms are deprecated.
+@item -mintel-syntax
+Emit assembly using Intel syntax opcodes instead of AT&T syntax.
+
@item -mieee-fp
@itemx -mno-ieee-fp
Control whether or not the compiler uses IEEE floating point
and PentiumPro, @code{double} and @code{long double} values should be
aligned to an 8 byte boundary (see @samp{-malign-double}) or suffer
significant run time performance penalties. On Pentium III, the
-Streaming SIMD Extention (SSE) data type @code{__m128} suffers similar
+Streaming SIMD Extension (SSE) data type @code{__m128} suffers similar
penalties if it is not 16 byte aligned.
To ensure proper alignment of this values on the stack, the stack boundary
to stack space usage, such as embedded systems and operating system kernels,
may want to reduce the preferred alignment to
@samp{-mpreferred-stack-boundary=2}.
+
+@item -mpush-args
+@kindex -mpush-args
+Use PUSH operations to store outgoing parameters. This method is shorter
+and usually equally fast as method using SUB/MOV operations and is enabled
+by default. In some cases disabling it may improve performance because of
+improved scheduling and reduced dependencies.
+
+@item -maccumulate-outgoing-args
+@kindex -maccumulate-outgoing-args
+If enabled, the maximum amount of space required for outgoing arguments will be
+computed in the function prologue. This in faster on most modern CPUs
+because of reduced dependencies, improved scheduling and reduced stack usage
+when preferred stack boundary is not equal to 2. The drawback is a notable
+increase in code size. This switch implies -mno-push-args.
+
+@item -mthreads
+@kindex -mthreads
+Support thread-safe exception handling on @samp{Mingw32}. Code that relies
+on thread-safe exception handling must compile and link all code with the
+@samp{-mthreads} option. When compiling, @samp{-mthreads} defines
+@samp{-D_MT}; when linking, it links in a special thread helper library
+@samp{-lmingwthrd} which cleans up per thread exception handling data.
+
+@item -mno-align-stringops
+@kindex -mno-align-stringops
+Do not align destination of inlined string operations. This switch reduces
+code size and improves performance in case the destination is already aligned,
+but gcc don't know about it.
+
+@item -minline-all-stringops
+@kindex -minline-all-stringops
+By default GCC inlines string operations only when destination is known to be
+aligned at least to 4 byte boundary. This enables more inlining, increase code
+size, but may improve performance of code that depends on fast memcpy, strlen
+and memset for short lengths.
@end table
@node HPPA Options
Generate code that assumes calls never cross space boundaries. This
allows GCC to emit code which performs faster indirect calls.
-This option will not work in the presense of shared libraries or nested
+This option will not work in the presence of shared libraries or nested
functions.
@item -mlong-load-store
@item -mmemory-latency=@var{time}
Sets the latency the scheduler should assume for typical memory
references as seen by the application. This number is highly
-dependant on the memory access patterns used by the application
+dependent on the memory access patterns used by the application
and the size of the external cache on the machine.
Valid options for @var{time} are
@item -ms
Generate code for the H8/S.
+@item -ms2600
+Generate code for the H8/S2600. This switch must be used with -ms.
+
@item -mint32
Make @code{int} data 32 bits by default.
@item -malign-300
-On the h8/300h, use the same alignment rules as for the h8/300.
-The default for the h8/300h is to align longs and floats on 4 byte boundaries.
+On the H8/300H and H8/S, use the same alignment rules as for the H8/300.
+The default for the H8/300H and H8/S is to align longs and floats on 4
+byte boundaries.
@samp{-malign-300} causes them to be aligned on 2 byte boundaries.
-This option has no effect on the h8/300.
+This option has no effect on the H8/300.
@end table
@node SH Options
@item -m3e
Generate code for the SH3e.
+@item -m4-nofpu
+Generate code for the SH4 without a floating-point unit.
+
+@item -m4-single-only
+Generate code for the SH4 with a floating-point unit that only
+supports single-precision arithmentic.
+
+@item -m4-single
+Generate code for the SH4 assuming the floating-point unit is in
+single-precision mode by default.
+
+@item -m4
+Generate code for the SH4.
+
@item -mb
Compile code for the processor in big endian mode.
@item -mrelax
Shorten some address references at link time, when possible; uses the
linker option @samp{-relax}.
+
+@item -mbigtable
+Use 32-bit offsets in @code{switch} tables. The default is to use
+16-bit offsets.
+
+@item -mfmovd
+Enable the use of the instruction @code{fmovd}.
+
+@item -mhitachi
+Comply with the calling conventions defined by Hitachi.
+
+@item -mnomacsave
+Mark the @code{MAC} register as call-clobbered, even if
+@code{-mhitachi} is given.
+
+@item -misize
+Dump instruction size and location in the assembly code.
+
+@item -mpadstruct
+This option is deprecated. It pads structures to multiple of 4 bytes,
+which is incompatible with the SH ABI.
+
+@item -mspace
+Optimize for space instead of speed. Implied by @code{-Os}.
+
+@item -mprefergot
+When generating position-independent code, emit function calls using
+the Global Offset Table instead of the Procedure Linkage Table.
+
+@item -musermode
+Generate a library function call to invalidate instruction cache
+entries, after fixing up a trampoline. This library function call
+doesn't assume it can write to the whole memory address space. This
+is the default when the target is @code{sh-*-linux*}.
@end table
@node System V Options
then a RPTS will be emitted even if the loop count cannot be determined
at compile time. Note that the repeated instruction following RPTS does
not have to be reloaded from memory each iteration, thus freeing up the
-CPU buses for oeprands. However, since interrupts are blocked by this
+CPU buses for operands. However, since interrupts are blocked by this
instruction, it is disabled by default.
@item -mloop-unsigned
@end table
+@node AVR Options
+@subsection AVR Options
+@cindex AVR Options
+
+These options are defined for AVR implementations:
+
+@table @code
+@item -mmcu=@var{mcu}
+Specify ATMEL AVR instruction set or MCU type.
+
+Instruction set avr1 is for the minimal AVR core, not supported by the C
+compiler, only for assembler programs (MCU types: at90s1200, attiny10,
+attiny11, attiny12, attiny15, attiny28).
+
+Instruction set avr2 (default) is for the classic AVR core with up to
+8K program memory space (MCU types: at90s2313, at90s2323, attiny22,
+at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90s8515,
+at90c8534, at90s8535).
+
+Instruction set avr3 is for the classic AVR core with up to 128K program
+memory space (MCU types: atmega103, atmega603).
+
+Instruction set avr4 is for the enhanced AVR core with up to 8K program
+memory space (MCU types: atmega83, atmega85).
+
+Instruction set avr5 is for the enhanced AVR core with up to 128K program
+memory space (MCU types: atmega161, atmega163, atmega32, at94k).
+
+@item -msize
+Output instruction sizes to the asm file.
+
+@item -minit-stack=@var{N}
+Specify the initial stack address, which may be a symbol or numeric value,
+__stack is the default.
+
+@item -mno-interrupts
+Generated code is not compatible with hardware interrupts.
+Code size will be smaller.
+
+@item -mcall-prologues
+Functions prologues/epilogues expanded as call to appropriate
+subroutines. Code size will be smaller.
+
+@item -mno-tablejump
+Do not generate tablejump insns which sometimes increase code size.
+
+@item -mtiny-stack
+Change only the low 8 bits of the stack pointer.
+@end table
+
+@node MCore Options
+@subsection MCore Options
+@cindex MCore options
+
+These are the @samp{-m} options defined for the Motorola M*Core
+processors.
+
+@table @code
+
+@item -mhardlit
+@itemx -mhardlit
+@itemx -mno-hardlit
+Inline constants into the code stream if it can be done in two
+instructions or less.
+
+@item -mdiv
+@itemx -mdiv
+@itemx -mno-div
+Use the divide instruction. (Enabled by default).
+
+@item -mrelax-immediate
+@itemx -mrelax-immediate
+@itemx -mno-relax-immediate
+Allow arbitrary sized immediates in bit operations.
+
+@item -mwide-bitfields
+@itemx -mwide-bitfields
+@itemx -mno-wide-bitfields
+Always treat bitfields as int-sized.
+
+@item -m4byte-functions
+@itemx -m4byte-functions
+@itemx -mno-4byte-functions
+Force all functions to be aligned to a four byte boundary.
+
+@item -mcallgraph-data
+@itemx -mcallgraph-data
+@itemx -mno-callgraph-data
+Emit callgraph information.
+
+@item -mslow-bytes
+@itemx -mslow-bytes
+@itemx -mno-slow-bytes
+Prefer word access when reading byte quantities.
+
+@item -mlittle-endian
+@itemx -mlittle-endian
+@itemx -mbig-endian
+Generate code for a little endian target.
+
+@item -m210
+@itemx -m210
+@itemx -m340
+Generate code for the 210 processor.
+@end table
+
+@node D30V Options
+@subsection D30V Options
+@cindex D30V Options
+
+These @samp{-m} options are defined for D30V implementations:
+@table @code
+@item -mextmem
+Link the @samp{.text}, @samp{.data}, @samp{.bss}, @samp{.strings},
+@samp{.rodata}, @samp{.rodata1}, @samp{.data1} sections into external
+memory, which starts at location @code{0x80000000}.
+
+@item -mextmemory
+Same as the @samp{-mextmem} switch.
+
+@item -monchip
+Link the @samp{.text} section into onchip text memory, which starts at
+location @code{0x0}. Also link @samp{.data}, @samp{.bss},
+@samp{.strings}, @samp{.rodata}, @samp{.rodata1}, @samp{.data1} sections
+into onchip data memory, which starts at location @code{0x20000000}.
+
+@item -mno-asm-optimize
+@itemx -masm-optimize
+Disable (enable) passing @samp{-O} to the assembler when optimizing.
+The assembler uses the @samp{-O} option to automatically parallelize
+adjacent short instructions where possible.
+
+@item -mbranch-cost=@var{n}
+Increase the internal costs of branches to @var{n}. Higher costs means
+that the compiler will issue more instructions to avoid doing a branch.
+The default is 2.
+
+@item -mcond-exec=@var{n}
+Specify the maximum number of conditionally executed instructions that
+replace a branch. The default is 4.
+@end table
@node Code Gen Options
@section Options for Code Generation Conventions
@code{__asm__} keywords in functions with memory checking enabled. GNU
CC cannot understand what the @code{asm} statement may do, and therefore
cannot generate the appropriate code, so it will reject it. However, if
-you specify the function attribute @code{no_check_memory_usage} (see
-@pxref{Function Attributes}, GNU CC will disable memory checking within a
+you specify the function attribute @code{no_check_memory_usage}
+(@pxref{Function Attributes}), GNU CC will disable memory checking within a
function; you may use @code{asm} statements inside such functions. You
may have an inline expansion of a non-checked function within a checked
function; in that case GNU CC will not generate checks for the inlined
a single-threaded environment since stack overflow is automatically
detected on nearly all systems if there is only one stack.
+Note that this switch does not actually cause checking to be done; the
+operating system must do that. The switch causes generation of code
+to ensure that the operating system sees the stack being extended.
+
+@item -fstack-limit-register=@var{reg}
+@itemx -fstack-limit-symbol=@var{sym}
+@itemx -fno-stack-limit
+Generate code to ensure that the stack does not grow beyond a certain value,
+either the value of a register or the address of a symbol. If the stack
+would grow beyond the value, a signal is raised. For most targets,
+the signal is raised before the stack overruns the boundary, so
+it is possible to catch the signal without taking special precautions.
+
+For instance, if the stack starts at address @samp{0x80000000} and grows
+downwards you can use the flags
+@samp{-fstack-limit-symbol=__stack_limit}
+@samp{-Wl,--defsym,__stack_limit=0x7ffe0000} which will enforce a stack
+limit of 128K.
+
@cindex aliasing of parameters
@cindex parameters, aliased
@item -fargument-alias
option, and that not all targets provide complete support for it.
@end table
+@c man end
+
@node Environment Variables
@section Environment Variables Affecting GCC
@cindex environment variables
+@c man begin ENVIRONMENT
+
This section describes several environment variables that affect how GCC
operates. Some of them work by specifying directories or prefixes to use
when searching for various kinds of files. Some are used to specify other
recognize and translate multibyte characters.
@end table
+@c man end
+
@node Running Protoize
@section Running Protoize
The program @code{protoize} is an optional part of GNU C. You can use
-it to add prototypes to a program, thus converting the program to ANSI
+it to add prototypes to a program, thus converting the program to ISO
C in one respect. The companion program @code{unprotoize} does the
reverse: it removes argument types from any prototypes that are found.
Basic conversion with @code{unprotoize} consists of rewriting most
function declarations to remove any argument types, and rewriting
-function definitions to the old-style pre-ANSI form.
+function definitions to the old-style pre-ISO form.
Both conversion programs print a warning for any function declaration or
definition that they can't convert. You can suppress these warnings
The output from @code{protoize} or @code{unprotoize} replaces the
original source file. The original file is renamed to a name ending
-with @samp{.save}. If the @samp{.save} file already exists, then
-the source file is simply discarded.
+with @samp{.save} (for DOS, the saved filename ends in @samp{.sav}
+without the original @samp{.c} suffix). If the @samp{.save} (@samp{.sav}
+for DOS) file already exists, then the source file is simply discarded.
@code{protoize} and @code{unprotoize} both depend on GCC itself to
scan the program and collect information about the functions it uses.
the @var{compilation-options}, they are ignored.
@item -C
-Rename files to end in @samp{.C} instead of @samp{.c}.
-This is convenient if you are converting a C program to C++.
-This option applies only to @code{protoize}.
+Rename files to end in @samp{.C} (@samp{.cc} for DOS-based file
+systems) instead of @samp{.c}. This is convenient if you are converting
+a C program to C++. This option applies only to @code{protoize}.
@item -g
Add explicit global declarations. This means inserting explicit
OSDN Git Service
