-@c Copyright (C) 1988, 89, 92, 93, 94, 1995, 1996 Free Software Foundation, Inc.
+@c Copyright (C) 1988,89,92,93,94,95,96,97,1998 Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@item Overall Options
@xref{Overall Options,,Options Controlling the Kind of Output}.
@smallexample
--c -S -E -o @var{file} -pipe -v -x @var{language}
+-c -S -E -o @var{file} -pipe -v --help -x @var{language}
@end smallexample
@item C Language Options
@xref{C Dialect Options,,Options Controlling C Dialect}.
@smallexample
--ansi -fallow-single-precision -fcond-mismatch -fno-asm
--fno-builtin -fsigned-bitfields -fsigned-char
+-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
@end smallexample
@item C++ Language Options
@xref{C++ Dialect Options,,Options Controlling C++ Dialect}.
@smallexample
--fall-virtual -fdollars-in-identifiers -felide-constructors
--fenum-int-equiv -fexternal-templates -ffor-scope -fno-for-scope
--fhandle-signatures -fmemoize-lookups -fno-default-inline -fno-gnu-keywords
--fnonnull-objects -foperator-names -fstrict-prototype
--fthis-is-variable -nostdinc++ -traditional +e@var{n}
+-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 -fhandle-signatures
+-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 -frepo -fstrict-prototype
+-fsquangle -ftemplate-depth-@var{n} -fthis-is-variable -fvtable-thunks
+-nostdinc++
@end smallexample
@item Warning Options
@smallexample
-fsyntax-only -pedantic -pedantic-errors
-w -W -Wall -Waggregate-return -Wbad-function-cast
--Wcast-align -Wcast-qual -Wchar-subscript -Wcomment
+-Wcast-align -Wcast-qual -Wchar-subscript -Wcomment
-Wconversion -Werror -Wformat
--Wid-clash-@var{len} -Wimplicit -Wimport -Winline
--Wlarger-than-@var{len} -Wmissing-declarations
--Wmissing-prototypes -Wnested-externs
--Wno-import -Woverloaded-virtual -Wparentheses
--Wpointer-arith -Wredundant-decls -Wreorder -Wreturn-type -Wshadow
--Wsign-compare -Wstrict-prototypes -Wswitch -Wsynth
--Wtemplate-debugging -Wtraditional -Wtrigraphs
--Wuninitialized -Wunused -Wwrite-strings
+-Wid-clash-@var{len} -Wimplicit -Wimplicit-int
+-Wimplicit-function-declaration -Wimport
+-Werror-implicit-function-declaration -Winline
+-Wlarger-than-@var{len} -Wlong-long
+-Wmain -Wmissing-declarations -Wmissing-noreturn
+-Wmissing-prototypes -Wmultichar -Wnested-externs -Wno-import
+-Wno-non-template-friend -Wold-style-cast -Woverloaded-virtual
+-Wparentheses -Wpointer-arith -Wredundant-decls -Wreorder
+-Wreturn-type -Wshadow -Wsign-compare -Wstrict-prototypes
+-Wswitch -Wsynth -Wtraditional
+-Wtrigraphs -Wundef -Wuninitialized -Wunused -Wwrite-strings
+-Wunknown-pragmas
@end smallexample
@item Debugging Options
@xref{Debugging Options,,Options for Debugging Your Program or GCC}.
@smallexample
--a -ax -d@var{letters} -fpretend-float
--g -g@var{level} -gcoff -gdwarf -gdwarf+
+-a -ax -d@var{letters} -fdump-unnumbered -fpretend-float
+-fprofile-arcs -ftest-coverage
+-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
@item Optimization Options
@xref{Optimize Options,,Options that Control Optimization}.
@smallexample
+-fbranch-probabilities -foptimize-register-moves
-fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
-fdelayed-branch -fexpensive-optimizations
-ffast-math -ffloat-store -fforce-addr -fforce-mem
--ffunction-sections -finline-functions
--fkeep-inline-functions -fno-default-inline
--fno-defer-pop -fno-function-cse
--fno-inline -fno-peephole -fomit-frame-pointer
--frerun-cse-after-loop -fschedule-insns
+-fdata-sections -ffunction-sections -fgcse
+-finline-functions -fkeep-inline-functions
+-fno-default-inline -fno-defer-pop -fno-function-cse
+-fno-inline -fno-peephole -fomit-frame-pointer -fregmove
+-frerun-cse-after-loop -frerun-loop-opt -fschedule-insns
-fschedule-insns2 -fstrength-reduce -fthread-jumps
-funroll-all-loops -funroll-loops
--O -O0 -O1 -O2 -O3
+-fmove-all-movables -freduce-all-givs -fstrict-aliasing
+-O -O0 -O1 -O2 -O3 -Os
@end smallexample
@item Preprocessor Options
@item Directory Options
@xref{Directory Options,,Options for Directory Search}.
@smallexample
--B@var{prefix} -I@var{dir} -I- -L@var{dir}
+-B@var{prefix} -I@var{dir} -I- -L@var{dir} -specs=@var{file}
@end smallexample
@item Target Options
@xref{Submodel Options,,Hardware Models and Configurations}.
@smallexample
@emph{M680x0 Options}
--m68000 -m68020 -m68020-40 -m68030 -m68040 -m68060
--m5200 -m68881 -mbitfield -mc68000 -mc68020 -mfpa
--mnobitfield -mrtd -mshort -msoft-float
+-m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
+-m68060 -mcpu32 -m5200 -m68881 -mbitfield -mc68000 -mc68020
+-mfpa -mnobitfield -mrtd -mshort -msoft-float
+-malign-int
@emph{VAX Options}
-mg -mgnu -munix
@emph{SPARC Options}
--mcpu=@var{cpu type}
--mtune=@var{cpu type}
+-mcpu=@var{cpu type}
+-mtune=@var{cpu type}
+-mcmodel=@var{code model}
+-malign-jumps=@var{num} -malign-loops=@var{num}
+-malign-functions=@var{num}
+-m32 -m64
-mapp-regs -mbroken-saverestore -mcypress -mepilogue
--mflat -mfpu -mfullany -mhard-float -mhard-quad-float
--mimpure-text -mint32 -mint64 -mlive-g0
--mlong32 -mlong64 -mmedlow -mmedany
--mno-app-regs -mno-epilogue
+-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
-msoft-float -msoft-quad-float -msparclite -mstack-bias
-mstorem-bug -muser-registers
@emph{ARM Options}
--mapcs-frame -mapcs-26 -mapcs-32
+-mapcs-frame -mno-apcs-frame
+-mapcs-26 -mapcs-32
+-mapcs-stack-check -mno-apcs-stack-check
+-mapcs-float -mno-apcs-float
+-mapcs-reentrant -mno-apcs-reentrant
+-msched-prolog -mno-sched-prolog
-mlittle-endian -mbig-endian -mwords-little-endian
--mshort-load-bytes -mno-short-load-bytes
--msoft-float -mhard-float
+-mshort-load-bytes -mno-short-load-bytes -mshort-load-words -mno-short-load-words
+-msoft-float -mhard-float -mfpe
+-mthumb-interwork -mno-thumb-interwork
+-mcpu= -march= -mfpe=
+-mstructure-size-boundary=
-mbsd -mxopen -mno-symrename
+@emph{Thumb Options}
+-mtpcs-frame -mno-tpcs-frame
+-mtpcs-leaf-frame -mno-tpcs-leaf-frame
+-mlittle-endian -mbig-endian
+-mthumb-interwork -mno-thumb-interwork
+-mstructure-size-boundary=
+
+@emph{MN10200 Options}
+-mrelax
+
+@emph{MN10300 Options}
+-mmult-bug
+-mno-mult-bug
+-mrelax
+
+@emph{M32R/D Options}
+-mcode-model=@var{model type} -msdata=@var{sdata type}
+-G @var{num}
+
@emph{M88K Options}
-m88000 -m88100 -m88110 -mbig-pic
-mcheck-zero-division -mhandle-large-shift
-mversion-03.00 -mwarn-passed-structs
@emph{RS/6000 and PowerPC Options}
--mcpu=@var{cpu type}
--mtune=@var{cpu type}
+-mcpu=@var{cpu type}
+-mtune=@var{cpu type}
-mpower -mno-power -mpower2 -mno-power2
-mpowerpc -mno-powerpc
-mpowerpc-gpopt -mno-powerpc-gpopt
-mpowerpc-gfxopt -mno-powerpc-gfxopt
-mnew-mnemonics -mno-new-mnemonics
-mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc
--mxl-call -mno-xl-call
+-maix64 -maix32 -mxl-call -mno-xl-call -mthreads -mpe
-msoft-float -mhard-float -mmultiple -mno-multiple
--mstring -mno-string -mbit-align -mno-bit-align
+-mstring -mno-string -mupdate -mno-update
+-mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
-mstrict-align -mno-strict-align -mrelocatable
-mno-relocatable -mrelocatable-lib -mno-relocatable-lib
--mtoc -mno-toc -mtraceback -mno-traceback
--mlittle -mlittle-endian -mbig -mbig-endian
+-mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
-mcall-aix -mcall-sysv -mprototype -mno-prototype
--msim -mmvme -memb -msdata -msdata=@var{opt} -G @var{num}
+-msim -mmvme -mads -myellowknife -memb -msdata
+-msdata=@var{opt} -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
-membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64
--mgpopt -mhalf-pic -mhard-float -mint64 -mips1
--mips2 -mips3 -mlong64 -mlong-calls -mmemcpy
+-mgpopt -mhalf-pic -mhard-float -mint64 -mips1
+-mips2 -mips3 -mips4 -mlong64 -mlong-calls -mmemcpy
-mmips-as -mmips-tfile -mno-abicalls
-mno-embedded-data -mno-embedded-pic
-mno-gpopt -mno-long-calls
-mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats
--mrnames -msoft-float
--m4650 -msingle-float -mmad
+-mrnames -msoft-float
+-m4650 -msingle-float -mmad
-mstats -EL -EB -G @var{num} -nocpp
+-mabi=32 -mabi=n32 -mabi=64 -mabi=eabi
@emph{i386 Options}
--m486 -m386 -mieee-fp -mno-fancy-math-387
+-mcpu=@var{cpu type}
+-march=@var{cpu type}
+-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}
+-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}
@emph{HPPA Options}
--mdisable-fpregs -mdisable-indexing -mfast-indirect-calls
--mgas -mjump-in-delay -mlong-load-store -mno-disable-fpregs
--mno-disable-indexing -mno-fast-indirect-calls -mno-gas
--mno-jump-in-delay
--mno-long-load-store
--mno-portable-runtime -mno-soft-float -mno-space -mno-space-regs -msoft-float
--mpa-risc-1-0 -mpa-risc-1-1 -mportable-runtime
--mschedule=@var{list} -mspace -mspace-regs
+-mbig-switch -mdisable-fpregs -mdisable-indexing
+-mfast-indirect-calls -mgas -mjump-in-delay
+-mlong-load-store -mno-big-switch -mno-disable-fpregs
+-mno-disable-indexing -mno-fast-indirect-calls -mno-gas
+-mno-jump-in-delay -mno-long-load-store
+-mno-portable-runtime -mno-soft-float -mno-space
+-mno-space-regs -msoft-float -mpa-risc-1-0
+-mpa-risc-1-1 -mportable-runtime
+-mschedule=@var{list} -mspace -mspace-regs
@emph{Intel 960 Options}
-m@var{cpu type} -masm-compat -mclean-linkage
-mtail-call
@emph{DEC Alpha Options}
--mfp-regs -mno-fp-regs
--mno-soft-float -msoft-float
--mieee -mieee-with-inexact -mieee-conformant
--mfp-trap-mode -mfp-rounding-mode -mtrap-precision
--mbuild-constants
+-mfp-regs -mno-fp-regs -mno-soft-float -msoft-float
+-malpha-as -mgas
+-mieee -mieee-with-inexact -mieee-conformant
+-mfp-trap-mode=@var{mode} -mfp-rounding-mode=@var{mode}
+-mtrap-precision=@var{mode} -mbuild-constants
+-mcpu=@var{cpu type}
+-mbwx -mno-bwx -mcix -mno-cix -mmax -mno-max
+-mmemory-latency=@var{time}
@emph{Clipper Options}
--mc300 -mc400
+-mc300 -mc400
@emph{H8/300 Options}
--mrelax -mh -mint32 -malign-300
+-mrelax -mh -ms -mint32 -malign-300
@emph{SH Options}
--m1 -m2 -m3 -m3e -mb -ml -mrelax
+-m1 -m2 -m3 -m3e -mb -ml -mdalign -mrelax
@emph{System V Options}
-Qy -Qn -YP,@var{paths} -Ym,@var{dir}
+
+@emph{ARC Options}
+-EB -EL
+-mmangle-cpu -mcpu=@var{cpu} -mtext=@var{text section}
+-mdata=@var{data section} -mrodata=@var{readonly data section}
+
+@emph{V850 Options}
+-mlong-calls -mno-long-calls -mep -mno-ep
+-mprolog-function -mno-prolog-function -mspace
+-mtda=@var{n} -msda=@var{n} -mzda=@var{n}
+-mv850 -mbig-switch
+
+@emph{NS32K Options}
+-m32032 -m32332 -m32532 -m32081 -m32381 -mmult-add -mnomult-add
+-msoft-float -mrtd -mnortd -mregparam -mnoregparam -msb -mnosb
+-mbitfield -mnobitfield -mhimem -mnohimem
@end smallexample
@item Code Generation Options
@xref{Code Gen Options,,Options for Code Generation Conventions}.
@smallexample
-fcall-saved-@var{reg} -fcall-used-@var{reg}
--ffixed-@var{reg} -finhibit-size-directive
+-fexceptions -ffixed-@var{reg} -finhibit-size-directive
+-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
--fverbose-asm -fpack-struct +e0 +e1
+-fverbose-asm -fpack-struct -fstack-check
+-fargument-alias -fargument-noalias
+-fargument-noalias-global
+-fleading-underscore
@end smallexample
@end table
various stages of compilation. This fails to work on some systems where
the assembler is unable to read from a pipe; but the GNU assembler has
no trouble.
+
+@item --help
+Print (on the standard output) a description of the command line options
+understood by @code{gcc}. If the @code{-v} option is also specified
+then @code{--help} will also be passed on to the various processes
+invoked by @code{gcc}, so that they can display the command line options
+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.
@end table
@node Invoking G++
circumstances, you might want to compile programs from standard input,
or otherwise without a suffix that flags them as C++ programs.
@code{g++} is a program that calls GNU CC with the default language
-set to C++, and automatically specifies linking against the GNU class
-library libg++.
+set to C++, and automatically specifies linking against the C++
+library.
@cindex @code{g++ 1.@var{xx}}
@cindex @code{g++}, separate compiler
@cindex @code{g++} older version
C, such as the @code{asm}, @code{inline} 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, disallows @samp{$} as part of
-identifiers, and disables recognition of C++ style @samp{//} comments.
+rarely used ANSI trigraph feature, and it disables recognition of C++
+style @samp{//} comments.
The alternate keywords @code{__asm__}, @code{__extension__},
@code{__inline__} and @code{__typeof__} continue to work despite
The functions @code{alloca}, @code{abort}, @code{exit}, and
@code{_exit} are not builtin functions when @samp{-ansi} is used.
+@item -flang-isoc9x
+Enable support for features found in the C9X standard. In particular,
+enable support for the C9X @code{restrict} keyword.
+
+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 -fno-asm
Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
keyword, so that code can use these words as identifiers. You can use
@findex strcmp
@findex strcpy
@findex strlen
-Don't recognize builtin functions that do not begin with two leading
-underscores. Currently, the functions affected include @code{abort},
+Don't recognize builtin functions that do not begin with `__builtin_'
+as prefix. Currently, the functions affected include @code{abort},
@code{abs}, @code{alloca}, @code{cos}, @code{exit}, @code{fabs},
@code{ffs}, @code{labs}, @code{memcmp}, @code{memcpy}, @code{sin},
@code{sqrt}, @code{strcmp}, @code{strcpy}, and @code{strlen}.
builtin functions, since these functions do not have an ANSI standard
meaning.
+@item -fhosted
+@cindex hosted environment
+
+Assert that compilation takes place in a hosted environment. This implies
+@samp{-fbuiltin}. A hosted environment is one in which the
+entire standard library is available, and in which @code{main} has a return
+type of @code{int}. Examples are nearly everything except a kernel.
+This is equivalent to @samp{-fno-freestanding}.
+
+@item -ffreestanding
+@cindex hosted environment
+
+Assert that compilation takes place in a freestanding environment. This
+implies @samp{-fno-builtin}. A freestanding environment
+is one in which the standard library may not exist, and program startup may
+not necessarily be at @code{main}. The most obvious example is an OS kernel.
+This is equivalent to @samp{-fno-hosted}.
+
@item -trigraphs
Support ANSI C trigraphs. You don't want to know about this
brain-damage. The @samp{-ansi} option implies @samp{-trigraphs}.
literal characters @samp{x} and @samp{a} respectively. Without
@w{@samp{-traditional}}, @samp{\x} is a prefix for the hexadecimal
representation of a character, and @samp{\a} produces a bell.
-
-@item
-In C++ programs, assignment to @code{this} is permitted with
-@samp{-traditional}. (The option @samp{-fthis-is-variable} also has
-this effect.)
@end itemize
You may wish to use @samp{-fno-builtin} as well as @samp{-traditional}
ANSI 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 the @samp{-traditional-cpp}
-option, which is described next.
+The @samp{-traditional} option also enables @samp{-traditional-cpp},
+which is described next.
@item -traditional-cpp
Attempt to support some aspects of traditional C preprocessors.
might compile a file @code{firstClass.C} like this:
@example
-g++ -g -felide-constructors -O -c firstClass.C
+g++ -g -frepo -O -c firstClass.C
@end example
@noindent
-In this example, only @samp{-felide-constructors} is an option meant
+In this example, only @samp{-frepo} is an option meant
only for C++ programs; you can use the other options with any
language supported by GNU CC.
Turn off all access checking. This switch is mainly useful for working
around bugs in the access control code.
-@item -fall-virtual
-Treat all possible member functions as virtual, implicitly.
-All member functions (except for constructor functions and @code{new} or
-@code{delete} member operators) are treated as virtual functions of the
-class where they appear.
-
-This does not mean that all calls to these member functions will be made
-through the internal table of virtual functions. Under some
-circumstances, the compiler can determine that a call to a given virtual
-function can be made directly; in these cases the calls are direct in
-any case.
-
@item -fcheck-new
Check that the pointer returned by @code{operator new} is non-null
before attempting to modify the storage allocated. The current Working
Paper requires that @code{operator new} never return a null pointer, so
this check is normally unnecessary.
+An alternative to using this option is to specify that your
+@code{operator new} does not throw any exceptions; if you declare it
+@samp{throw()}, g++ will check the return value. See also @samp{new
+(nothrow)}.
+
@item -fconserve-space
Put uninitialized or runtime-initialized global variables into the
common segment, as C does. This saves space in the executable at the
completed, you may have an object that is being destroyed twice because
two definitions were merged.
+This option is no longer useful on most targets, now that support has
+been added for putting variables into BSS without making them common.
+
@item -fdollars-in-identifiers
Accept @samp{$} in identifiers. You can also explicitly prohibit use of
-@samp{$} with the option @samp{-fno-dollars-in-identifiers}. (GNU C++
-allows @samp{$} by default on some target systems but not others.)
+@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.
-@item -fenum-int-equiv
-Anachronistically permit implicit conversion of @code{int} to
-enumeration types. Current C++ allows conversion of @code{enum} to
-@code{int}, but not the other way around.
+@item -fno-elide-constructors
+The C++ standard allows an implementation to omit creating a temporary
+which is only used to initialize another object of the same type.
+Specifying this option disables that optimization, and forces g++ to
+call the copy constructor in all cases.
@item -fexternal-templates
Cause template instantiations to obey @samp{#pragma interface} and
to the location of the template definition. @xref{Template
Instantiation}, for more information.
+This option is deprecated.
+
@item -falt-external-templates
Similar to -fexternal-templates, but template instances are emitted or
not according to the place where they are first instantiated.
@xref{Template Instantiation}, for more information.
+This option is deprecated.
+
@item -ffor-scope
-@item -fno-for-scope
+@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.
@code{__typeof__} instead. @samp{-ansi} implies
@samp{-fno-gnu-keywords}.
-@item -fno-implicit-templates
-Never emit code for templates which are instantiated implicitly (i.e. by
-use); only emit code for explicit instantiations. @xref{Template
-Instantiation}, for more information.
+@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.
@item -fhandle-signatures
Recognize the @code{signature} and @code{sigof} keywords for specifying
recognize them. @xref{C++ Signatures, Type Abstraction using
Signatures}.
+@item -fhonor-std
+Treat the @code{namespace std} as a namespace, instead of ignoring
+it. For compatibility with earlier versions of g++, the compiler will,
+by default, ignore @code{namespace-declarations},
+@code{using-declarations}, @code{using-directives}, and
+@code{namespace-names}, if they involve @code{std}.
+
@item -fhuge-objects
Support virtual function calls for objects that exceed the size
representable by a @samp{short int}. Users should not use this flag by
-default; if you need to use it, the compiler will tell you so. If you
-compile any of your code with this flag, you must compile @emph{all} of
-your code with this flag (including libg++, if you use it).
+default; if you need to use it, the compiler will tell you so.
This flag is not useful when compiling with -fvtable-thunks.
+Like all options that change the ABI, all C++ code, @emph{including
+libgcc} must be built with the same setting of this option.
+
+@item -fno-implicit-templates
+Never emit code for templates which are instantiated implicitly (i.e. by
+use); only emit code for explicit instantiations. @xref{Template
+Instantiation}, for more information.
+
+@item -finit-priority
+Support @samp{__attribute__ ((init_priority (n)))} for controlling the
+order of initialization of file-scope objects. On ELF targets, this
+requires GNU ld 2.10 or later.
+
@item -fno-implement-inlines
To save space, do not emit out-of-line copies of inline functions
controlled by @samp{#pragma implementation}. This will cause linker
errors if these functions are not inlined everywhere they are called.
-@item -fmemoize-lookups
-@itemx -fsave-memoized
-Use heuristics to compile faster. These heuristics are not enabled by
-default, since they are only effective for certain input files. Other
-input files compile more slowly.
-
-The first time the compiler must build a call to a member function (or
-reference to a data member), it must (1) determine whether the class
-implements member functions of that name; (2) resolve which member
-function to call (which involves figuring out what sorts of type
-conversions need to be made); and (3) check the visibility of the member
-function to the caller. All of this adds up to slower compilation.
-Normally, the second time a call is made to that member function (or
-reference to that data member), it must go through the same lengthy
-process again. This means that code like this:
+@item -fname-mangling-version-@var{n}
+Control the way in which names are mangled. Version 0 is compatible
+with versions of g++ before 2.8. Version 1 is the default. Version 1
+will allow correct mangling of function templates. For example,
+version 0 mangling does not mangle foo<int, double> and foo<int, char>
+given this declaration:
-@smallexample
-cout << "This " << p << " has " << n << " legs.\n";
-@end smallexample
+@example
+template <class T, class U> void foo(T t);
+@end example
-@noindent
-makes six passes through all three steps. By using a software cache, a
-``hit'' significantly reduces this cost. Unfortunately, using the cache
-introduces another layer of mechanisms which must be implemented, and so
-incurs its own overhead. @samp{-fmemoize-lookups} enables the software
-cache.
-
-Because access privileges (visibility) to members and member functions
-may differ from one function context to the next, G++ may need to flush
-the cache. With the @samp{-fmemoize-lookups} flag, the cache is flushed
-after every function that is compiled. The @samp{-fsave-memoized} flag
-enables the same software cache, but when the compiler determines that
-the context of the last function compiled would yield the same access
-privileges of the next function to compile, it preserves the cache.
-This is most helpful when defining many member functions for the same
-class: with the exception of member functions which are friends of other
-classes, each member function has exactly the same access privileges as
-every other, and the cache need not be flushed.
-
-The code that implements these flags has rotted; you should probably
-avoid using them.
+@item -foperator-names
+Recognize 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}.
+
+@item -fno-optional-diags
+Disable diagnostics that the standard says a compiler does not need to
+issue. Currently, this means the diagnostic for a name having multiple
+meanings within a class.
+
+@item -frepo
+Enable automatic template instantiation. This option also implies
+@samp{-fno-implicit-templates}. @xref{Template Instantiation}, for more
+information.
@item -fstrict-prototype
Within an @samp{extern "C"} linkage specification, treat a function
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 -fno-nonnull-objects
-Don't assume that a reference is initialized to refer to a valid object.
-Although the current C++ Working Paper prohibits null references, some
-old code may rely on them, and you can use @samp{-fno-nonnull-objects}
-to turn on checking.
+@item -fsquangle
+@itemx -fno-squangle
+@samp{-fsquangle} will enable a compressed form of name mangling for
+identifiers. In particular, it helps to shorten very long names by recognizing
+types and class names which occur more than once, replacing them with special
+short ID codes. This option also requires any C++ libraries being used to
+be compiled with this option as well. The compiler has this disabled (the
+equivalent of @samp{-fno-squangle}) by default.
-At the moment, the compiler only does this checking for conversions to
-virtual base classes.
+Like all options that change the ABI, all C++ code, @emph{including
+libgcc.a} must be built with the same setting of this option.
-@item -foperator-names
-Recognize 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}.
+@item -ftemplate-depth-@var{n}
+Set the maximum instantiation depth for template classes to @var{n}.
+A limit on the template instantiation depth is needed to detect
+endless recursions during template class instantiation. ANSI/ISO C++
+conforming programs must not rely on a maximum depth greater than 17.
@item -fthis-is-variable
Permit assignment to @code{this}. The incorporation of user-defined
implementations store a single pointer to a @samp{thunk} function which
does any necessary adjustment and then calls the target function.
-This option also enables a heuristic for controlling emission of
-vtables; if a class has any non-inline virtual functions, the vtable
-will be emitted in the translation unit containing the first one of
-those.
+Like all options that change the ABI, all C++ code, @emph{including
+libgcc.a} must be built with the same setting of this option.
@item -nostdinc++
Do not search for header files in the standard directories specific to
C++, but do still search the other standard directories. (This option
-is used when building libg++.)
-
-@item -traditional
-For C++ programs (in addition to the effects that apply to both C and
-C++), this has the same effect as @samp{-fthis-is-variable}.
-@xref{C Dialect Options,, Options Controlling C Dialect}.
+is used when building the C++ library.)
@end table
In addition, these optimization, warning, and code generation options
@table @code
@item -fno-default-inline
Do not assume @samp{inline} for functions defined inside a class scope.
-@xref{Optimize Options,,Options That Control Optimization}.
+@xref{Optimize Options,,Options That Control Optimization}. Note that these
+functions will have linkage like inline functions; they just won't be
+inlined by default.
-@item -Woverloaded-virtual
-@itemx -Wtemplate-debugging
+@item -Wno-non-template-friend
+@xref{Warning Options,,Options to Request or Suppress Warnings}.
+@item -Wold-style-cast
+@itemx -Woverloaded-virtual
Warnings that apply only to C++ programs. @xref{Warning
Options,,Options to Request or Suppress Warnings}.
-@item +e@var{n}
-Control how virtual function definitions are used, in a fashion
-compatible with @code{cfront} 1.x. @xref{Code Gen Options,,Options for
-Code Generation Conventions}.
+@item -Weffc++
+Warn about violation of some style rules from Effective C++ by Scott Myers.
@end table
@node Warning Options
Check the code for syntax errors, but don't do anything beyond that.
@item -pedantic
-Issue all the warnings demanded by strict ANSI standard C; reject
-all programs that use forbidden extensions.
+Issue all the warnings demanded by strict ANSI C and ISO C++;
+reject all programs that use forbidden extensions.
-Valid ANSI standard C programs should compile properly with or without
+Valid ANSI 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 features
-are supported as well. With this option, they are rejected.
+without this option, certain GNU extensions and traditional C and C++
+features are supported as well. With this option, they are rejected.
@samp{-pedantic} does not cause warning messages for use of the
alternate keywords whose names begin and end with @samp{__}. Pedantic
the arguments supplied have types appropriate to the format string
specified.
-@item -Wimplicit
-Warn whenever a function or parameter is implicitly declared.
+@item -Wimplicit-int
+Warn when a declaration does not specify a type.
+
+@item -Wimplicit-function-declaration
+@itemx -Werror-implicit-function-declaration
+Give a warning (or error) whenever a function is used before being
+declared.
+@item -Wimplicit
+Same as @samp{-Wimplicit-int} and @samp{-Wimplicit-function-}@*
+@samp{declaration}.
+
+@item -Wmain
+Warn if the type of @samp{main} is suspicious. @samp{main} should be a
+function with external linkage, returning int, taking either zero
+arguments, two, or three arguments of appropriate types.
+
+@item -Wmultichar
+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
is expected, or when operators are nested whose precedence people
often get confused about.
+Also warn about constructions where there may be confusion to which
+@code{if} statement an @code{else} branch belongs. Here is an example of
+such a case:
+
+@smallexample
+@{
+ if (a)
+ if (b)
+ foo ();
+ else
+ bar ();
+@}
+@end smallexample
+
+In C, every @code{else} branch belongs to the innermost possible @code{if}
+statement, which in this example is @code{if (b)}. This is often not
+what the programmer expected, as illustrated in the above example by
+indentation the programmer chose. When there is the potential for this
+confusion, GNU C will issue a warning when this flag is specified.
+To eliminate the warning, add explicit braces around the innermost
+@code{if} statement so there is no way the @code{else} could belong to
+the enclosing @code{if}. The resulting code would look like this:
+
+@smallexample
+@{
+ if (a)
+ @{
+ if (b)
+ foo ();
+ else
+ bar ();
+ @}
+@}
+@end smallexample
+
@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
label is declared but not used, and whenever a statement computes a
result that is explicitly not used.
+In order to get a warning about an unused function parameter, you must
+specify both @samp{-W} and @samp{-Wunused}.
+
To suppress this warning for an expression, simply cast it to void. For
unused variables and parameters, use the @samp{unused} attribute
(@pxref{Variable Attributes}).
and @samp{j} will be rearranged to match the declaration order of the
members.
-@item -Wsign-compare
-@cindex warning for comparison of signed and unsigned values
-@cindex comparison of signed and unsigned values, warning
-@cindex signed and unsigned values, comparison warning
-Warn when a comparison between signed and unsigned values could produce
-an incorrect result when the signed value is converted to unsigned.
-
@item -Wtemplate-debugging
@cindex template debugging
When using templates in a C++ program, warn if debugging is not yet
fully available (C++ only).
+@item -Wunknown-pragmas
+@cindex warning for unknown pragmas
+@cindex unknown pragmas, warning
+@cindex pragmas, warning of unknown
+Warn when a #pragma directive is encountered which is not understood by
+GCC. If this command line option is used, warnings will even be issued
+for unknown pragmas in system header files. This is not the case if
+the warnings were only enabled by the @samp{-Wall} command line option.
+
@item -Wall
All of the above @samp{-W} options combined. This enables all the
warnings about constructions that some users consider questionable, and
arguments.
@item
+A comparison between signed and unsigned values could produce an
+incorrect result when the signed value is converted to unsigned.
+(But don't warn if @samp{-Wno-sign-compare} is also specified.)
+
+@item
An aggregate has a partly bracketed initializer.
For example, the following code would evoke such a warning,
because braces are missing around the initializer for @code{x.h}:
struct t @{ struct s h; int i; @};
struct t x = @{ 1, 2, 3 @};
@end smallexample
+
+@item
+An aggregate has an initializer which does not initialize all members.
+For example, the following code would cause such a warning, because
+@code{x.h} would be implicitly initialized to zero:
+
+@smallexample
+struct s @{ int f, g, h; @};
+struct s x = @{ 3, 4 @};
+@end smallexample
@end itemize
@item -Wtraditional
A @code{switch} statement has an operand of type @code{long}.
@end itemize
+@item -Wundef
+Warn if an undefined identifier is evaluated in an @samp{#if} directive.
+
@item -Wshadow
Warn whenever a local variable shadows another local variable.
@code{x = -1} if @code{x} is unsigned. But do not warn about explicit
casts like @code{(unsigned) -1}.
+@item -Wsign-compare
+@cindex warning for comparison of signed and unsigned values
+@cindex comparison of signed and unsigned values, warning
+@cindex signed and unsigned values, comparison warning
+Warn when a comparison between signed and unsigned values could produce
+an incorrect result when the signed value is converted to unsigned.
+This warning is also enabled by @samp{-W}; to get the other warnings
+of @samp{-W} without this warning, use @samp{-W -Wno-sign-compare}.
+
@item -Waggregate-return
Warn if any functions that return structures or unions are defined or
called. (In languages where you can return an array, this also elicits
Use this option to detect global functions that are not declared in
header files.
+@item -Wmissing-noreturn
+Warn about functions which might be candidates for attribute @code{noreturn}.
+Note these are only possible candidates, not absolute ones. Care should
+be taken to manually verify functions actually do not ever return before
+adding the @code{noreturn} attribute, otherwise subtle code generation
+bugs could be introduced.
+
@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.
@item -Wnested-externs
Warn if an @code{extern} declaration is encountered within an function.
+@item -Wno-non-template-friend
+Disable warnings when non-templatized friend functions are declared
+within a template. With the advent of explicit template specification
+support in g++, if the name of the friend is an unqualified-id (ie,
+@samp{friend foo(int)}), the C++ language specification demands that the
+friend declare or define an ordinary, nontemplate function. (Section
+14.5.3). Before g++ implemented explicit specification, unqualified-ids
+could be interpreted as a particular specialization of a templatized
+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.
+
@item -Winline
Warn if a function can not be inlined, and either it was declared as inline,
or else the @samp{-finline-functions} option was given.
+@item -Wold-style-cast
+Warn if an old-style (C-style) cast is used within a program.
+
@item -Woverloaded-virtual
@cindex overloaded virtual fn, warning
@cindex warning for overloaded virtual fn
In this example, g++ will synthesize a default @samp{A& operator =
(const A&);}, while cfront will use the user-defined @samp{operator =}.
+@item -Wlong-long
+Warn if @samp{long long} type is used. This is default. To inhibit
+the warning messages, use @samp{-Wno-long-long}. Flags
+@samp{-Wlong-long} and @samp{-Wno-long-long} are taken into account
+only when @samp{-pedantic} flag is used.
+
@item -Werror
Make all warnings into errors.
@end table
crash or
refuse to read the program. If you want to control for certain whether
to generate the extra information, use @samp{-gstabs+}, @samp{-gstabs},
-@samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf+}, or @samp{-gdwarf}
+@samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf-1+}, or @samp{-gdwarf-1}
(see below).
Unlike most other C compilers, GNU CC allows you to use @samp{-g} with
capability for more than one debugging format.
@item -ggdb
-Produce debugging information in the native format (if that is supported),
-including GDB extensions if at all possible.
+Produce debugging information for use by GDB. This means to use the
+most expressive format available (DWARF 2, stabs, or the native format
+if neither of those are supported), including GDB extensions if at all
+possible.
@item -gstabs
Produce debugging information in stabs format (if that is supported),
assembler (GAS) to fail with an error.
@item -gdwarf
-Produce debugging information in DWARF format (if that is supported).
-This is the format used by SDB on most System V Release 4 systems.
+Produce debugging information in DWARF version 1 format (if that is
+supported). This is the format used by SDB on most System V Release 4
+systems.
@item -gdwarf+
-Produce debugging information in DWARF format (if that is supported),
-using GNU extensions understood only by the GNU debugger (GDB). The
-use of these extensions is likely to make other debuggers crash or
-refuse to read the program.
+Produce debugging information in DWARF version 1 format (if that is
+supported), using GNU extensions understood only by the GNU debugger
+(GDB). The use of these extensions is likely to make other debuggers
+crash or refuse to read the program.
+
+@item -gdwarf-2
+Produce debugging information in DWARF version 2 format (if that is
+supported). This is the format used by DBX on IRIX 6.
@item -g@var{level}
@itemx -ggdb@var{level}
@itemx -gcoff@var{level}
@itemx -gxcoff@var{level}
@itemx -gdwarf@var{level}
+@itemx -gdwarf-2@var{level}
Request debugging information and also use @var{level} to specify how
much information. The default level is 2.
however, that the format of the data is not what @code{tcov} expects.
Eventually GNU @code{gprof} should be extended to process this data.
+@item -Q
+Makes the compiler print out each function name as it is compiled, and
+print some statistics about each pass when it finishes.
+
@item -ax
Generate extra code to profile basic blocks. Your executable will
produce output that is a superset of that produced when @samp{-a} is
The output is appended to file @file{bb.out}.
You can examine different profiling aspects without recompilation. Your
-execuable will read a list of function names from file @file{bb.in}.
+executable will read a list of function names from file @file{bb.in}.
Profiling starts when a function on the list is entered and stops when
that invocation is exited. To exclude a function from profiling, prefix
its name with `-'. If a function name is not unique, you can
written to @file{bbtrace.gz}. It is solely used for counting jump
frequencies.
+@item -fprofile-arcs
+Instrument @dfn{arcs} during compilation. For each function of your
+program, GNU CC creates a program flow graph, then finds a spanning tree
+for the graph. Only arcs that are not on the spanning tree have to be
+instrumented: the compiler adds code to count the number of times that these
+arcs are executed. When an arc is the only exit or only entrance to a
+block, the instrumentation code can be added to the block; otherwise, a
+new basic block must be created to hold the instrumentation code.
+
+Since not every arc in the program must be instrumented, programs
+compiled with this option run faster than programs compiled with
+@samp{-a}, which adds instrumentation code to every basic block in the
+program. The tradeoff: since @code{gcov} does not have
+execution counts for all branches, it must start with the execution
+counts for the instrumented branches, and then iterate over the program
+flow graph until the entire graph has been solved. Hence, @code{gcov}
+runs a little more slowly than a program which uses information from
+@samp{-a}.
+
+@samp{-fprofile-arcs} also makes it possible to estimate branch
+probabilities, and to calculate basic block execution counts. In
+general, basic block execution counts do not give enough information to
+estimate all branch probabilities. When the compiled program exits, it
+saves the arc execution counts to a file called
+@file{@var{sourcename}.da}. Use the compiler option
+@samp{-fbranch-probabilities} (@pxref{Optimize Options,,Options that
+Control Optimization}) when recompiling, to optimize using estimated
+branch probabilities.
+
+@need 2000
+@item -ftest-coverage
+Create data files for the @code{gcov} code-coverage utility
+(@pxref{Gcov,, @code{gcov}: a GNU CC Test Coverage Program}).
+The data file names begin with the name of your source file:
+
+@table @code
+@item @var{sourcename}.bb
+A mapping from basic blocks to line numbers, which @code{gcov} uses to
+associate basic block execution counts with line numbers.
+
+@item @var{sourcename}.bbg
+A list of all arcs in the program flow graph. This allows @code{gcov}
+to reconstruct the program flow graph, so that it can compute all basic
+block and arc execution counts from the information in the
+@code{@var{sourcename}.da} file (this last file is the output from
+@samp{-fprofile-arcs}).
+@end table
+
+@item -Q
+Makes the compiler print out each function name as it is compiled, and
+print some statistics about each pass when it finishes.
+
@item -d@var{letters}
Says to make debugging dumps during compilation at times specified by
@var{letters}. This is used for debugging the compiler. The file names
possible letters for use in @var{letters}, and their meanings:
@table @samp
-@item M
-Dump all macro definitions, at the end of preprocessing, and write no
-output.
-@item N
-Dump all macro names, at the end of preprocessing.
+@item b
+Dump after computing branch probabilities, to @file{@var{file}.bp}.
+@item c
+Dump after instruction combination, to the file @file{@var{file}.combine}.
+@item d
+Dump after delayed branch scheduling, to @file{@var{file}.dbr}.
@item D
Dump all macro definitions, at the end of preprocessing, in addition to
normal output.
@item s
Dump after CSE (including the jump optimization that sometimes
follows CSE), to @file{@var{file}.cse}.
-@item L
-Dump after loop optimization, to @file{@var{file}.loop}.
-@item t
-Dump after the second CSE pass (including the jump optimization that
-sometimes follows CSE), to @file{@var{file}.cse2}.
+@item F
+Dump after purging ADDRESSOF, to @file{@var{file}.addressof}.
@item f
Dump after flow analysis, to @file{@var{file}.flow}.
-@item c
-Dump after instruction combination, to the file
-@file{@var{file}.combine}.
-@item S
-Dump after the first instruction scheduling pass, to
-@file{@var{file}.sched}.
-@item l
-Dump after local register allocation, to
-@file{@var{file}.lreg}.
@item g
-Dump after global register allocation, to
-@file{@var{file}.greg}.
-@item R
-Dump after the second instruction scheduling pass, to
-@file{@var{file}.sched2}.
+Dump after global register allocation, to @file{@var{file}.greg}.
+@item G
+Dump after GCSE, to @file{@var{file}.gcse}.
+@item j
+Dump after first jump optimization, to @file{@var{file}.jump}.
@item J
Dump after last jump optimization, to @file{@var{file}.jump2}.
-@item d
-Dump after delayed branch scheduling, to @file{@var{file}.dbr}.
@item k
Dump after conversion from registers to stack, to @file{@var{file}.stack}.
+@item l
+Dump after local register allocation, to @file{@var{file}.lreg}.
+@item L
+Dump after loop optimization, to @file{@var{file}.loop}.
+@item M
+Dump after performing the machine dependent reorganisation pass, to
+@file{@var{file}.mach}.
+@item N
+Dump after the register move pass, to @file{@var{file}.regmove}.
+@item r
+Dump after RTL generation, to @file{@var{file}.rtl}.
+@item R
+Dump after the second instruction scheduling pass, to @file{@var{file}.sched2}.
+@item s
+Dump after CSE (including the jump optimization that sometimes follows
+CSE), to @file{@var{file}.cse}.
+@item S
+Dump after the first instruction scheduling pass, to @file{@var{file}.sched}.
+@item t
+Dump after the second CSE pass (including the jump optimization that
+sometimes follows CSE), to @file{@var{file}.cse2}.
+@item x
+Just generate RTL for a function instead of compiling it. Usually used
+with @samp{r}.
@item a
Produce all the dumps listed above.
@item m
@item p
Annotate the assembler output with a comment indicating which
pattern and alternative was used.
+@item y
+Dump debugging information during parsing, to standard error.
@item A
Annotate the assembler output with miscellaneous debugging information.
@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
+options, in particular with and without -g.
+
@item -fpretend-float
When running a cross-compiler, pretend that the target machine uses the
same floating point format as the host machine. This causes incorrect
@item -O0
Do not optimize.
+@item -Os
+Optimize for size. @samp{-Os} enables all @samp{-O2} optimizations that
+do not typically increase code size. It also performs further
+optimizations designed to reduce code size.
+
If you use multiple @samp{-O} options, with or without level numbers,
the last such option is the one that is effective.
@end table
precision than a @code{double} is supposed to have. Similarly for the
x86 architecture. For most programs, the excess precision does only
good, but a few programs rely on the precise definition of IEEE floating
-point. Use @samp{-ffloat-store} for such programs.
+point. Use @samp{-ffloat-store} for such programs, after modifying
+them to store all pertinent intermediate computations into variables.
@item -fno-default-inline
Do not make member functions inline by default merely because they are
Re-run common subexpression elimination after loop optimizations has been
performed.
+@item -frerun-loop-opt
+Run the loop optimizer twice.
+
+@item -fgcse
+Perform a global common subexpression elimination pass.
+This pass also performs global constant and copy propagation.
+
@item -fexpensive-optimizations
Perform a number of minor optimizations that are relatively expensive.
+@item -foptimize-register-moves
+@item -fregmove
+Attempt to reassign register numbers in move instructions and as
+operands of other simple instructions in order to maximize the amount of
+register tying. This is especially helpful on machines with two-operand
+instructions. GNU CC enables this optimization by default with @samp{-O2}
+or higher.
+
+Note @code{-fregmove} and @code{-foptimize-register-moves} are the same
+optimization.
+
@item -fdelayed-branch
If supported for the target machine, attempt to reorder instructions
to exploit instruction slots available after delayed branch
registers and where memory load instructions take more than one cycle.
@item -ffunction-sections
-Place each function into its own section in the output file if the
-target supports arbitrary sections. The function's name determines
-the section's name in the output file.
+@item -fdata-sections
+Place each function or data item into its own section in the output
+file if the target supports arbitrary sections. The name of the
+function or the name of the data item determines the section's name
+in the output file.
-Use this option on systems where the linker can perform optimizations
+Use these options on systems where the linker can perform optimizations
to improve locality of reference in the instruction space. HPPA
processors running HP-UX and Sparc processors running Solaris 2 have
linkers with such optimizations. Other systems using the ELF object format
as well as AIX may have these optimizations in the future.
-Only use this option when there are significant benefits from doing
-so. When you specify this option, the assembler and linker will
+Only use these options when there are significant benefits from doing
+so. When you specify these options, the assembler and linker will
create larger object and executable files and will also be slower.
You will not be able to use @code{gprof} on all systems if you
specify this option and you may have problems with debugging if
registers around such calls. Such allocation is done only when it
seems to result in better code than would otherwise be produced.
-This option is enabled by default on certain machines, usually those
-which have no call-preserved registers to use instead.
+This option is always enabled by default on certain machines, usually
+those which have no call-preserved registers to use instead.
+
+For all machines, optimization level 2 and higher enables this flag by
+default.
@item -funroll-loops
Perform the optimization of loop unrolling. This is only done for loops
and usually makes programs run more slowly. @samp{-funroll-all-loops}
implies @samp{-fstrength-reduce} as well as @samp{-frerun-cse-after-loop}.
+@item -fmove-all-movables
+Forces all invariant computations in loops to be moved
+outside the loop.
+
+@item -freduce-all-givs
+Forces all general-induction variables in loops to be
+strength-reduced.
+
+@emph{Note:} When compiling programs written in Fortran,
+@samp{-fmove-all-moveables} and @samp{-freduce-all-givs} are enabled
+by default when you use the optimizer.
+
+These options may generate better or worse code; results are highly
+dependent on the structure of loops within the source code.
+
+These two options are intended to be removed someday, once
+they have helped determine the efficacy of various
+approaches to improving loop optimizations.
+
+Please let us (@code{egcs@@cygnus.com} and @code{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}
+when these options are @emph{enabled}.
+
@item -fno-peephole
Disable any machine-specific peephole optimizations.
+
+@item -fbranch-probabilities
+After running a program compiled with @samp{-fprofile-arcs}
+(@pxref{Debugging Options,, Options for Debugging Your Program or
+@code{gcc}}), you can compile it a second time using
+@samp{-fbranch-probabilities}, to improve optimizations based on
+guessing the path a branch might take.
+
+@ifset INTERNALS
+With @samp{-fbranch-probabilities}, GCC puts a @samp{REG_EXEC_COUNT}
+note on the first instruction of each basic block, and a
+@samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}.
+These can be used to improve optimization. Currently, they are only
+used in one place: in @file{reorg.c}, instead of guessing which path a
+branch is mostly to take, the @samp{REG_BR_PROB} values are used to
+exactly determine which path is taken more often.
+@end ifset
+
+@item -fstrict-aliasing
+Allows the compiler to assume the strictest aliasing rules applicable to
+the language being compiled. For C (and C++), this activates
+optimizations based on the type of expressions. In particular, an
+object of one type is assumed never to reside at the same address as an
+object of a different type, unless the types are almost the same. For
+example, an @code{unsigned int} can alias an @code{int}, but not a
+@code{void*} or a @code{double}. A character type may alias any other
+type.
+
+Pay special attention to code like this:
+@example
+union a_union @{
+ int i;
+ double d;
+@};
+
+int f() @{
+ a_union t;
+ t.d = 3.0;
+ return t.i;
+@}
+@end example
+The practice of reading from a different union member than the one most
+recently written to (called ``type-punning'') is common. Even with
+@samp{-fstrict-aliasing}, type-punning is allowed, provided the memory
+is accessed through the union type. So, the code above will work as
+expected. However, this code might not:
+@example
+int f() @{
+ a_union t;
+ int* ip;
+ t.d = 3.0;
+ ip = &t.i;
+ return *ip;
+@}
+@end example
+
+@ifset INTERNALS
+Every language that wishes to perform language-specific alias analysis
+should define a function that computes, given an @code{tree}
+node, an alias set for the node. Nodes in different alias sets are not
+allowed to alias. For an example, see the C front-end function
+@code{c_get_alias_set}.
+@end ifset
+
@end table
@node Preprocessor Options
Do not use the standard system libraries when linking.
Only the libraries you specify will be passed to the linker.
The standard startup files are used normally, unless @code{-nostartfiles}
-is used.
+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
+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 -nostdlib
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 linker. The compiler may generate calls to memcmp, memset, and memcpy
+for System V (and ANSI 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.
@cindex @code{-lgcc}, use with @code{-nostdlib}
@cindex @code{-nostdlib} and unresolved references
@table @code
@item -I@var{dir}
-Add the directory @var{directory} to the head of the list of directories
-to be searched for header files. This can be used to override a system
-header file, substituting your own version, since these directories are
+Add the directory @var{dir} to the head of the list of directories to be
+searched for header files. This can be used to override a system header
+file, substituting your own version, since these directories are
searched before the system header file directories. If you use more
than one @samp{-I} option, the directories are scanned in left-to-right
order; the standard system directories come after.
Another way to specify a prefix much like the @samp{-B} prefix is to use
the environment variable @code{GCC_EXEC_PREFIX}. @xref{Environment
Variables}.
+
+@item -specs=@var{file}
+Process @var{file} after the compiler reads in the standard @file{specs}
+file, in order to override the defaults that the @file{gcc} driver
+program uses when determining what switches to pass to @file{cc1},
+@file{cc1plus}, @file{as}, @file{ld}, etc. More than one
+@samp{-specs=}@var{file} can be specified on the command line, and they
+are processed in order, from left to right.
@end table
@node Target Options
* Convex Options::
* AMD29K Options::
* ARM Options::
+* Thumb Options::
+* MN10200 Options::
+* MN10300 Options::
+* M32R/D Options::
* M88K Options::
* RS/6000 and PowerPC Options::
* RT Options::
* H8/300 Options::
* SH Options::
* System V Options::
+* V850 Options::
+* ARC Options::
+* NS32K Options::
@end menu
@node M680x0 Options
Generate output for a 68000. This is the default
when the compiler is configured for 68000-based systems.
+Use this option for microcontrollers with a 68000 or EC000 core,
+including the 68008, 68302, 68306, 68307, 68322, 68328 and 68356.
+
@item -m68020
@itemx -mc68020
Generate output for a 68020. This is the default
configured for 68040-based systems.
This option inhibits the use of 68881/68882 instructions that have to be
-emulated by software on the 68040. If your 68040 does not have code to
-emulate those instructions, use @samp{-m68040}.
+emulated by software on the 68040. Use this option if your 68040 does not
+have code to emulate those instructions.
@item -m68060
Generate output for a 68060. This is the default when the compiler is
configured for 68060-based systems.
This option inhibits the use of 68020 and 68881/68882 instructions that
-have to be emulated by software on the 68060. If your 68060 does not
-have code to emulate those instructions, use @samp{-m68060}.
+have to be emulated by software on the 68060. Use this option if your 68060
+does not have code to emulate those instructions.
+
+@item -mcpu32
+Generate output for a CPU32. This is the default
+when the compiler is configured for CPU32-based systems.
+
+Use this option for microcontrollers with a
+CPU32 or CPU32+ core, including the 68330, 68331, 68332, 68333, 68334,
+68336, 68340, 68341, 68349 and 68360.
@item -m5200
Generate output for a 520X "coldfire" family cpu. This is the default
when the compiler is configured for 520X-based systems.
+Use this option for microcontroller with a 5200 core, including
+the MCF5202, MCF5203, MCF5204 and MCF5202.
+
@item -m68020-40
Generate output for a 68040, without using any of the new instructions.
68020/68881 or a 68030 or a 68040. The generated code does use the
68881 instructions that are emulated on the 68040.
+@item -m68020-60
+Generate output for a 68060, without using any of the new instructions.
+This results in code which can run relatively efficiently on either a
+68020/68881 or a 68030 or a 68040. The generated code does use the
+68881 instructions that are emulated on the 68060.
+
@item -mfpa
Generate output containing Sun FPA instructions for floating point.
Consider type @code{int} to be 16 bits wide, like @code{short int}.
@item -mnobitfield
-Do not use the bit-field instructions. The @samp{-m68000} option
-implies @w{@samp{-mnobitfield}}.
+Do not use the bit-field instructions. The @samp{-m68000}, @samp{-mcpu32}
+and @samp{-m5200} options imply @w{@samp{-mnobitfield}}.
@item -mbitfield
Do use the bit-field instructions. The @samp{-m68020} option implies
harmlessly ignored.)
The @code{rtd} instruction is supported by the 68010, 68020, 68030,
-68040, and 68060 processors, but not by the 68000 or 5200.
+68040, 68060 and CPU32 processors, but not by the 68000 or 5200.
+
+@item -malign-int
+@itemx -mno-align-int
+Control whether GNU CC aligns @code{int}, @code{long}, @code{long long},
+@code{float}, @code{double}, and @code{long double} variables on a 32-bit
+boundary (@samp{-malign-int}) or a 16-bit boundary (@samp{-mno-align-int}).
+Aligning variables on 32-bit boundaries produces code that runs somewhat
+faster on processors with 32-bit busses at the expense of more memory.
+
+@strong{Warning:} if you use the @samp{-malign-int} switch, GNU CC will
+align structures containing the above types differently than
+most published application binary interface specifications for the m68k.
+
@end table
@node VAX Options
They have been replaced with @samp{-mcpu=xxx}.
@item -mcpu=@var{cpu_type}
-Set architecture type and instruction scheduling parameters for machine
-type @var{cpu_type}. Supported values for @var{cpu_type} are
-@samp{common}, @samp{cypress}, @samp{v8}, @samp{supersparc},
-@samp{sparclite}, @samp{f930}, @samp{f934},
-@samp{sparclet}, @samp{90c701}, @samp{v8plus}, @samp{v9},
-and @samp{ultrasparc}. Specifying @samp{v9} is only supported on true
-64 bit targets.
+Set the instruction set, register set, and instruction scheduling parameters
+for machine type @var{cpu_type}. Supported values for @var{cpu_type} are
+@samp{v7}, @samp{cypress}, @samp{v8}, @samp{supersparc}, @samp{sparclite},
+@samp{f930}, @samp{f934}, @samp{sparclet}, @samp{tsc701}, @samp{v9}, and
+@samp{ultrasparc}.
+
+Default instruction scheduling parameters are used for values that select
+an architecture and not an implementation. These are @samp{v7}, @samp{v8},
+@samp{sparclite}, @samp{sparclet}, @samp{v9}.
+
+Here is a list of each supported architecture and their supported
+implementations.
+
+@smallexample
+ v7: cypress
+ v8: supersparc
+ sparclite: f930, f934
+ sparclet: tsc701
+ v9: ultrasparc
+@end smallexample
@item -mtune=@var{cpu_type}
Set the instruction scheduling parameters for machine type
-@var{cpu_type}, but do not set the architecture type as the option
-@samp{-mcpu=}@var{cpu_type} would. The same values for
-@samp{-mcpu=}@var{cpu_type} are used for @samp{-tune=}@var{cpu_type}.
+@var{cpu_type}, but do not set the instruction set or register set that the
+option @samp{-mcpu=}@var{cpu_type} would.
+
+The same values for @samp{-mcpu=}@var{cpu_type} are used for
+@samp{-mtune=}@*@var{cpu_type}, though the only useful values are those that
+select a particular cpu implementation: @samp{cypress}, @samp{supersparc},
+@samp{f930}, @samp{f934}, @samp{tsc701}, @samp{ultrasparc}.
+
+@item -malign-loops=@var{num}
+Align loops to a 2 raised to a @var{num} byte boundary. If
+@samp{-malign-loops} is not specified, the default is 2.
+
+@item -malign-jumps=@var{num}
+Align instructions that are only jumped to to a 2 raised to a @var{num}
+byte boundary. If @samp{-malign-jumps} is not specified, the default is 2.
+
+@item -malign-functions=@var{num}
+Align the start of functions to a 2 raised to @var{num} byte boundary.
+If @samp{-malign-functions} is not specified, the default is 2 if compiling
+for 32 bit sparc, and 5 if compiling for 64 bit sparc.
@end table
@item -mlittle-endian
Generate code for a processor running in little-endian mode.
-@item -mmedlow
-Generate code for the Medium/Low code model: assume a 32 bit address space.
-Programs are statically linked, PIC is not supported. Pointers are still
-64 bits.
-
-It is very likely that a future version of GCC will rename this option.
-
-@item -mmedany
-Generate code for the Medium/Anywhere code model: assume a 32 bit text
-and a 32 bit data segment, both starting anywhere (determined at link time).
-Programs are statically linked, PIC is not supported. Pointers are still
-64 bits.
-
-It is very likely that a future version of GCC will rename this option.
-
-@item -mfullany
-Generate code for the Full/Anywhere code model: assume a full 64 bit
-address space. PIC is not supported.
-
-It is very likely that a future version of GCC will rename this option.
-
-@item -mint64
-Types long and int are 64 bits.
-
-@item -mlong32
-Types long and int are 32 bits.
-
-@item -mlong64
-@itemx -mint32
-Type long is 64 bits, and type int is 32 bits.
+@item -m32
+@itemx -m64
+Generate code for a 32 bit or 64 bit environment.
+The 32 bit environment sets int, long and pointer to 32 bits.
+The 64 bit environment sets int to 32 bits and long and pointer
+to 64 bits.
+
+@item -mcmodel=medlow
+Generate code for the Medium/Low code model: the program must be linked
+in the low 32 bits of the address space. Pointers are 64 bits.
+Programs can be statically or dynamically linked.
+
+@item -mcmodel=medmid
+Generate code for the Medium/Middle code model: the program must be linked
+in the low 44 bits of the address space, the text segment must be less than
+2G bytes, and data segment must be within 2G of the text segment.
+Pointers are 64 bits.
+
+@item -mcmodel=medany
+Generate code for the Medium/Anywhere code model: the program may be linked
+anywhere in the address space, the text segment must be less than
+2G bytes, and data segment must be within 2G of the text segment.
+Pointers are 64 bits.
+
+@item -mcmodel=embmedany
+Generate code for the Medium/Anywhere code model for embedded systems:
+assume a 32 bit text and a 32 bit data segment, both starting anywhere
+(determined at link time). Register %g4 points to the base of the
+data segment. Pointers still 64 bits.
+Programs are statically linked, PIC is not supported.
@item -mstack-bias
@itemx -mno-stack-bias
registers for copying out arguments. This helps detect calling a function
with fewer arguments than it was declared with.
+@item -mno-impure-text
+@itemx -mimpure-text
+@kindex -mimpure-text
+@samp{-mimpure-text}, used in addition to @samp{-shared}, tells the compiler to
+not pass @samp{-assert pure-text} to the linker when linking a shared object.
+
@item -msoft-float
@kindex -msoft-float
Generate output containing library calls for floating point.
@kindex -mapcs-frame
Generate a stack frame that is compliant with the ARM Procedure Call
Standard for all functions, even if this is not strictly necessary for
-correct execution of the code.
+correct execution of the code. Specifying @samp{-fomit-frame-pointer}
+with this option will cause the stack frames not to be generated for
+leaf functions. The default is @samp{-mno-apcs-frame}.
+
+@item -mapcs
+@kindex -mapcs
+This is a synonym for @samp{-mapcs-frame}.
@item -mapcs-26
@kindex -mapcs-26
option. This option replaces the @samp{-m6} option of previous releases
of the compiler.
+@item -mapcs-stack-check
+@kindex -mapcs-stack-check
+@kindex -mno-apcs-stack-check
+Generate code to check the amount of stack space available upon entry to
+every function (that actually uses some stack space). If there is
+insufficient space available then either the function
+@samp{__rt_stkovf_split_small} or @samp{__rt_stkovf_split_big} will be
+called, depending upon the amount of stack space required. The run time
+system is required to provide these functions. The default is
+@samp{-mno-apcs-stack-check}, since this produces smaller code.
+
+@item -mapcs-float
+@kindex -mapcs-float
+@kindex -mno-apcs-float
+Pass floating point arguments using the float point registers. This is
+one of the variants of the APCS. This option is reccommended if the
+target hardware has a floating point unit or if a lot of floating point
+arithmetic is going to be performed by the code. The default is
+@samp{-mno-apcs-float}, since integer only code is slightly increased in
+size if @samp{-mapcs-float} is used.
+
+@item -mapcs-reentrant
+@kindex -mapcs-reentrant
+@kindex -mno-apcs-reentrant
+Generate reentrant, position independent code. This is the equivalent
+to specifying the @samp{-fpic} option. The default is
+@samp{-mno-apcs-reentrant}.
+
+@item -mthumb-interwork
+@kindex -mthumb-interwork
+@kindex -mno-thumb-interwork
+Generate code which supports calling between the ARM and THUMB
+instruction sets. Without this option the two instruction sets cannot
+be reliably used inside one program. The default is
+@samp{-mno-thumb-interwork}, since slightly larger code is generated
+when @samp{-mthumb-interwork} is specified.
+
+@item -mno-sched-prolog
+@kindex -mno-sched-prolog
+@kindex -msched-prolog
+Prevent the reordering of instructions in the function prolog, or the
+merging of those instruction with the instructions in the function's
+body. This means that all functions will start with a recognisable set
+of instructions (or in fact one of a chioce from a small set of
+different function prologues), and this information can be used to
+locate the start if functions inside an executable piece of code. The
+default is @samp{-msched-prolog}.
+
@item -mhard-float
Generate output containing floating point instructions. This is the
default.
option produces more efficient code, but the MMU is sometimes configured
to trap these instructions.
+@item -mshort-load-words
+@kindex -mshort-load-words
+This is a synonym for the @samp{-mno-short-load-bytes}.
+
+@item -mno-short-load-words
+@kindex -mno-short-load-words
+This is a synonym for the @samp{-mshort-load-bytes}.
+
@item -mbsd
@kindex -mbsd
This option only applies to RISC iX. Emulate the native BSD-mode
preparation for linking with the RISC iX C library; this option
suppresses this pass. The post-processor is never run when the
compiler is built for cross-compilation.
+
+@item -mcpu=<name>
+@kindex -mcpu=
+This specifies the name of the target ARM processor. GCC uses this name
+to determine what kind of instructions it can use when generating
+assembly code. Permissable names are: arm2, arm250, arm3, arm6, arm60,
+arm600, arm610, arm620, arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi,
+arm70, arm700, arm700i, arm710, arm710c, arm7100, arm7500, arm7500fe,
+arm7tdmi, arm8, strongarm, strongarm110
+
+@item -march=<name>
+@kindex -march=
+This specifies the name of the target ARM architecture. GCC uses this
+name to determine what kind of instructions it can use when generating
+assembly code. This option can be used in conjunction with or instead
+of the @samp{-mcpu=} option. Permissable names are: armv2, armv2a,
+armv3, armv3m, armv4, armv4t
+
+@item -mfpe=<number>
+@kindex -mfpe=
+This specifes the version of the floating point emulation available on
+the target. Permissable values are 2 and 3.
+
+@item -mstructure-size-boundary=<n>
+@kindex -mstructure-size-boundary
+The size of all structures and unions will be rounded up to a multiple
+of the number of bits set by this option. Permissable values are 8 and
+32. The default value varies for different toolchains. For the COFF
+targeted toolchain the default value is 8. Specifying the larger number
+can produced faster, more efficient code, but can also increase the size
+of the program. The two values are potentially incompatible. Code
+compiled with one value cannot necessarily expect to work with code or
+libraries compiled with the other value, if they exchange information
+using structures or unions. Programmers are encouraged to use the 32
+value as future versions of the toolchain may default to this value.
+
+@end table
+
+@node Thumb Options
+@subsection Thumb Options
+@cindex Thumb Options
+
+@table @code
+
+@item -mthumb-interwork
+@kindex -mthumb-interwork
+@kindex -mno-thumb-interwork
+Generate code which supports calling between the THUMB and ARM
+instruction sets. Without this option the two instruction sets cannot
+be reliably used inside one program. The default is
+@samp{-mno-thumb-interwork}, since slightly smaller code is generated
+with this option.
+
+@item -mtpcs-frame
+@kindex -mtpcs-frame
+@kindex -mno-tpcs-frame
+Generate a stack frame that is compliant with the Thumb Procedure Call
+Standard for all non-leaf functions. (A leaf function is one that does
+not call any other functions). The default is @samp{-mno-apcs-frame}.
+
+@item -mtpcs-leaf-frame
+@kindex -mtpcs-leaf-frame
+@kindex -mno-tpcs-leaf-frame
+Generate a stack frame that is compliant with the Thumb Procedure Call
+Standard for all leaf functions. (A leaf function is one that does
+not call any other functions). The default is @samp{-mno-apcs-leaf-frame}.
+
+@item -mlittle-endian
+@kindex -mlittle-endian
+Generate code for a processor running in little-endian mode. This is
+the default for all standard configurations.
+
+@item -mbig-endian
+@kindex -mbig-endian
+Generate code for a processor running in big-endian mode.
+
+@item -mstructure-size-boundary=<n>
+@kindex -mstructure-size-boundary
+The size of all structures and unions will be rounded up to a multiple
+of the number of bits set by this option. Permissable values are 8 and
+32. The default value varies for different toolchains. For the COFF
+targeted toolchain the default value is 8. Specifying the larger number
+can produced faster, more efficient code, but can also increase the size
+of the program. The two values are potentially incompatible. Code
+compiled with one value cannot necessarily expect to work with code or
+libraries compiled with the other value, if they exchange information
+using structures or unions. Programmers are encouraged to use the 32
+value as future versions of the toolchain may default to this value.
+
+@end table
+
+@node MN10200 Options
+@subsection MN10200 Options
+@cindex MN10200 options
+These @samp{-m} options are defined for Matsushita MN10200 architectures:
+@table @code
+
+@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
+has an effect when used on the command line for the final link step.
+
+This option makes symbolic debugging impossible.
+@end table
+
+@node MN10300 Options
+@subsection MN10300 Options
+@cindex MN10300 options
+These @samp{-m} options are defined for Matsushita MN10300 architectures:
+
+@table @code
+@item -mmult-bug
+Generate code to avoid bugs in the multiply instructions for the MN10300
+processors. This is the default.
+
+@item -mno-mult-bug
+Do not generate code to avoid bugs in the multiply instructions for the
+MN10300 processors.
+
+@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
+has an effect when used on the command line for the final link step.
+
+This option makes symbolic debugging impossible.
+@end table
+
+
+@node M32R/D Options
+@subsection M32R/D Options
+@cindex M32R/D options
+
+These @samp{-m} options are defined for Mitsubishi M32R/D architectures:
+
+@table @code
+@item -mcode-model=small
+Assume all objects live in the lower 16MB of memory (so that their addresses
+can be loaded with the @code{ld24} instruction), and assume all subroutines
+are reachable with the @code{bl} instruction.
+This is the default.
+
+The addressability of a particular object can be set with the
+@code{model} attribute.
+
+@item -mcode-model=medium
+Assume objects may be anywhere in the 32 bit address space (the compiler
+will generate @code{seth/add3} instructions to load their addresses), and
+assume all subroutines are reachable with the @code{bl} instruction.
+
+@item -mcode-model=large
+Assume objects may be anywhere in the 32 bit address space (the compiler
+will generate @code{seth/add3} instructions to load their addresses), and
+assume subroutines may not be reachable with the @code{bl} instruction
+(the compiler will generate the much slower @code{seth/add3/jl}
+instruction sequence).
+
+@item -msdata=none
+Disable use of the small data area. Variables will be put into
+one of @samp{.data}, @samp{bss}, or @samp{.rodata} (unless the
+@code{section} attribute has been specified).
+This is the default.
+
+The small data area consists of sections @samp{.sdata} and @samp{.sbss}.
+Objects may be explicitly put in the small data area with the
+@code{section} attribute using one of these sections.
+
+@item -msdata=sdata
+Put small global and static data in the small data area, but do not
+generate special code to reference them.
+
+@item -msdata=use
+Put small global and static data in the small data area, and generate
+special instructions to reference them.
+
+@item -G @var{num}
+@cindex smaller data references
+Put global and static objects less than or equal to @var{num} bytes
+into the small data or bss sections instead of the normal data or bss
+sections. The default value of @var{num} is 8.
+The @samp{-msdata} option must be set to one of @samp{sdata} or @samp{use}
+for this option to have any effect.
+
+All modules should be compiled with the same @samp{-G @var{num}} value.
+Compiling with different values of @var{num} may or may not work; if it
+doesn't the linker will give an error message - incorrect code will not be
+generated.
+
@end table
@node M88K Options
@itemx -mno-powerpc-gpopt
@itemx -mpowerpc-gfxopt
@itemx -mno-powerpc-gfxopt
+@itemx -mpowerpc64
+@itemx -mno-powerpc64
@kindex -mpower
@kindex -mpower2
@kindex -mpowerpc
@kindex -mpowerpc-gpopt
@kindex -mpowerpc-gfxopt
+@kindex -mpowerpc64
GNU CC supports two related instruction set architectures for the
RS/6000 and PowerPC. The @dfn{POWER} instruction set are those
instructions supported by the @samp{rios} chip set used in the original
RS/6000 systems and the @dfn{PowerPC} instruction set is the
architecture of the Motorola MPC5xx, MPC6xx, MPC8xx microprocessors, and
-the IBM 40x microprocessors. The PowerPC architecture defines 64-bit
-instructions, but they are not supported by any current processors.
+the IBM 4xx microprocessors.
Neither architecture is a subset of the other. However there is a
large common subset of instructions supported by both. An MQ
use the optional PowerPC architecture instructions in the Graphics
group, including floating-point select.
+The @samp{-mpowerpc64} option allows GNU CC to generate the additional
+64-bit instructions that are found in the full PowerPC64 architecture
+and to treat GPRs as 64-bit, doubleword quantities. GNU CC defaults to
+@samp{-mno-powerpc64}.
+
If you specify both @samp{-mno-power} and @samp{-mno-powerpc}, GNU CC
will use only the instructions in the common subset of both
architectures plus some special AIX common-mode calls, and will not use
GNU CC uses that mnemonic irrespective of which of these options is
specified.
-PowerPC assemblers support both the old and new mnemonics, as will later
-POWER assemblers. Current POWER assemblers only support the old
-mnemonics. Specify @samp{-mnew-mnemonics} if you have an assembler that
-supports them, otherwise specify @samp{-mold-mnemonics}.
-
-The default value of these options depends on how GNU CC was configured.
-Specifying @samp{-mcpu=@var{cpu_type}} sometimes overrides the value of
-these option. Unless you are building a cross-compiler, you should
-normally not specify either @samp{-mnew-mnemonics} or
+GNU CC defaults to the mnemonics appropriate for the architecture in
+use. Specifying @samp{-mcpu=@var{cpu_type}} sometimes overrides the
+value of these option. Unless you are building a cross-compiler, you
+should normally not specify either @samp{-mnew-mnemonics} or
@samp{-mold-mnemonics}, but should instead accept the default.
@item -mcpu=@var{cpu_type}
+@kindex -mcpu
Set architecture type, register usage, choice of mnemonics, and
instruction scheduling parameters for machine type @var{cpu_type}.
Supported values for @var{cpu_type} are @samp{rs6000}, @samp{rios1},
@samp{rios2}, @samp{rsc}, @samp{601}, @samp{602}, @samp{603},
-@samp{603e}, @samp{604}, @samp{620}, @samp{power}, @samp{power2},
-@samp{powerpc}, @samp{403}, @samp{505}, @samp{821}, and @samp{860} and
-@samp{common}. @samp{-mcpu=power}, @samp{-mcpu=power2}, and
-@samp{-mcpu=powerpc} specify generic POWER, POWER2 and pure PowerPC
-(i.e., not MPC601) architecture machine types, with an appropriate,
-generic processor model assumed for scheduling purposes.@refill
+@samp{603e}, @samp{604}, @samp{604e}, @samp{620}, @samp{power},
+@samp{power2}, @samp{powerpc}, @samp{403}, @samp{505}, @samp{801},
+@samp{821}, @samp{823}, and @samp{860} and @samp{common}.
+@samp{-mcpu=power}, @samp{-mcpu=power2}, and @samp{-mcpu=powerpc}
+specify generic POWER, POWER2 and pure PowerPC (i.e., not MPC601)
+architecture machine types, with an appropriate, generic processor model
+assumed for scheduling purposes.@refill
@c overfull hbox here --bob 22 jul96
@c original text between ignore ... end ignore
@ignore
-Specifying any of the @samp{-mcpu=rios1}, @samp{-mcpu=rios2}, @samp{-mcpu=rsc},
-@samp{-mcpu=power}, or @samp{-mcpu=power2} options enables the @samp{-mpower}
-option and disables the @samp{-mpowerpc} option; @samp{-mcpu=601}
-enables both the @samp{-mpower} and @samp{-mpowerpc} options;
-all of @samp{-mcpu=602}, @samp{-mcpu=603}, @samp{-mcpu=603e}, @samp{-mcpu=604},
-@samp{-mcpu=620}, @samp{-mcpu=403}, @samp{-mcpu=505}, @samp{-mcpu=821},
-@samp{-mcpu=860} and @samp{-mcpu=powerpc} enable the @samp{-mpowerpc}
-option and disable the @samp{-mpower} option; @samp{-mcpu=common}
-disables both the @samp{-mpower} and @samp{-mpowerpc} options.@refill
+Specifying any of the @samp{-mcpu=rios1}, @samp{-mcpu=rios2},
+@samp{-mcpu=rsc}, @samp{-mcpu=power}, or @samp{-mcpu=power2} options
+enables the @samp{-mpower} option and disables the @samp{-mpowerpc}
+option; @samp{-mcpu=601} enables both the @samp{-mpower} and
+@samp{-mpowerpc} options; all of @samp{-mcpu=602}, @samp{-mcpu=603},
+@samp{-mcpu=603e}, @samp{-mcpu=604}, @samp{-mcpu=604e},
+@samp{-mcpu=620}, @samp{-mcpu=403}, @samp{-mcpu=505}, @samp{-mcpu=801},
+@samp{-mcpu=821}, @samp{-mcpu=823}, @samp{-mcpu=860} and
+@samp{-mcpu=powerpc} enable the @samp{-mpowerpc} option and disable the
+@samp{-mpower} option; @samp{-mcpu=common} disables both the
+@samp{-mpower} and @samp{-mpowerpc} options.@refill
@end ignore
@c changed paragraph
Specifying any of the following options:
@itemx -mno-fp-in-toc
@itemx -mno-sum-in-toc
@itemx -mminimal-toc
+@kindex -mminimal-toc
Modify generation of the TOC (Table Of Contents), which is created for
every executable file. The @samp{-mfull-toc} option is selected by
default. In that case, GNU CC will allocate at least one TOC entry for
uses extremely little TOC space. You may wish to use this option
only on files that contain less frequently executed code. @refill
+@item -maix64
+@itemx -maix32
+@kindex -maix64
+@kindex -maix32
+Enable AIX 64-bit ABI and calling convention: 64-bit pointers, 64-bit
+@code{long} type, and the infrastructure needed to support them.
+Specifying @samp{-maix64} implies @samp{-mpowerpc64} and
+@samp{-mpowerpc}, while @samp{-maix32} disables the 64-bit ABI and
+implies @samp{-mno-powerpc64}. GNU CC defaults to @samp{-maix32}.
+
@item -mxl-call
@itemx -mno-xl-call
+@kindex -mxl-call
On AIX, pass floating-point arguments to prototyped functions beyond the
register save area (RSA) on the stack in addition to argument FPRs. The
AIX calling convention was extended but not initially documented to
handle an obscure K&R C case of calling a function that takes the
address of its arguments with fewer arguments than declared. AIX XL
-compilers assume that floating point arguments which do not fit in the
-RSA are on the stack when they compile a subroutine without
+compilers access floating point arguments which do not fit in the
+RSA from the stack when a subroutine is compiled without
optimization. Because always storing floating-point arguments on the
stack is inefficient and rarely needed, this option is not enabled by
default and only is necessary when calling subroutines compiled by AIX
XL compilers without optimization.
+@item -mthreads
+@kindex -mthreads
+Support @dfn{AIX Threads}. Link an application written to use
+@dfn{pthreads} with special libraries and startup code to enable the
+application to run.
+
+@item -mpe
+@kindex -mpe
+Support @dfn{IBM RS/6000 SP} @dfn{Parallel Environment} (PE). Link an
+application written to use message passing with special startup code to
+enable the application to run. The system must have PE installed in the
+standard location (@file{/usr/lpp/ppe.poe/}), or the @file{specs} file
+must be overridden with the @samp{-specs=} option to specify the
+appropriate directory location. The Parallel Environment does not
+support threads, so the @samp{-mpe} option and the @samp{-mthreads}
+option are incompatible.
+
@item -msoft-float
@itemx -mhard-float
+@kindex -msoft-float
Generate code that does not use (uses) the floating-point register set.
Software floating point emulation is provided if you use the
@samp{-msoft-float} option, and pass the option to GNU CC when linking.
@item -mstring
@itemx -mno-string
+@kindex -mstring
Generate code that uses (does not use) the load string instructions and the
store string word instructions to save multiple registers and do small block
-moves. These instructions are generated by default on POWER systems, anod not
+moves. These instructions are generated by default on POWER systems, and not
generated on PowerPC systems. Do not use @samp{-mstring} on little endian
PowerPC systems, since those instructions do not work when the processor is in
little endian mode.
+@item -mupdate
+@itemx -mno-update
+@kindex -mupdate
+Generate code that uses (does not use) the load or store instructions
+that update the base register to the address of the calculated memory
+location. These instructions are generated by default. If you use
+@samp{-mno-update}, there is a small window between the time that the
+stack pointer is updated and the address of the previous frame is
+stored, which means code that walks the stack frame across interrupts or
+signals may get corrupted data.
+
+@item -mfused-madd
+@itemx -mno-fused-madd
+@kindex -mfused-madd
+Generate code that uses (does not use) the floating point multiply and
+accumulate instructions. These instructions are generated by default if
+hardware floating is used.
+
@item -mno-bit-align
@itemx -mbit-align
+@kindex -mbit-align
On System V.4 and embedded PowerPC systems do not (do) force structures
and unions that contain bit fields to be aligned to the base type of the
bit field.
@item -mno-strict-align
@itemx -mstrict-align
+@kindex -mstrict-align
On System V.4 and embedded PowerPC systems do not (do) assume that
unaligned memory references will be handled by the system.
@item -mrelocatable
@itemx -mno-relocatable
+@kindex -mrelocatable
On embedded PowerPC systems generate code that allows (does not allow)
the program to be relocated to a different address at runtime. If you
use @samp{-mrelocatable} on any module, all objects linked together must
@itemx -mno-relocatable-lib
On embedded PowerPC systems generate code that allows (does not allow)
the program to be relocated to a different address at runtime. Modules
-compiled with @samp{-mreloctable-lib} can be linked with either modules
+compiled with @samp{-mrelocatable-lib} can be linked with either modules
compiled without @samp{-mrelocatable} and @samp{-mrelocatable-lib} or
with modules compiled with the @samp{-mrelocatable} options.
register 2 contains a pointer to a global area pointing to the addresses
used in the program.
-@item -mno-traceback
-@itemx -mtraceback
-On embedded PowerPC systems do not (do) generate a traceback tag before
-the start of the function. This tag can be used by the debugger to
-identify where the start of a function is.
-
@item -mlittle
@itemx -mlittle-endian
On System V.4 and embedded PowerPC systems compile code for the
operating system.
@item -mcall-linux
-On System V.4 and embedded PowerPC systems compile code for the Linux
-operating system.
+On System V.4 and embedded PowerPC systems compile code for the
+Linux-based GNU system.
@item -mprototype
-@item -mno-prototype
+@itemx -mno-prototype
On System V.4 and embedded PowerPC systems assume that all calls to
variable argument functions are properly prototyped. Otherwise, the
compiler must insert an instruction before every non prototyped call to
@item -mmvme
On embedded PowerPC systems, assume that the startup module is called
-@file{mvme-crt0.o} and the standard C libraries are @file{libmvme.a} and
+@file{crt0.o} and the standard C libraries are @file{libmvme.a} and
+@file{libc.a}.
+
+@item -mads
+On embedded PowerPC systems, assume that the startup module is called
+@file{crt0.o} and the standard C libraries are @file{libads.a} and
+@file{libc.a}.
+
+@item -myellowknife
+On embedded PowerPC systems, assume that the startup module is called
+@file{crt0.o} and the standard C libraries are @file{libyk.a} and
@file{libc.a}.
@item -memb
@item -G @var{num}
@cindex smaller data references (PowerPC)
@cindex .sdata/.sdata2 references (PowerPC)
-On embbeded PowerPC systems, put global and static items less than or
+On embedded PowerPC systems, put global and static items less than or
equal to @var{num} bytes into the small data or bss sections instead of
the normal data or bss section. By default, @var{num} is 8. The
@samp{-G @var{num}} switch is also passed to the linker.
@samp{r4000} is the default @var{cpu type} at this ISA level.
This option does not change the sizes of any of the C data types.
+@item -mips4
+Issue instructions from level 4 of the MIPS ISA. @samp{r8000} is the
+default @var{cpu type} at this ISA level.
+
@item -mfp32
Assume that 32 32-bit floating point registers are available. This is
the default.
Types long and pointer are 64 bits, and type int is 32 bits.
This works only if @samp{-mips3} is also specified.
+@itemx -mabi=32
+@itemx -mabi=n32
+@itemx -mabi=64
+@itemx -mabi=eabi
+Generate code for the indicated ABI.
+
@item -mmips-as
Generate code for the MIPS assembler, and invoke @file{mips-tfile} to
add normal debug information. This is the default for all
@item -mgas
Generate code for the GNU assembler. This is the default on the OSF/1
-reference platform, using the OSF/rose object format.
+reference platform, using the OSF/rose object format. Also, this is
+the default if the configure option @samp{--with-gnu-as} is used.
+
+@item -msplit-addresses
+@itemx -mno-split-addresses
+Generate code to load the high and low parts of address constants separately.
+This allows @code{gcc} to optimize away redundant loads of the high order
+bits of addresses. This optimization requires GNU as and GNU ld.
+This optimization is enabled by default for some embedded targets where
+GNU as and GNU ld are standard.
@item -mrnames
@itemx -mno-rnames
@item -membedded-pic
@itemx -mno-embedded-pic
-Generate PIC code suitable for some embedded systems. All calls are made
-using PC relative address, and all data is addressed using the $gp register.
-This requires GNU as and GNU ld which do most of the work.
+Generate PIC code suitable for some embedded systems. All calls are
+made using PC relative address, and all data is addressed using the $gp
+register. No more than 65536 bytes of global data may be used. This
+requires GNU as and GNU ld which do most of the work. This currently
+only works on targets which use ECOFF; it does not work with ELF.
@item -membedded-data
@itemx -mno-embedded-data
value.
@item -nocpp
-Tell the MIPS assembler to not run it's preprocessor over user
+Tell the MIPS assembler to not run its preprocessor over user
assembler files (with a @samp{.s} suffix) when assembling them.
@end table
These @samp{-m} options are defined for the i386 family of computers:
@table @code
-@item -m486
-@itemx -m386
-Control whether or not code is optimized for a 486 instead of an
-386. Code generated for an 486 will run on a 386 and vice versa.
+@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: @samp{i386},
+@samp{i486}, @samp{i586} (@samp{pentium}), @samp{pentium}, @samp{i686}
+(@samp{pentiumpro}) and @samp{pentiumpro}. While picking a specific
+@var{cpu type} will schedule things appropriately for that particular
+chip, the compiler will not generate any code that does not run on the
+i386 without the @samp{-march=@var{cpu type}} option being used.
+
+@item -march=@var{cpu type}
+Generate instructions for the machine type @var{cpu type}. The choices
+for @var{cpu type} are: @samp{i386}, @samp{i486}, @samp{pentium}, and
+@samp{pentiumpro}. Specifying @samp{-march=@var{cpu type}} implies
+@samp{-mcpu=@var{cpu type}}.
+
+@item -m386
+@itemx -m486
+@itemx -mpentium
+@itemx -mpentiumpro
+Synonyms for -mcpu=i386, -mcpu=i486, -mcpu=pentium, and -mcpu=pentiumpro
+respectively.
@item -mieee-fp
@itemx -mno-ieee-fp
@item -malign-loops=@var{num}
Align loops to a 2 raised to a @var{num} byte boundary. If
-@samp{-malign-loops} is not specified, the default is 2.
+@samp{-malign-loops} is not specified, the default is 2 unless
+gas 2.8 (or later) is being used in which case the default is
+to align the loop on a 16 byte boundary if it is less than 8
+bytes away.
@item -malign-jumps=@var{num}
Align instructions that are only jumped to to a 2 raised to a @var{num}
byte boundary. If @samp{-malign-jumps} is not specified, the default is
-2 if optimizing for a 386, and 4 if optimizing for a 486.
+2 if optimizing for a 386, and 4 if optimizing for a 486 unless
+gas 2.8 (or later) is being used in which case the default is
+to align the instruction on a 16 byte boundary if it is less
+than 8 bytes away.
@item -malign-functions=@var{num}
Align the start of functions to a 2 raised to @var{num} byte boundary.
-If @samp{-malign-jumps} is not specified, the default is 2 if optimizing
+If @samp{-malign-functions} is not specified, the default is 2 if optimizing
for a 386, and 4 if optimizing for a 486.
@end table
@item -mpa-risc-1-1
Generate code for a PA 1.1 processor.
+@item -mbig-switch
+Generate code suitable for big switch tables. Use this option only if
+the assembler/linker complain about out of range branches within a switch
+table.
+
@item -mjump-in-delay
Fill delay slots of function calls with unconditional jump instructions
by modifying the return pointer for the function call to be the target
@item -mspace
Optimize for space rather than execution time. Currently this only
enables out of line function prologues and epilogues. This option is
-incompatable with PIC code generation and profiling.
+incompatible with PIC code generation and profiling.
@item -mlong-load-store
Generate 3-instruction load and store sequences as sometimes required by
@item -mschedule=@var{cpu type}
Schedule code according to the constraints for the machine type
@var{cpu type}. The choices for @var{cpu type} are @samp{700} for
-7@var{n}0 machines, @samp{7100} for 7@var{n}5 machines, and @samp{7100}
+7@var{n}0 machines, @samp{7100} for 7@var{n}5 machines, and @samp{7100LC}
for 7@var{n}2 machines. @samp{7100} is the default for @var{cpu type}.
Note the @samp{7100LC} scheduling information is incomplete and using
@item -mold-align
Enable structure-alignment compatibility with Intel's gcc release version
-1.3 (based on gcc 1.37). Currently this is buggy in that @samp{#pragma
-align 1} is always assumed as well, and cannot be turned off.
+1.3 (based on gcc 1.37). This option implies @samp{-mstrict-align}.
@end table
@node DEC Alpha Options
Normally GNU CC examines a 32- or 64-bit integer constant to
see if it can construct it from smaller constants in two or three
instructions. If it cannot, it will output the constant as a literal and
-generate code to load it from the data segement at runtime.
+generate code to load it from the data segment at runtime.
Use this option to require GNU CC to construct @emph{all} integer constants
using code, even if it takes more instructions (the maximum is six).
You would typically use this option to build a shared library dynamic
loader. Itself a shared library, it must relocate itself in memory
before it can find the variables and constants in its own data segment.
+
+@item -malpha-as
+@itemx -mgas
+Select whether to generate code to be assembled by the vendor-supplied
+assembler (@samp{-malpha-as}) or by the GNU assembler @samp{-mgas}.
+
+@item -mbwx
+@itemx -mno-bwx
+@itemx -mcix
+@itemx -mno-cix
+@itemx -mmax
+@itemx -mno-max
+Indicate whether GNU CC should generate code to use the optional BWX,
+CIX, and MAX instruction sets. The default is to use the instruction sets
+supported by the CPU type specified via @samp{-mcpu=} option or that
+of the CPU on which GNU CC was built if none was specified.
+
+@item -mcpu=@var{cpu_type}
+Set the instruction set, register set, and instruction scheduling
+parameters for machine type @var{cpu_type}. You can specify either the
+@samp{EV} style name or the corresponding chip number. GNU CC
+supports scheduling parameters for the EV4 and EV5 family of processors
+and will choose the default values for the instruction set from
+the processor you specify. If you do not specify a processor type,
+GNU CC will default to the processor on which the compiler was built.
+
+Supported values for @var{cpu_type} are
+
+@table @samp
+@item ev4
+@itemx 21064
+Schedules as an EV4 and has no instruction set extensions.
+
+@item ev5
+@itemx 21164
+Schedules as an EV5 and has no instruction set extensions.
+
+@item ev56
+@itemx 21164a
+Schedules as an EV5 and supports the BWX extension.
+
+@item pca56
+@itemx 21164pc
+@itemx 21164PC
+Schedules as an EV5 and supports the BWX and MAX extensions.
+
+@item ev6
+@itemx 21264
+Schedules as an EV5 (until Digital releases the scheduling parameters
+for the EV6) and supports the BWX, CIX, and MAX extensions.
+@end table
+
+@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
+and the size of the external cache on the machine.
+
+Valid options for @var{time} are
+
+@table @samp
+@item @var{number}
+A decimal number representing clock cycles.
+
+@item L1
+@itemx L2
+@itemx L3
+@itemx main
+The compiler contains estimates of the number of clock cycles for
+``typical'' EV4 & EV5 hardware for the Level 1, 2 & 3 caches
+(also called Dcache, Scache, and Bcache), as well as to main memory.
+Note that L3 is only valid for EV5.
+
+@end table
@end table
@node Clipper Options
@item -mh
Generate code for the H8/300H.
+@item -ms
+Generate code for the H8/S.
+
@item -mint32
Make @code{int} data 32 bits by default.
@item -ml
Compile code for the processor in little endian mode.
+@item -mdalign
+Align doubles at 64 bit boundaries. Note that this changes the calling
+conventions, and thus some functions from the standard C library will
+not work unless you recompile it first with -mdalign.
+
@item -mrelax
Shorten some address references at link time, when possible; uses the
linker option @samp{-relax}.
@c the generic assembler that comes with Solaris takes just -Ym.
@end table
+@node V850 Options
+@subsection V850 Options
+@cindex V850 Options
+
+These @samp{-m} options are defined for V850 implementations:
+
+@table @code
+@item -mlong-calls
+@itemx -mno-long-calls
+Treat all calls as being far away (near). If calls are assumed to be
+far away, the compiler will always load the functions address up into a
+register, and call indirect through the pointer.
+
+@item -mno-ep
+@itemx -mep
+Do not optimize (do optimize) basic blocks that use the same index
+pointer 4 or more times to copy pointer into the @code{ep} register, and
+use the shorter @code{sld} and @code{sst} instructions. The @samp{-mep}
+option is on by default if you optimize.
+
+@item -mno-prolog-function
+@itemx -mprolog-function
+Do not use (do use) external functions to save and restore registers at
+the prolog and epilog of a function. The external functions are slower,
+but use less code space if more than one function saves the same number
+of registers. The @samp{-mprolog-function} option is on by default if
+you optimize.
+
+@item -mspace
+Try to make the code as small as possible. At present, this just turns
+on the @samp{-mep} and @samp{-mprolog-function} options.
+
+@item -mtda=@var{n}
+Put static or global variables whose size is @var{n} bytes or less into
+the tiny data area that register @code{ep} points to. The tiny data
+area can hold up to 256 bytes in total (128 bytes for byte references).
+
+@item -msda=@var{n}
+Put static or global variables whose size is @var{n} bytes or less into
+the small data area that register @code{gp} points to. The small data
+area can hold up to 64 kilobytes.
+
+@item -mzda=@var{n}
+Put static or global variables whose size is @var{n} bytes or less into
+the first 32 kilobytes of memory.
+
+@item -mv850
+Specify that the target processor is the V850.
+
+@item -mbig-switch
+Generate code suitable for big switch tables. Use this option only if
+the assembler/linker complain about out of range branches within a switch
+table.
+@end table
+
+@node ARC Options
+@subsection ARC Options
+@cindex ARC Options
+
+These options are defined for ARC implementations:
+
+@table @code
+@item -EL
+Compile code for little endian mode. This is the default.
+
+@item -EB
+Compile code for big endian mode.
+
+@item -mmangle-cpu
+Prepend the name of the cpu to all public symbol names.
+In multiple-processor systems, there are many ARC variants with different
+instruction and register set characteristics. This flag prevents code
+compiled for one cpu to be linked with code compiled for another.
+No facility exists for handling variants that are "almost identical".
+This is an all or nothing option.
+
+@item -mcpu=@var{cpu}
+Compile code for ARC variant @var{cpu}.
+Which variants are supported depend on the configuration.
+All variants support @samp{-mcpu=base}, this is the default.
+
+@item -mtext=@var{text section}
+@item -mdata=@var{data section}
+@item -mrodata=@var{readonly data section}
+Put functions, data, and readonly data in @var{text section},
+@var{data section}, and @var{readonly data section} respectively
+by default. This can be overridden with the @code{section} attribute.
+@xref{Variable Attributes}
+
+@end table
+
+@node NS32K Options
+@subsection NS32K Options
+@cindex NS32K options
+
+These are the @samp{-m} options defined for the 32000 series. The default
+values for these options depends on which style of 32000 was selected when
+the compiler was configured; the defaults for the most common choices are
+given below.
+
+@table @code
+@item -m32032
+@itemx -m32032
+Generate output for a 32032. This is the default
+when the compiler is configured for 32032 and 32016 based systems.
+
+@item -m32332
+@itemx -m32332
+Generate output for a 32332. This is the default
+when the compiler is configured for 32332-based systems.
+
+@item -m32532
+@itemx -m32532
+Generate output for a 32532. This is the default
+when the compiler is configured for 32532-based systems.
+
+@item -m32081
+Generate output containing 32081 instructions for floating point.
+This is the default for all systems.
+
+@item -m32381
+Generate output containing 32381 instructions for floating point. This
+also implies @samp{-m32081}. The 32381 is only compatible with the 32332
+and 32532 cpus. This is the default for the pc532-netbsd configuration.
+
+@item -mmulti-add
+Try and generate multiply-add floating point instructions @code{polyF}
+and @code{dotF}. This option is only available if the @samp{-m32381}
+option is in effect. Using these instructions requires changes to to
+register allocation which generally has a negative impact on
+performance. This option should only be enabled when compiling code
+particularly likely to make heavy use of multiply-add instructions.
+
+@item -mnomulti-add
+Do not try and generate multiply-add floating point instructions
+@code{polyF} and @code{dotF}. This is the default on all platforms.
+
+@item -msoft-float
+Generate output containing library calls for floating point.
+@strong{Warning:} the requisite libraries may not be available.
+
+@item -mnobitfield
+Do not use the bit-field instructions. On some machines it is faster to
+use shifting and masking operations. This is the default for the pc532.
+
+@item -mbitfield
+Do use the bit-field instructions. This is the default for all platforms
+except the pc532.
+
+@item -mrtd
+Use a different function-calling convention, in which functions
+that take a fixed number of arguments return pop their
+arguments on return with the @code{ret} instruction.
+
+This calling convention is incompatible with the one normally
+used on Unix, so you cannot use it if you need to call libraries
+compiled with the Unix compiler.
+
+Also, you must provide function prototypes for all functions that
+take variable numbers of arguments (including @code{printf});
+otherwise incorrect code will be generated for calls to those
+functions.
+
+In addition, seriously incorrect code will result if you call a
+function with too many arguments. (Normally, extra arguments are
+harmlessly ignored.)
+
+This option takes its name from the 680x0 @code{rtd} instruction.
+
+
+@item -mregparam
+Use a different function-calling convention where the first two arguments
+are passed in registers.
+
+This calling convention is incompatible with the one normally
+used on Unix, so you cannot use it if you need to call libraries
+compiled with the Unix compiler.
+
+@item -mnoregparam
+Do not pass any arguments in registers. This is the default for all
+targets.
+
+@item -msb
+It is OK to use the sb as an index register which is always loaded with
+zero. This is the default for the pc532-netbsd target.
+
+@item -mnosb
+The sb register is not available for use or has not been initialized to
+zero by the run time system. This is the default for all targets except
+the pc532-netbsd. It is also implied whenever @samp{-mhimem} or
+@samp{-fpic} is set.
+
+@item -mhimem
+Many ns32000 series addressing modes use displacements of up to 512MB.
+If an address is above 512MB then displacements from zero can not be used.
+This option causes code to be generated which can be loaded above 512MB.
+This may be useful for operating systems or ROM code.
+
+@item -mnohimem
+Assume code will be loaded in the first 512MB of virtual address space.
+This is the default for all platforms.
+
+
+@end table
+
+
+
@node Code Gen Options
@section Options for Code Generation Conventions
@cindex code generation conventions
it.
@table @code
+@item -fexceptions
+Enable exception handling. Generates extra code needed to propagate
+exceptions. For some targets, this implies generation of frame unwind
+information for all functions. This can produce significant data size
+overhead, although it does not affect execution.
+If you do not specify this option, it is enabled by
+default for languages like C++ which normally require exception handling,
+and disabled for languages like C that do not normally require it.
+However, when compiling C code that needs to interoperate properly with
+exception handlers written in C++, you may need to enable this option.
+You may also wish to disable this option is you are compiling older C++
+programs that don't use exception handling.
+
@item -fpcc-struct-return
Return ``short'' @code{struct} and @code{union} values in memory like
longer ones, rather than in registers. This convention is less
who actually need to read the generated assembly code (perhaps while
debugging the compiler itself).
-@samp{-fverbose-asm} is the default. @samp{-fno-verbose-asm} causes the
+@samp{-fno-verbose-asm}, the default, causes the
extra information to be omitted and is useful when comparing two assembler
files.
@cindex PIC
Generate position-independent code (PIC) suitable for use in a shared
library, if supported for the target machine. Such code accesses all
-constant addresses through a global offset table (GOT). If the GOT size
-for the linked executable exceeds a machine-specific maximum size, you
-get an error message from the linker indicating that @samp{-fpic} does
-not work; in that case, recompile with @samp{-fPIC} instead. (These
-maximums are 16k on the m88k, 8k on the Sparc, and 32k on the m68k and
-RS/6000. The 386 has no such limit.)
+constant addresses through a global offset table (GOT). The dynamic
+loader resolves the GOT entries when the program starts (the dynamic
+loader is not part of GNU CC; it is part of the operating system). If
+the GOT size for the linked executable exceeds a machine-specific
+maximum size, you get an error message from the linker indicating that
+@samp{-fpic} does not work; in that case, recompile with @samp{-fPIC}
+instead. (These maximums are 16k on the m88k, 8k on the Sparc, and 32k
+on the m68k and RS/6000. The 386 has no such limit.)
Position-independent code requires special support, and therefore works
only on certain machines. For the 386, GNU CC supports PIC for System V
but not for the Sun 386i. Code generated for the IBM RS/6000 is always
position-independent.
-The GNU assembler does not fully support PIC. Currently, you must use
-some other assembler in order for PIC to work. We would welcome
-volunteers to upgrade GAS to handle this; the first part of the job is
-to figure out what the assembler must do differently.
-
@item -fPIC
If supported for the target machine, emit position-independent code,
suitable for dynamic linking and avoiding any limit on the size of the
three-way choice.
@item -fcall-used-@var{reg}
-Treat the register named @var{reg} as an allocatable register that is
+Treat the register named @var{reg} as an allocable register that is
clobbered by function calls. It may be allocated for temporaries or
variables that do not live across a call. Functions compiled this way
will not save and restore the register @var{reg}.
-Use of this flag for a register that has a fixed pervasive role in the
-machine's execution model, such as the stack pointer or frame pointer,
-will produce disastrous results.
+It is an error to used this flag with the frame pointer or stack pointer.
+Use of this flag for other registers that have fixed pervasive roles in
+the machine's execution model will produce disastrous results.
This flag does not have a negative form, because it specifies a
three-way choice.
@item -fcall-saved-@var{reg}
-Treat the register named @var{reg} as an allocatable register saved by
+Treat the register named @var{reg} as an allocable register saved by
functions. It may be allocated even for temporaries or variables that
live across a call. Functions compiled this way will save and restore
the register @var{reg} if they use it.
-Use of this flag for a register that has a fixed pervasive role in the
-machine's execution model, such as the stack pointer or frame pointer,
-will produce disastrous results.
+It is an error to used this flag with the frame pointer or stack pointer.
+Use of this flag for other registers that have fixed pervasive roles in
+the machine's execution model will produce disastrous results.
A different sort of disaster will result from the use of this flag for
a register in which function values may be returned.
not want to use this option, since it makes the code suboptimal, and
the offsets of structure members won't agree with system libraries.
-@item +e0
-@itemx +e1
-Control whether virtual function definitions in classes are used to
-generate code, or only to define interfaces for their callers. (C++
-only).
+@item -fcheck-memory-usage
+Generate extra code to check each memory access. GNU CC will generate
+code that is suitable for a detector of bad memory accesses such as
+@file{Checker}.
+
+You must also specify this option when you compile functions you call that
+have side effects. If you do not, you may get erroneous messages from
+the detector. Normally, you should compile all your code with this option.
+If you use functions from a library that have side-effects (such as
+@code{read}), you may not be able to recompile the library and
+specify this option. In that case, you can enable the
+@samp{-fprefix-function-name} option, which requests GNU CC to encapsulate
+your code and make other functions look as if they were compiled with
+@samp{-fcheck-memory-usage}. This is done by calling ``stubs'',
+which are provided by the detector. If you cannot find or build
+stubs for every function you call, you may have to specify
+@samp{-fcheck-memory-usage} without @samp{-fprefix-function-name}.
+
+If you specify this option, you can not use the @code{asm} or
+@code{__asm__} keywords in functions with memory checking enabled. The
+compiler cannot understand what the @code{asm} statement will do, and
+therefore cannot generate the appropriate code, so it is rejected.
+However, the function attribute @code{no_check_memory_usage} will
+disable memory checking within a function, and @code{asm} statements can
+be put inside such functions. Inline expansion of a non-checked
+function within a checked function is permitted; the inline function's
+memory accesses won't be checked, but the rest will.
+
+If you move your @code{asm} statements to non-checked inline functions,
+but they do access memory, you can add calls to the support code in your
+inline function, to indicate any reads, writes, or copies being done.
+These calls would be similar to those done in the stubs described above.
+
+@c FIXME: The support-routine interface is defined by the compiler and
+@c should be documented!
+
+@item -fprefix-function-name
+Request GNU CC to add a prefix to the symbols generated for function names.
+GNU CC adds a prefix to the names of functions defined as well as
+functions called. Code compiled with this option and code compiled
+without the option can't be linked together, unless or stubs are used.
+
+If you compile the following code with @samp{-fprefix-function-name}
+@example
+extern void bar (int);
+void
+foo (int a)
+@{
+ return bar (a + 5);
+
+@}
+@end example
+
+@noindent
+GNU CC will compile the code as if it was written:
+@example
+extern void prefix_bar (int);
+void
+prefix_foo (int a)
+@{
+ return prefix_bar (a + 5);
+@}
+@end example
+This option is designed to be used with @samp{-fcheck-memory-usage}.
-These options are provided for compatibility with @code{cfront} 1.x
-usage; the recommended alternative GNU C++ usage is in flux. @xref{C++
-Interface,,Declarations and Definitions in One Header}.
+@item -finstrument-functions
+Generate instrumentation calls for entry and exit to functions. Just
+after function entry and just before function exit, the following
+profiling functions will be called with the address of the current
+function and its call site. (On some platforms,
+@code{__builtin_return_address} does not work beyond the current
+function, so the call site information may not be available to the
+profiling functions otherwise.)
-With @samp{+e0}, virtual function definitions in classes are declared
-@code{extern}; the declaration is used only as an interface
-specification, not to generate code for the virtual functions (in this
-compilation).
+@example
+void __cyg_profile_func_enter (void *this_fn, void *call_site);
+void __cyg_profile_func_exit (void *this_fn, void *call_site);
+@end example
-With @samp{+e1}, G++ actually generates the code implementing virtual
-functions defined in the code, and makes them publicly visible.
+The first argument is the address of the start of the current function,
+which may be looked up exactly in the symbol table.
+
+This instrumentation is also done for functions expanded inline in other
+functions. The profiling calls will indicate where, conceptually, the
+inline function is entered and exited. This means that addressable
+versions of such functions must be available. If all your uses of a
+function are expanded inline, this may mean an additional expansion of
+code size. If you use @samp{extern inline} in your C code, an
+addressable version of such functions must be provided. (This is
+normally the case anyways, but if you get lucky and the optimizer always
+expands the functions inline, you might have gotten away without
+providing static copies.)
+
+A function may be given the attribute @code{no_instrument_function}, in
+which case this instrumentation will not be done. This can be used, for
+example, for the profiling functions listed above, high-priority
+interrupt routines, and any functions from which the profiling functions
+cannot safely be called (perhaps signal handlers, if the profiling
+routines generate output or allocate memory).
+
+@item -fstack-check
+Generate code to verify that you do not go beyond the boundary of the
+stack. You should specify this flag if you are running in an
+environment with multiple threads, but only rarely need to specify it in
+a single-threaded environment since stack overflow is automatically
+detected on nearly all systems if there is only one stack.
+
+@cindex aliasing of parameters
+@cindex parameters, aliased
+@item -fargument-alias
+@itemx -fargument-noalias
+@itemx -fargument-noalias-global
+Specify the possible relationships among parameters and between
+parameters and global data.
+
+@samp{-fargument-alias} specifies that arguments (parameters) may
+alias each other and may alias global storage.
+@samp{-fargument-noalias} specifies that arguments do not alias
+each other, but may alias global storage.
+@samp{-fargument-noalias-global} specifies that arguments do not
+alias each other and do not alias global storage.
+
+Each language will automatically use whatever option is required by
+the language standard. You should not need to use these options yourself.
+
+@item -fleading-underscore
+This option and its counterpart, -fno-leading-underscore, forcibly
+change the way C symbols are represented in the object file. One use
+is to help link with legacy assembly code.
+
+Be warned that you should know what you are doing when invoking this
+option, and that not all targets provide complete support for it.
@end table
@node Environment Variables
@cindex environment variables
This section describes several environment variables that affect how GNU
-CC operates. They work by specifying directories or prefixes to use
-when searching for various kinds of files.
+CC 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
+aspects of the compilation environment.
@ifclear INTERNALS
Note that you can also specify places to search using options such as
name from the source file name. Or the value can have the form
@samp{@var{file} @var{target}}, in which case the rules are written to
file @var{file} using @var{target} as the target name.
+
+@item LANG
+@findex LANG
+@cindex locale definition
+This variable is used to pass locale information to the compiler. One way in
+which this information is used is to determine the character set to be used
+when character literals, string literals and comments are parsed in C and C++.
+When the compiler is configured to allow multibyte characters,
+the following values for @code{LANG} are recognized:
+
+@table @code
+@item C-JIS
+Recognize JIS characters.
+@item C-SJIS
+Recognize SJIS characters.
+@item C-EUCJP
+Recognize EUCJP characters.
+@end table
+
+If @code{LANG} is not defined, or if it has some other value, then the
+compiler will use mblen and mbtowc as defined by the default locale to
+recognize and translate multibyte characters.
@end table
@node Running Protoize
OSDN Git Service
