home | help
GCC(1)				       GNU				  GCC(1)

NAME
     gcc - GNU project C and C++ compiler

SYNOPSIS
     gcc [-c|-S|-E] [-std=standard]
	 [-g] [-pg] [-Olevel]
	 [-Wwarn...] [-pedantic]
	 [-Idir...] [-Ldir...]
	 [-Dmacro[=defn]...] [-Umacro]
	 [-foption...] [-mmachine-option...]
	 [-o outfile] [@file] infile...

     Only  the most useful options are listed here; see below for the remainder.
     g++ accepts mostly the same options as gcc.

DESCRIPTION
     When you invoke GCC, it normally does preprocessing, compilation,	assembly
     and  linking.   The  "overall options" allow you to stop this process at an
     intermediate stage.  For example, the -c option says not to run the linker.
     Then the output consists of object files output by the assembler.

     Other options are passed on to one stage of processing.  Some options  con-
     trol  the	preprocessor  and others the compiler itself.  Yet other options
     control the assembler and linker; most of these are  not  documented  here,
     since you rarely need to use any of them.

     Most of the command line options that you can use with GCC are useful for C
     programs;	when  an  option  is  only useful with another language (usually
     C++), the explanation says so explicitly.	If the description for a partic-
     ular option does not mention a source language, you  can  use  that  option
     with all supported languages.

     The  gcc  program accepts options and file names as operands.  Many options
     have multi-letter names; therefore multiple single-letter options	may  not
     be grouped: -dr is very different from -d -r.

     You  can mix options and other arguments.	For the most part, the order you
     use doesn't matter.  Order does matter when you use several options of  the
     same  kind;  for example, if you specify -L more than once, the directories
     are searched in the order specified.

     Many options have long names starting with -f  or	with  -W---for	example,
     -fmove-loop-invariants,  -Wformat and so on.  Most of these have both posi-
     tive and negative forms; the negative form  of  -ffoo  would  be  -fno-foo.
     This manual documents only one of these two forms, whichever one is not the
     default.

OPTIONS
     Option Summary

     Here is a summary of all the options, grouped by type.  Explanations are in
     the following sections.

     Overall Options
	 -c   -S   -E  -o file	-combine -pipe	-pass-exit-codes -x language  -v
	 -###  --help  --target-help  --version @file

     C Language Options
	 -ansi	 -std=standard	 -fgnu89-inline  -aux-info   filename	-fno-asm
	 -fno-builtin	-fno-builtin-function  -fhosted  -ffreestanding -fopenmp
	 -fms-extensions -trigraphs  -no-integrated-cpp   -traditional	 -tradi-
	 tional-cpp -fallow-single-precision  -fcond-mismatch -fsigned-bitfields
	 -fsigned-char -funsigned-bitfields  -funsigned-char

     C++ Language Options
	 -fabi-version=n    -fno-access-control    -fcheck-new	-fconserve-space
	 -ffriend-injection    -fno-elide-constructors	   -fno-enforce-eh-specs
	 -ffor-scope   -fno-for-scope  -fno-gnu-keywords -fno-implicit-templates
	 -fno-implicit-inline-templates -fno-implement-inlines	 -fms-extensions
	 -fno-nonansi-builtins	 -fno-operator-names -fno-optional-diags  -fper-
	 missive -frepo   -fno-rtti   -fstats	-ftemplate-depth-n  -fno-thread-
	 safe-statics  -fuse-cxa-atexit  -fno-weak  -nostdinc++ -fno-default-in-
	 line  -fvisibility-inlines-hidden -Wabi  -Wctor-dtor-privacy -Wnon-vir-
	 tual-dtor  -Wreorder -Weffc++	-Wno-deprecated   -Wstrict-null-sentinel
	 -Wno-non-template-friend      -Wold-style-cast     -Woverloaded-virtual
	 -Wno-pmf-conversions -Wsign-promo

     Language Independent Options
	 -fmessage-length=n -fdiagnostics-show-location=[once|every-line]  -fdi-
	 agnostics-show-option

     Warning Options
	 -fsyntax-only	 -pedantic   -pedantic-errors  -w  -Wextra  -Wall  -Wad-
	 dress	 -Waggregate-return  -Wno-attributes  -Wc++-compat  -Wcast-align
	 -Wcast-qual   -Wchar-subscripts   -Wcomment  -Wconversion   -Wno-depre-
	 cated-declarations -Wdisabled-optimization  -Wno-div-by-zero	-Wno-en-
	 dif-labels   -Werror	-Werror=*  -Werror-implicit-function-declaration
	 -Wfatal-errors   -Wfloat-equal   -Wformat   -Wformat=2  -Wno-format-ex-
	 tra-args -Wformat-nonliteral -Wformat-security  -Wformat-y2k -Wimplicit
	 -Wimplicit-function-declaration   -Wimplicit-int  -Wimport  -Wno-import
	 -Winit-self   -Winline  -Wno-int-to-pointer-cast  -Wno-invalid-offsetof
	 -Winvalid-pch	     -Wlarger-than-len	     -Wunsafe-loop-optimizations
	 -Wlong-long  -Wmain	-Wmissing-braces    -Wmissing-field-initializers
	 -Wmissing-format-attribute   -Wmissing-include-dirs  -Wmissing-noreturn
	 -Wno-multichar  -Wnonnull  -Wno-overflow -Woverlength-strings	-Wpacked
	 -Wpadded -Wparentheses  -Wpointer-arith  -Wno-pointer-to-int-cast -Wre-
	 dundant-decls -Wreturn-type  -Wsequence-point	-Wshadow  -Wsign-compare
	 -Wstack-protector  -Wstrict-aliasing -Wstrict-aliasing=2 -Wstrict-over-
	 flow  -Wstrict-overflow=n  -Wswitch   -Wswitch-default    -Wswitch-enum
	 -Wsystem-headers  -Wtrigraphs	-Wundef  -Wuninitialized -Wunknown-prag-
	 mas	-Wno-pragmas   -Wunreachable-code   -Wunused   -Wunused-function
	 -Wunused-label   -Wunused-parameter  -Wunused-value   -Wunused-variable
	 -Wvariadic-macros -Wvolatile-register-var  -Wwrite-strings

     C-only Warning Options
	 -Wbad-function-cast	  -Wmissing-declarations    -Wmissing-prototypes
	 -Wnested-externs  -Wold-style-definition -Wstrict-prototypes	-Wtradi-
	 tional -Wdeclaration-after-statement -Wpointer-sign

     Debugging Options
	 -dletters    -dumpspecs    -dumpmachine    -dumpversion   -fdump-noaddr
	 -fdump-unnumbered    -fdump-translation-unit[-n]   -fdump-class-hierar-
	 chy[-n]      -fdump-ipa-all	  -fdump-ipa-cgraph	 -fdump-tree-all
	 -fdump-tree-original[-n]   -fdump-tree-optimized[-n]	 -fdump-tree-in-
	 lined[-n]     -fdump-tree-cfg	   -fdump-tree-vcg     -fdump-tree-alias
	 -fdump-tree-ch 	-fdump-tree-ssa[-n]	     -fdump-tree-pre[-n]
	 -fdump-tree-ccp[-n]	 -fdump-tree-dce[-n]	-fdump-tree-gimple[-raw]
	 -fdump-tree-mudflap[-n]     -fdump-tree-dom[-n]     -fdump-tree-dse[-n]
	 -fdump-tree-phiopt[-n]   -fdump-tree-forwprop[-n]   -fdump-tree-copyre-
	 name[-n]     -fdump-tree-nrv	  -fdump-tree-vect	-fdump-tree-sink
	 -fdump-tree-sra[-n]	    -fdump-tree-salias	     -fdump-tree-fre[-n]
	 -fdump-tree-vrp[-n]			     -ftree-vectorizer-verbose=n
	 -fdump-tree-storeccp[-n] -feliminate-dwarf2-dups -feliminate-unused-de-
	 bug-types   -feliminate-unused-debug-symbols  -femit-class-debug-always
	 -fmem-report  -fprofile-arcs	-frandom-seed=string   -fsched-verbose=n
	 -ftest-coverage    -ftime-report  -fvar-tracking  -g	-glevel   -gcoff
	 -gdwarf-2 -ggdb  -gstabs  -gstabs+  -gvms  -gxcoff   -gxcoff+	-p   -pg
	 -print-file-name=library   -print-libgcc-file-name  -print-multi-direc-
	 tory  -print-multi-lib -print-prog-name=program  -print-search-dirs  -Q
	 -save-temps  -time

     Optimization Options
	 -falign-functions=n  -falign-jumps=n -falign-labels=n	 -falign-loops=n
	 -fbounds-check -fmudflap -fmudflapth -fmudflapir -fbranch-probabilities
	 -fprofile-values   -fvpt   -fbranch-target-load-optimize  -fbranch-tar-
	 get-load-optimize2 -fbtr-bb-exclusive -fcaller-saves  -fcprop-registers
	 -fcse-follow-jumps -fcse-skip-blocks	-fcx-limited-range   -fdata-sec-
	 tions	-fdelayed-branch   -fdelete-null-pointer-checks -fearly-inlining
	 -fexpensive-optimizations   -ffast-math    -ffloat-store   -fforce-addr
	 -ffunction-sections	-fgcse	   -fgcse-lm	 -fgcse-sm    -fgcse-las
	 -fgcse-after-reload -fcrossjumping   -fif-conversion	-fif-conversion2
	 -finline-functions    -finline-functions-called-once	-finline-limit=n
	 -fkeep-inline-functions     -fkeep-static-consts      -fmerge-constants
	 -fmerge-all-constants	 -fmodulo-sched  -fno-branch-count-reg	-fno-de-
	 fault-inline  -fno-defer-pop  -fmove-loop-invariants  -fno-function-cse
	 -fno-guess-branch-probability	-fno-inline  -fno-math-errno  -fno-peep-
	 hole  -fno-peephole2  -funsafe-math-optimizations   -funsafe-loop-opti-
	 mizations   -ffinite-math-only -fno-toplevel-reorder -fno-trapping-math
	 -fno-zero-initialized-in-bss  -fomit-frame-pointer    -foptimize-regis-
	 ter-move    -foptimize-sibling-calls	 -fprefetch-loop-arrays   -fpro-
	 file-generate	 -fprofile-use	 -fregmove    -frename-registers   -fre-
	 order-blocks	-freorder-blocks-and-partition -freorder-functions -fre-
	 run-cse-after-loop  -frounding-math  -frtl-abstract-sequences	-fsched-
	 ule-insns    -fschedule-insns2  -fno-sched-interblock	 -fno-sched-spec
	 -fsched-spec-load  -fsched-spec-load-dangerous  -fsched-stalled-insns=n
	 -fsched-stalled-insns-dep=n			-fsched2-use-superblocks
	 -fsched2-use-traces  -fsee  -freschedule-modulo-scheduled-loops  -fsec-
	 tion-anchors	  -fsignaling-nans    -fsingle-precision-constant   -fs-
	 tack-protector  -fstack-protector-all -fstrict-aliasing  -fstrict-over-
	 flow	-ftracer   -fthread-jumps   -funroll-all-loops	  -funroll-loops
	 -fpeel-loops -fsplit-ivs-in-unroller -funswitch-loops -fvariable-expan-
	 sion-in-unroller  -ftree-pre	-ftree-ccp  -ftree-dce -ftree-loop-opti-
	 mize  -ftree-loop-linear  -ftree-loop-im  -ftree-loop-ivcanon	-fivopts
	 -ftree-dominator-opts	  -ftree-dse	-ftree-copyrename    -ftree-sink
	 -ftree-ch -ftree-sra -ftree-ter -ftree-lrs -ftree-fre	-ftree-vectorize
	 -ftree-vect-loop-version -ftree-salias -fipa-pta -fweb -ftree-copy-prop
	 -ftree-store-ccp    -ftree-store-copy-prop    -fwhole-program	 --param
	 name=value -O	-O0  -O1  -O2  -O3  -Os

     Preprocessor Options
	 -Aquestion=answer  -A-question[=answer]  -C	-dD    -dI    -dM    -dN
	 -Dmacro[=defn]   -E   -H  -idirafter  dir  -include file  -imacros file
	 -iprefix file	-iwithprefix dir -iwithprefixbefore  dir   -isystem  dir
	 -imultilib  dir -isysroot dir -M  -MM	-MF  -MG  -MP  -MQ  -MT  -nostd-
	 inc  -P   -fworking-directory	 -remap  -trigraphs    -undef	 -Umacro
	 -Wp,option -Xpreprocessor option

     Assembler Option
	 -Wa,option  -Xassembler option

     Linker Options
	 object-file-name   -llibrary  -nostartfiles   -nodefaultlibs  -nostdlib
	 -pie -rdynamic -s   -static   -static-libgcc	-shared   -shared-libgcc
	 -symbolic -Wl,option  -Xlinker option -u symbol

     Directory Options
	 -Bprefix  -Idir  -iquotedir  -Ldir -specs=file  -I- --sysroot=dir

     Target Options
	 -V version  -b machine

     Machine Dependent Options
	 ARC  Options  -EB   -EL  -mmangle-cpu	 -mcpu=cpu   -mtext=text-section
	 -mdata=data-section  -mrodata=readonly-data-section

	 ARM Options -mapcs-frame  -mno-apcs-frame -mabi=name -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	-mfloat-abi=name    -msoft-float
	 -mhard-float	-mfpe -mthumb-interwork  -mno-thumb-interwork -mcpu=name
	 -march=name  -mfpu=name -mstructure-size-boundary=n -mabort-on-noreturn
	 -mlong-calls  -mno-long-calls	-msingle-pic-base   -mno-single-pic-base
	 -mpic-register=reg    -mnop-fun-dllimport    -mcirrus-fix-invalid-insns
	 -mno-cirrus-fix-invalid-insns -mpoke-function-name -mthumb  -marm  -mt-
	 pcs-frame   -mtpcs-leaf-frame -mcaller-super-interworking  -mcallee-su-
	 per-interworking -mtp=name

	 AVR  Options	-mmcu=mcu    -msize    -minit-stack=n	 -mno-interrupts
	 -mcall-prologues  -mno-tablejump  -mtiny-stack  -mint8

	 Blackfin Options -momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer
	 -mspecld-anomaly -mno-specld-anomaly -mcsync-anomaly -mno-csync-anomaly
	 -mlow-64k    -mno-low64k   -mid-shared-library   -mno-id-shared-library
	 -mshared-library-id=n -mlong-calls  -mno-long-calls

	 CRIS  Options	-mcpu=cpu   -march=cpu	 -mtune=cpu  -mmax-stack-frame=n
	 -melinux-stacksize=n	 -metrax4    -metrax100    -mpdebug    -mcc-init
	 -mno-side-effects -mstack-align  -mdata-align	 -mconst-align	-m32-bit
	 -m16-bit   -m8-bit   -mno-prologue-epilogue   -mno-gotplt -melf  -maout
	 -melinux	-mlinux       -sim	 -sim2	    -mmul-bug-workaround
	 -mno-mul-bug-workaround

	 CRX Options -mmac -mpush-args

	 Darwin  Options -all_load  -allowable_client  -arch  -arch_errors_fatal
	 -arch_only  -bind_at_load  -bundle  -bundle_loader -client_name   -com-
	 patibility_version    -current_version   -dead_strip	-dependency-file
	 -dylib_file	-dylinker_install_name	 -dynamic    -dynamiclib    -ex-
	 ported_symbols_list  -filelist   -flat_namespace  -force_cpusubtype_ALL
	 -force_flat_namespace	-headerpad_max_install_names -image_base   -init
	 -install_name	 -keep_private_externs	-multi_module  -multiply_defined
	 -multiply_defined_unused  -noall_load	  -no_dead_strip_inits_and_terms
	 -nofixprebinding      -nomultidefs	  -noprebind	  -noseglinkedit
	 -pagezero_size  -prebind  -prebind_all_twolevel_modules -private_bundle
	 -read_only_relocs  -sectalign -sectobjectsymbols   -whyload   -seg1addr
	 -sectcreate	     -sectobjectsymbols        -sectorder	-segaddr
	 -segs_read_only_addr	    -segs_read_write_addr	 -seg_addr_table
	 -seg_addr_table_filename   -seglinkedit  -segprot  -segs_read_only_addr
	 -segs_read_write_addr -single_module  -static	 -sub_library	-sub_um-
	 brella   -twolevel_namespace	-umbrella   -undefined	-unexported_sym-
	 bols_list  -weak_reference_mismatches	-whatsloaded  -F  -gused  -gfull
	 -mmacosx-version-min=version -mkernel -mone-byte-bool

	 DEC  Alpha Options -mno-fp-regs  -msoft-float	-malpha-as  -mgas -mieee
	 -mieee-with-inexact  -mieee-conformant -mfp-trap-mode=mode  -mfp-round-
	 ing-mode=mode -mtrap-precision=mode   -mbuild-constants  -mcpu=cpu-type
	 -mtune=cpu-type  -mbwx   -mmax   -mfix  -mcix -mfloat-vax  -mfloat-ieee
	 -mexplicit-relocs	-msmall-data	  -mlarge-data	    -msmall-text
	 -mlarge-text -mmemory-latency=time

	 DEC Alpha/VMS Options -mvms-return-codes

	 FRV   Options	 -mgpr-32   -mgpr-64   -mfpr-32   -mfpr-64  -mhard-float
	 -msoft-float  -malloc-cc   -mfixed-cc	 -mdword   -mno-dword	-mdouble
	 -mno-double  -mmedia	-mno-media  -mmuladd  -mno-muladd -mfdpic  -min-
	 line-plt -mgprel-ro   -multilib-library-pic  -mlinked-fp   -mlong-calls
	 -malign-labels   -mlibrary-pic    -macc-4   -macc-8  -mpack   -mno-pack
	 -mno-eflags  -mcond-move  -mno-cond-move  -moptimize-membar  -mno-opti-
	 mize-membar  -mscc  -mno-scc  -mcond-exec  -mno-cond-exec -mvliw-branch
	 -mno-vliw-branch	 -mmulti-cond-exec	    -mno-multi-cond-exec
	 -mnested-cond-exec  -mno-nested-cond-exec   -mtomcat-stats  -mTLS -mtls
	 -mcpu=cpu

	 GNU/Linux Options -muclibc

	 H8/300 Options -mrelax  -mh  -ms  -mn	-mint32  -malign-300

	 HPPA Options  -march=architecture-type  -mbig-switch	-mdisable-fpregs
	 -mdisable-indexing  -mfast-indirect-calls   -mgas   -mgnu-ld	 -mhp-ld
	 -mfixed-range=register-range -mjump-in-delay -mlinker-opt  -mlong-calls
	 -mlong-load-store    -mno-big-switch	 -mno-disable-fpregs   -mno-dis-
	 able-indexing	 -mno-fast-indirect-calls   -mno-gas  -mno-jump-in-delay
	 -mno-long-load-store	    -mno-portable-runtime	 -mno-soft-float
	 -mno-space-regs      -msoft-float	-mpa-risc-1-0	   -mpa-risc-1-1
	 -mpa-risc-2-0	  -mportable-runtime  -mschedule=cpu-type   -mspace-regs
	 -msio	-mwsio -munix=unix-std	-nolibdld  -static  -threads

	 i386 and x86-64 Options -mtune=cpu-type  -march=cpu-type  -mfpmath=unit
	 -masm=dialect	  -mno-fancy-math-387  -mno-fp-ret-in-387   -msoft-float
	 -msvr3-shlib	-mno-wide-multiply    -mrtd	-malign-double	  -mpre-
	 ferred-stack-boundary=num  -mmmx   -msse  -msse2 -msse3 -mssse3 -m3dnow
	 -mthreads   -mno-align-stringops   -minline-all-stringops   -mpush-args
	 -maccumulate-outgoing-args    -m128bit-long-double  -m96bit-long-double
	 -mregparm=num	 -msseregparm  -mstackrealign  -momit-leaf-frame-pointer
	 -mno-red-zone	-mno-tls-direct-seg-refs  -mcmodel=code-model -m32  -m64
	 -mlarge-data-threshold=num

	 IA-64	Options  -mbig-endian	 -mlittle-endian    -mgnu-as	-mgnu-ld
	 -mno-pic   -mvolatile-asm-stop    -mregister-names   -mno-sdata  -mcon-
	 stant-gp     -mauto-pic     -minline-float-divide-min-latency	   -min-
	 line-float-divide-max-throughput  -minline-int-divide-min-latency -min-
	 line-int-divide-max-throughput     -minline-sqrt-min-latency	   -min-
	 line-sqrt-max-throughput	 -mno-dwarf2-asm       -mearly-stop-bits
	 -mfixed-range=register-range  -mtls-size=tls-size  -mtune=cpu-type  -mt
	 -pthread  -milp32  -mlp64  -mno-sched-br-data-spec -msched-ar-data-spec
	 -mno-sched-control-spec -msched-br-in-data-spec -msched-ar-in-data-spec
	 -msched-in-control-spec       -msched-ldc	  -mno-sched-control-ldc
	 -mno-sched-spec-verbose	   -mno-sched-prefer-non-data-spec-insns
	 -mno-sched-prefer-non-control-spec-insns -mno-sched-count-spec-in-crit-
	 ical-path

	 M32R/D   Options   -m32r2   -m32rx    -m32r	-mdebug    -malign-loops
	 -mno-align-loops -missue-rate=number -mbranch-cost=number -mmodel=code-
	 size-model-type  -msdata=sdata-type  -mno-flush-func  -mflush-func=name
	 -mno-flush-trap -mflush-trap=number -G num

	 M32C Options -mcpu=cpu -msim -memregs=number

	 M680x0  Options  -m68000   -m68020   -m68020-40   -m68020-60	 -m68030
	 -m68040  -m68060  -mcpu32  -m5200  -mcfv4e -m68881  -mbitfield -mc68000
	 -mc68020  -mnobitfield   -mrtd   -mshort   -msoft-float   -mpcrel  -ma-
	 lign-int    -mstrict-align    -msep-data    -mno-sep-data  -mshared-li-
	 brary-id=n  -mid-shared-library  -mno-id-shared-library

	 M68hc1x  Options  -m6811   -m6812    -m68hc11	  -m68hc12     -m68hcs12
	 -mauto-incdec	-minmax  -mlong-calls  -mshort -msoft-reg-count=count

	 MCore Options -mhardlit  -mno-hardlit	-mdiv  -mno-div  -mrelax-immedi-
	 ates	-mno-relax-immediates	 -mwide-bitfields    -mno-wide-bitfields
	 -m4byte-functions   -mno-4byte-functions   -mcallgraph-data  -mno-call-
	 graph-data   -mslow-bytes   -mno-slow-bytes   -mno-lsim -mlittle-endian
	 -mbig-endian  -m210  -m340  -mstack-increment

	 MIPS Options -EL  -EB	-march=arch  -mtune=arch -mips1  -mips2   -mips3
	 -mips4   -mips32   -mips32r2	-mips64  -mips16  -mno-mips16  -mabi=abi
	 -mabicalls   -mno-abicalls  -mshared	-mno-shared   -mxgot   -mno-xgot
	 -mgp32    -mgp64  -mfp32   -mfp64   -mhard-float   -msoft-float  -msin-
	 gle-float  -mdouble-float   -mdsp   -mpaired-single   -mips3d	-mlong64
	 -mlong32    -msym32   -mno-sym32  -Gnum   -membedded-data   -mno-embed-
	 ded-data     -muninit-const-in-rodata	     -mno-uninit-const-in-rodata
	 -msplit-addresses    -mno-split-addresses  -mexplicit-relocs	-mno-ex-
	 plicit-relocs	-mcheck-zero-division	-mno-check-zero-division   -mdi-
	 vide-traps    -mdivide-breaks	 -mmemcpy    -mno-memcpy    -mlong-calls
	 -mno-long-calls -mmad	-mno-mad  -mfused-madd	-mno-fused-madd   -nocpp
	 -mfix-r4000   -mno-fix-r4000	-mfix-r4400  -mno-fix-r4400 -mfix-vr4120
	 -mno-fix-vr4120  -mfix-vr4130 -mfix-sb1  -mno-fix-sb1 -mflush-func=func
	 -mno-flush-func  -mbranch-likely   -mno-branch-likely	 -mfp-exceptions
	 -mno-fp-exceptions -mvr4130-align -mno-vr4130-align

	 MMIX	Options   -mlibfuncs	-mno-libfuncs	-mepsilon   -mno-epsilon
	 -mabi=gnu -mabi=mmixware  -mzero-extend  -mknuthdiv  -mtoplevel-symbols
	 -melf	   -mbranch-predict	-mno-branch-predict	-mbase-addresses
	 -mno-base-addresses  -msingle-exit  -mno-single-exit

	 MN10300  Options  -mmult-bug	-mno-mult-bug -mam33  -mno-am33 -mam33-2
	 -mno-am33-2 -mreturn-pointer-on-d0 -mno-crt0  -mrelax

	 MT Options -mno-crt0 -mbacc -msim -march=cpu-type

	 PDP-11 Options -mfpu  -msoft-float  -mac0  -mno-ac0  -m40   -m45   -m10
	 -mbcopy    -mbcopy-builtin   -mint32	-mno-int16  -mint16   -mno-int32
	 -mfloat32  -mno-float64 -mfloat64   -mno-float32   -mabshi   -mno-abshi
	 -mbranch-expensive    -mbranch-cheap  -msplit	 -mno-split   -munix-asm
	 -mdec-asm

	 PowerPC Options See RS/6000 and PowerPC Options.

	 RS/6000 and  PowerPC  Options	-mcpu=cpu-type	-mtune=cpu-type  -mpower
	 -mno-power   -mpower2	-mno-power2 -mpowerpc  -mpowerpc64  -mno-powerpc
	 -maltivec   -mno-altivec  -mpowerpc-gpopt   -mno-powerpc-gpopt   -mpow-
	 erpc-gfxopt	-mno-powerpc-gfxopt   -mmfcrf	 -mno-mfcrf    -mpopcntb
	 -mno-popcntb	-mfprnd   -mno-fprnd  -mnew-mnemonics	 -mold-mnemonics
	 -mfull-toc    -mminimal-toc  -mno-fp-in-toc  -mno-sum-in-toc -m64  -m32
	 -mxl-compat   -mno-xl-compat	 -mpe	-malign-power	 -malign-natural
	 -msoft-float	  -mhard-float	  -mmultiple	-mno-multiple	-mstring
	 -mno-string   -mupdate    -mno-update	 -mfused-madd	 -mno-fused-madd
	 -mbit-align   -mno-bit-align -mstrict-align  -mno-strict-align  -mrelo-
	 catable -mno-relocatable  -mrelocatable-lib  -mno-relocatable-lib -mtoc
	 -mno-toc   -mlittle	-mlittle-endian    -mbig    -mbig-endian   -mdy-
	 namic-no-pic  -maltivec  -mswdiv -mprioritize-restricted-insns=priority
	 -msched-costly-dep=dependence_type	      -minsert-sched-nops=scheme
	 -mcall-sysv   -mcall-netbsd  -maix-struct-return   -msvr4-struct-return
	 -mabi=abi-type   -msecure-plt	-mbss-plt  -misel  -mno-isel  -misel=yes
	 -misel=no  -mspe  -mno-spe  -mspe=yes	 -mspe=no  -mvrsave  -mno-vrsave
	 -mmulhw -mno-mulhw -mdlmzb -mno-dlmzb -mfloat-gprs=yes  -mfloat-gprs=no
	 -mfloat-gprs=single   -mfloat-gprs=double  -mprototype   -mno-prototype
	 -msim	-mmvme	-mads  -myellowknife  -memb  -msdata -msdata=opt   -mvx-
	 works	-mwindiss  -G num  -pthread

	 S/390 and zSeries Options -mtune=cpu-type  -march=cpu-type -mhard-float
	 -msoft-float	  -mlong-double-64     -mlong-double-128     -mbackchain
	 -mno-backchain    -mpacked-stack     -mno-packed-stack     -msmall-exec
	 -mno-small-exec   -mmvcle  -mno-mvcle	-m64   -m31  -mdebug  -mno-debug
	 -mesa	    -mzarch	-mtpf-trace	-mno-tpf-trace	    -mfused-madd
	 -mno-fused-madd   -mwarn-framesize   -mwarn-dynamicstack   -mstack-size
	 -mstack-guard

	 Score Options	-meb  -mel  -mnhwloop  -muls  -mmac  -mscore5  -mscore5u
	 -mscore7 -mscore7d

	 SH  Options  -m1   -m2   -m2e	 -m3   -m3e  -m4-nofpu	 -m4-single-only
	 -m4-single  -m4  -m4a-nofpu  -m4a-single-only	-m4a-single  -m4a  -m4al
	 -m5-64media   -m5-64media-nofpu -m5-32media  -m5-32media-nofpu -m5-com-
	 pact  -m5-compact-nofpu -mb  -ml  -mdalign  -mrelax -mbigtable  -mfmovd
	 -mhitachi -mrenesas -mno-renesas -mnomacsave  -mieee	-misize   -mpad-
	 struct  -mspace -mprefergot  -musermode -multcost=number -mdiv=strategy
	 -mdivsi3_libfunc=name	 -madjust-unroll  -mindexed-addressing	-mgettr-
	 cost=number -mpt-fixed
	  -minvalid-symbols

	 SPARC Options -mcpu=cpu-type -mtune=cpu-type  -mcmodel=code-model  -m32
	 -m64	-mapp-regs   -mno-app-regs -mfaster-structs  -mno-faster-structs
	 -mfpu	  -mno-fpu    -mhard-float     -msoft-float    -mhard-quad-float
	 -msoft-quad-float   -mimpure-text    -mno-impure-text	 -mlittle-endian
	 -mstack-bias  -mno-stack-bias -munaligned-doubles   -mno-unaligned-dou-
	 bles -mv8plus	-mno-v8plus  -mvis  -mno-vis -threads -pthreads -pthread

	 System V Options -Qy  -Qn  -YP,paths  -Ym,dir

	 TMS320C3x/C4x	Options  -mcpu=cpu  -mbig  -msmall  -mregparm  -mmemparm
	 -mfast-fix  -mmpyi  -mbk  -mti   -mdp-isr-reload  -mrpts=count   -mrptb
	 -mdb	  -mloop-unsigned   -mparallel-insns	-mparallel-mpy	  -mpre-
	 serve-float

	 V850  Options	-mlong-calls   -mno-long-calls	 -mep	-mno-ep   -mpro-
	 log-function	-mno-prolog-function   -mspace -mtda=n	-msda=n  -mzda=n
	 -mapp-regs  -mno-app-regs -mdisable-callt  -mno-disable-callt	-mv850e1
	 -mv850e -mv850  -mbig-switch

	 VAX Options -mg  -mgnu  -munix

	 x86-64 Options See i386 and x86-64 Options.

	 Xstormy16 Options -msim

	 Xtensa  Options  -mconst16  -mno-const16  -mfused-madd  -mno-fused-madd
	 -mtext-section-literals    -mno-text-section-literals	  -mtarget-align
	 -mno-target-align -mlongcalls	-mno-longcalls

	 zSeries Options See S/390 and zSeries Options.

     Code Generation Options
	 -fcall-saved-reg      -fcall-used-reg	   -ffixed-reg	    -fexceptions
	 -fnon-call-exceptions	  -funwind-tables   -fasynchronous-unwind-tables
	 -finhibit-size-directive	 -finstrument-functions      -fno-common
	 -fno-ident -fpcc-struct-return  -fpic	-fPIC -fpie -fPIE  -fno-jump-ta-
	 bles  -freg-struct-return   -fshort-enums -fshort-double  -fshort-wchar
	 -fverbose-asm	 -fpack-struct[=n]   -fstack-check  -fstack-limit-regis-
	 ter=reg   -fstack-limit-symbol=sym -fargument-alias  -fargument-noalias
	 -fargument-noalias-global  -fargument-noalias-anything -fleading-under-
	 score	-ftls-model=model -ftrapv  -fwrapv  -fbounds-check -fvisibility

     Options Controlling the Kind of Output

     Compilation can involve  up  to  four  stages:  preprocessing,  compilation
     proper, assembly and linking, always in that order.  GCC is capable of pre-
     processing  and compiling several files either into several assembler input
     files, or into one assembler input file; then  each  assembler  input  file
     produces  an  object file, and linking combines all the object files (those
     newly compiled, and those specified as input) into an executable file.

     For any given input file, the file name suffix determines what kind of com-
     pilation is done:

     file.c
	 C source code which must be preprocessed.

     file.i
	 C source code which should not be preprocessed.

     file.ii
	 C++ source code which should not be preprocessed.

     file.h
	 C, or C++ header file to be turned into a precompiled header.

     file.cc
     file.cp
     file.cxx
     file.cpp
     file.CPP
     file.c++
     file.C
	 C++ source code which must be preprocessed.  Note  that  in  .cxx,  the
	 last  two  letters  must both be literally x.	Likewise, .C refers to a
	 literal capital C.

     file.hh
     file.H
	 C++ header file to be turned into a precompiled header.

     file.f
     file.for
     file.FOR
	 Fixed form Fortran source code which should not be preprocessed.

     file.F
     file.fpp
     file.FPP
	 Fixed form Fortran source code which must  be	preprocessed  (with  the
	 traditional preprocessor).

     file.f90
     file.f95
	 Free form Fortran source code which should not be preprocessed.

     file.F90
     file.F95
	 Free form Fortran source code which must be preprocessed (with the tra-
	 ditional preprocessor).

     file.ads
	 Ada  source code file which contains a library unit declaration (a dec-
	 laration of a package, subprogram, or generic, or a generic  instantia-
	 tion),  or  a library unit renaming declaration (a package, generic, or
	 subprogram renaming declaration).  Such files are also called specs.

     file.adb
	 Ada source code file containing a library unit body  (a  subprogram  or
	 package body).  Such files are also called bodies.

     file.s
	 Assembler code.

     file.S
	 Assembler code which must be preprocessed.

     other
	 An  object file to be fed straight into linking.  Any file name with no
	 recognized suffix is treated this way.

     You can specify the input language explicitly with the -x option:

     -x language
	 Specify explicitly the language for the following input  files  (rather
	 than  letting the compiler choose a default based on the file name suf-
	 fix).	This option applies to all following input files until the  next
	 -x option.  Possible values for language are:

		 c  c-header  c-cpp-output
		 c++  c++-header  c++-cpp-output
		 assembler  assembler-with-cpp
		 ada
		 f95  f95-cpp-input
		 java
		 treelang

     -x none
	 Turn  off any specification of a language, so that subsequent files are
	 handled according to their file name suffixes (as they are  if  -x  has
	 not been used at all).

     -pass-exit-codes
	 Normally  the	gcc program will exit with the code of 1 if any phase of
	 the compiler  returns	a  non-success	return	code.	If  you  specify
	 -pass-exit-codes,  the gcc program will instead return with numerically
	 highest error produced by any phase that returned an error  indication.
	 The C, C++, and Fortran frontends return 4, if an internal compiler er-
	 ror is encountered.

     If  you  only  want  some	of the stages of compilation, you can use -x (or
     filename suffixes) to tell gcc where to start, and one of the  options  -c,
     -S,  or  -E  to say where gcc is to stop.	Note that some combinations (for
     example, -x cpp-output -E) instruct gcc to do nothing at all.

     -c  Compile or assemble the source files, but do  not  link.   The  linking
	 stage simply is not done.  The ultimate output is in the form of an ob-
	 ject file for each source file.

	 By default, the object file name for a source file is made by replacing
	 the suffix .c, .i, .s, etc., with .o.

	 Unrecognized  input  files,  not requiring compilation or assembly, are
	 ignored.

     -S  Stop after the stage of compilation proper; do not assemble.  The  out-
	 put is in the form of an assembler code file for each non-assembler in-
	 put file specified.

	 By  default,  the  assembler file name for a source file is made by re-
	 placing the suffix .c, .i, etc., with .s.

	 Input files that don't require compilation are ignored.

     -E  Stop after the preprocessing stage; do not  run  the  compiler  proper.
	 The output is in the form of preprocessed source code, which is sent to
	 the standard output.

	 Input files which don't require preprocessing are ignored.

     -o file
	 Place output in file file.  This applies regardless to whatever sort of
	 output  is  being produced, whether it be an executable file, an object
	 file, an assembler file or preprocessed C code.

	 If -o is not specified, the default is to put	an  executable	file  in
	 a.out,  the  object  file  for source.suffix in source.o, its assembler
	 file in source.s, a precompiled header file in  source.suffix.gch,  and
	 all preprocessed C source on standard output.

     -v  Print	(on  standard  error  output)  the  commands executed to run the
	 stages of compilation.  Also print the version number of  the	compiler
	 driver program and of the preprocessor and the compiler proper.

     -###Like  -v except the commands are not executed and all command arguments
	 are quoted.  This is useful for shell scripts to  capture  the  driver-
	 generated command lines.

     -pipe
	 Use  pipes  rather  than  temporary files for communication between the
	 various stages of compilation.  This fails  to  work  on  some  systems
	 where	the  assembler is unable to read from a pipe; but the GNU assem-
	 bler has no trouble.

     -combine
	 If you are compiling multiple source files, this option tells the  dri-
	 ver  to  pass	all  the source files to the compiler at once (for those
	 languages for which the compiler can handle this).  This will allow in-
	 termodule analysis (IMA) to be performed by  the  compiler.   Currently
	 the only language for which this is supported is C.  If you pass source
	 files for multiple languages to the driver, using this option, the dri-
	 ver  will  invoke  the  compiler(s) that support IMA once each, passing
	 each compiler all the source files appropriate for it.  For those  lan-
	 guages  that  do  not	support IMA this option will be ignored, and the
	 compiler will be invoked once for each source file  in  that  language.
	 If  you  use  this option in conjunction with -save-temps, the compiler
	 will generate multiple pre-processed files (one for each source  file),
	 but only one (combined) .o or .s file.

     --help
	 Print	(on  the  standard output) a description of the command line op-
	 tions understood by gcc.  If the  -v  option  is  also  specified  then
	 --help  will also be passed on to the various processes invoked by gcc,
	 so that they can display the command line options they accept.  If  the
	 -Wextra  option  is also specified then command line options which have
	 no documentation associated with them will also be displayed.

     --target-help
	 Print (on the standard output) a description of target specific command
	 line options for each tool.

     --version
	 Display the version number and copyrights of the invoked GCC.

     @file
	 Read command-line options from file.  The options read are inserted  in
	 place	of the original @file option.  If file does not exist, or cannot
	 be read, then the option will be treated literally, and not removed.

	 Options in file are separated by whitespace.	A  whitespace  character
	 may be included in an option by surrounding the entire option in either
	 single  or double quotes.  Any character (including a backslash) may be
	 included by prefixing the character to be included  with  a  backslash.
	 The  file may itself contain additional @file options; any such options
	 will be processed recursively.

     Compiling C++ Programs

     C++ source files conventionally use one of  the  suffixes	.C,  .cc,  .cpp,
     .CPP,  .c++,  .cp,  or .cxx; C++ header files often use .hh or .H; and pre-
     processed C++ files use the suffix .ii.  GCC recognizes  files  with  these
     names  and  compiles them as C++ programs even if you call the compiler the
     same way as for compiling C programs (usually with the name gcc).

     However, the use of gcc does not add the C++ library.   g++  is  a  program
     that  calls  GCC and treats .c, .h and .i files as C++ source files instead
     of C source files unless -x is used, and  automatically  specifies  linking
     against the C++ library.  This program is also useful when precompiling a C
     header  file with a .h extension for use in C++ compilations.  On many sys-
     tems, g++ is also installed with the name c++.

     When you compile C++ programs, you may specify many of  the  same	command-
     line  options  that you use for compiling programs in any language; or com-
     mand-line options meaningful for C and related languages; or  options  that
     are meaningful only for C++ programs.

     Options Controlling C Dialect

     The  following  options control the dialect of C (or languages derived from
     C, such as C++) that the compiler accepts:

     -ansi
	 In C mode, support all ISO C90 programs.  In C++ mode, remove	GNU  ex-
	 tensions that conflict with ISO C++.

	 This  turns  off certain features of GCC that are incompatible with ISO
	 C90 (when compiling C code), or of standard  C++  (when  compiling  C++
	 code),  such  as the "asm" and "typeof" keywords, and predefined macros
	 such as "unix" and "vax" that identify the type of system you	are  us-
	 ing.  It also enables the undesirable and rarely used ISO trigraph fea-
	 ture.	For the C compiler, it disables recognition of C++ style // com-
	 ments as well as the "inline" keyword.

	 The  alternate  keywords  "__asm__",  "__extension__", "__inline__" and
	 "__typeof__" continue to work despite -ansi.  You would not want to use
	 them in an ISO C program, of course, but it is useful to  put	them  in
	 header  files	that  might be included in compilations done with -ansi.
	 Alternate predefined macros such as "__unix__" and "__vax__"  are  also
	 available, with or without -ansi.

	 The  -ansi option does not cause non-ISO programs to be rejected gratu-
	 itously.  For that, -pedantic is required in addition to -ansi.

	 The macro "__STRICT_ANSI__" is predefined  when  the  -ansi  option  is
	 used.	Some header files may notice this macro and refrain from declar-
	 ing  certain functions or defining certain macros that the ISO standard
	 doesn't call for; this is to avoid interfering with any  programs  that
	 might use these names for other things.

	 Functions  which  would  normally be built in but do not have semantics
	 defined by ISO C (such as "alloca" and "ffs") are  not  built-in  func-
	 tions with -ansi is used.

     -std=
	 Determine  the  language  standard.  This option is currently only sup-
	 ported when compiling C or C++.  A value for this option must	be  pro-
	 vided; possible values are

	 c89
	 iso9899:1990
	     ISO C90 (same as -ansi).

	 iso9899:199409
	     ISO C90 as modified in amendment 1.

	 c99
	 c9x
	 iso9899:1999
	 iso9899:199x
	     ISO  C99.	 Note that this standard is not yet fully supported; see
	     <http://gcc.gnu.org/gcc-4.2/c99status.html> for  more  information.
	     The names c9x and iso9899:199x are deprecated.

	 gnu89
	     Default, ISO C90 plus GNU extensions (including some C99 features).

	 gnu99
	 gnu9x
	     ISO  C99 plus GNU extensions.  When ISO C99 is fully implemented in
	     GCC, this will become the default.  The name gnu9x is deprecated.

	 c++98
	     The 1998 ISO C++ standard plus amendments.

	 gnu++98
	     The same as -std=c++98 plus GNU extensions.  This	is  the  default
	     for C++ code.

	 Even  when  this option is not specified, you can still use some of the
	 features of newer standards in so far as they do not conflict with pre-
	 vious C standards.  For example, you may use "__restrict__"  even  when
	 -std=c99 is not specified.

	 The -std options specifying some version of ISO C have the same effects
	 as  -ansi, except that features that were not in ISO C90 but are in the
	 specified version (for example, // comments and the "inline" keyword in
	 ISO C99) are not disabled.

     -fgnu89-inline
	 The option -fgnu89-inline tells GCC to use the traditional  GNU  seman-
	 tics for "inline" functions when in C99 mode.
	   Using  this	option	is roughly equivalent to adding the "gnu_inline"
	 function attribute to all inline functions.

	 This option is accepted by GCC versions 4.1.3 and up.	In GCC	versions
	 prior to 4.3, C99 inline semantics are not supported, and thus this op-
	 tion  is effectively assumed to be present regardless of whether or not
	 it is specified; the only effect of specifying it explicitly is to dis-
	 able warnings about using inline functions in C99 mode.  Likewise,  the
	 option  -fno-gnu89-inline  is	not  supported in versions of GCC before
	 4.3.  It will be supported only in C99 or gnu99 mode,	not  in  C89  or
	 gnu89 mode.

	 The preprocesor macros "__GNUC_GNU_INLINE__" and "__GNUC_STDC_INLINE__"
	 may  be  used to check which semantics are in effect for "inline" func-
	 tions.

     -aux-info filename
	 Output to the given filename prototyped declarations for all  functions
	 declared  and/or  defined  in	a  translation	unit, including those in
	 header files.	This option is silently ignored in  any  language  other
	 than C.

	 Besides  declarations,  the  file indicates, in comments, the origin of
	 each declaration (source file and line), whether  the	declaration  was
	 implicit,  prototyped	or  unprototyped (I, N for new or O for old, re-
	 spectively, in the first  character  after  the  line	number	and  the
	 colon), and whether it came from a declaration or a definition (C or F,
	 respectively, in the following character).  In the case of function de-
	 finitions, a K&R-style list of arguments followed by their declarations
	 is also provided, inside comments, after the declaration.

     -fno-asm
	 Do not recognize "asm", "inline" or "typeof" as a keyword, so that code
	 can  use  these  words  as  identifiers.   You  can  use  the	keywords
	 "__asm__",  "__inline__"  and	"__typeof__"  instead.	 -ansi	 implies
	 -fno-asm.

	 In  C++, this switch only affects the "typeof" keyword, since "asm" and
	 "inline" are standard keywords.  You may want to use the  -fno-gnu-key-
	 words	flag  instead, which has the same effect.  In C99 mode (-std=c99
	 or -std=gnu99), this switch only affects the "asm"  and  "typeof"  key-
	 words, since "inline" is a standard keyword in ISO C99.

     -fno-builtin
     -fno-builtin-function
	 Don't recognize built-in functions that do not begin with __builtin_ as
	 prefix.

	 GCC  normally	generates  special code to handle certain built-in func-
	 tions more efficiently; for instance, calls to "alloca" may become sin-
	 gle instructions that adjust the stack directly, and calls to	"memcpy"
	 may become inline copy loops.	The resulting code is often both smaller
	 and  faster, but since the function calls no longer appear as such, you
	 cannot set a breakpoint on those calls, nor can you change the behavior
	 of the functions by linking with a  different	library.   In  addition,
	 when  a  function is recognized as a built-in function, GCC may use in-
	 formation about that function to warn about problems with calls to that
	 function, or to generate more efficient code,	even  if  the  resulting
	 code  still contains calls to that function.  For example, warnings are
	 given with -Wformat for bad calls to "printf", when "printf"  is  built
	 in, and "strlen" is known not to modify global memory.

	 With  the -fno-builtin-function option only the built-in function func-
	 tion is disabled.  function must not begin with __builtin_.  If a func-
	 tion is named this is not built-in in this version of GCC, this  option
	 is  ignored.	There  is no corresponding -fbuiltin-function option; if
	 you  wish  to	enable	built-in  functions   selectively   when   using
	 -fno-builtin or -ffreestanding, you may define macros such as:

		 #define abs(n) 	 __builtin_abs ((n))
		 #define strcpy(d, s)	 __builtin_strcpy ((d), (s))

     -fhosted
	 Assert  that compilation takes place in a hosted environment.	This im-
	 plies -fbuiltin.  A hosted environment is one in which the entire stan-
	 dard library is available, and in which "main" has  a	return	type  of
	 "int".  Examples are nearly everything except a kernel.  This is equiv-
	 alent to -fno-freestanding.

     -ffreestanding
	 Assert  that  compilation  takes  place  in a freestanding environment.
	 This implies -fno-builtin.  A freestanding environment is one in  which
	 the  standard library may not exist, and program startup may not neces-
	 sarily be at "main".  The most obvious example is an OS  kernel.   This
	 is equivalent to -fno-hosted.

     -fopenmp
	 Enable handling of OpenMP directives "#pragma omp" in C/C++ and "!$omp"
	 in  Fortran.  When -fopenmp is specified, the compiler generates paral-
	 lel code according to the OpenMP  Application	Program  Interface  v2.5
	 <http://www.openmp.org/>.

     -fms-extensions
	 Accept some non-standard constructs used in Microsoft header files.

	 Some cases of unnamed fields in structures and unions are only accepted
	 with this option.

     -trigraphs
	 Support ISO C trigraphs.  The -ansi option (and -std options for strict
	 ISO C conformance) implies -trigraphs.

     -no-integrated-cpp
	 Performs  a  compilation  in  two  passes: preprocessing and compiling.
	 This option allows a user supplied "cc1", "cc1plus",  or  "cc1obj"  via
	 the  -B  option.  The user supplied compilation step can then add in an
	 additional preprocessing step after  normal  preprocessing  but  before
	 compiling.  The default is to use the integrated cpp (internal cpp)

	 The  semantics  of  this  option  will  change if "cc1", "cc1plus", and
	 "cc1obj" are merged.

     -traditional
     -traditional-cpp
	 Formerly, these options caused GCC to attempt to emulate a pre-standard
	 C compiler.  They are now only supported with the -E switch.  The  pre-
	 processor  continues  to  support a pre-standard mode.  See the GNU CPP
	 manual for details.

     -fcond-mismatch
	 Allow conditional expressions with mismatched types in the  second  and
	 third arguments.  The value of such an expression is void.  This option
	 is not supported for C++.

     -funsigned-char
	 Let the type "char" be unsigned, like "unsigned char".

	 Each  kind  of  machine has a default for what "char" should be.  It is
	 either like "unsigned char" by default or like  "signed  char"  by  de-
	 fault.

	 Ideally,  a  portable	program  should always use "signed char" or "un-
	 signed char" when it depends on the signedness of an object.  But  many
	 programs  have  been  written	to  use plain "char" and expect it to be
	 signed, or expect it to be unsigned, depending  on  the  machines  they
	 were  written	for.   This option, and its inverse, let you make such a
	 program work with the opposite default.

	 The type "char" is always a distinct type from each of "signed char" or
	 "unsigned char", even though its behavior is always just  like  one  of
	 those two.

     -fsigned-char
	 Let the type "char" be signed, like "signed char".

	 Note  that this is equivalent to -fno-unsigned-char, which is the nega-
	 tive form of -funsigned-char.	Likewise, the option -fno-signed-char is
	 equivalent to -funsigned-char.

     -fsigned-bitfields
     -funsigned-bitfields
     -fno-signed-bitfields
     -fno-unsigned-bitfields
	 These options control whether a bit-field is signed or  unsigned,  when
	 the  declaration  does  not  use either "signed" or "unsigned".  By de-
	 fault, such a bit-field is signed, because this is consistent: the  ba-
	 sic integer types such as "int" are signed types.

     Options Controlling C++ Dialect

     This  section  describes  the command-line options that are only meaningful
     for C++ programs; but you can also use most of the GNU compiler options re-
     gardless of what language your program is in.  For example, you might  com-
     pile a file "firstClass.C" like this:

	     g++ -g -frepo -O -c firstClass.C

     In  this example, only -frepo is an option meant only for C++ programs; you
     can use the other options with any language supported by GCC.

     Here is a list of options that are only for compiling C++ programs:

     -fabi-version=n
	 Use version n of the C++ ABI.	Version 2 is the version of the C++  ABI
	 that  first  appeared	in G++ 3.4.  Version 1 is the version of the C++
	 ABI that first appeared in G++ 3.2.  Version 0 will always be the  ver-
	 sion  that  conforms most closely to the C++ ABI specification.  There-
	 fore, the ABI obtained using version 0 will  change  as  ABI  bugs  are
	 fixed.

	 The default is version 2.

     -fno-access-control
	 Turn off all access checking.	This switch is mainly useful for working
	 around bugs in the access control code.

     -fcheck-new
	 Check	that  the  pointer returned by "operator new" is non-null before
	 attempting to modify the storage allocated.  This check is normally un-
	 necessary because the C++ standard specifies that "operator  new"  will
	 only  return  0  if  it is declared throw(), in which case the compiler
	 will always check the return value even without this  option.	 In  all
	 other	cases,	when "operator new" has a non-empty exception specifica-
	 tion, memory exhaustion is signalled by throwing "std::bad_alloc".  See
	 also new (nothrow).

     -fconserve-space
	 Put uninitialized or runtime-initialized global variables into the com-
	 mon segment, as C does.  This saves space in the executable at the cost
	 of not diagnosing duplicate definitions.  If you compile with this flag
	 and your program mysteriously crashes after "main()" has completed, you
	 may have an object that is being destroyed twice  because  two  defini-
	 tions 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.

     -ffriend-injection
	 Inject friend functions into the enclosing namespace, so that they  are
	 visible  outside  the	scope  of  the class in which they are declared.
	 Friend functions were documented to work this way in the old  Annotated
	 C++ Reference Manual, and versions of G++ before 4.1 always worked that
	 way.  However, in ISO C++ a friend function which is not declared in an
	 enclosing  scope  can	only  be  found using argument dependent lookup.
	 This option causes friends to be injected as they were in  earlier  re-
	 leases.

	 This  option  is  for compatibility, and may be removed in a future re-
	 lease of G++.

     -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.

     -fno-enforce-eh-specs
	 Don't	generate code to check for violation of exception specifications
	 at runtime.  This option violates the C++ standard, but may  be  useful
	 for reducing code size in production builds, much like defining NDEBUG.
	 This  does  not give user code permission to throw exceptions in viola-
	 tion of the exception specifications; the compiler will still	optimize
	 based	on  the specifications, so throwing an unexpected exception will
	 result in undefined behavior.

     -ffor-scope
     -fno-for-scope
	 If -ffor-scope is specified, the scope of variables declared in a  for-
	 init-statement  is  limited to the for loop itself, as specified by the
	 C++ standard.	If -fno-for-scope is specified, the scope  of  variables
	 declared  in  a  for-init-statement extends to the end of the enclosing
	 scope, as was the case in old versions of G++, and other  (traditional)
	 implementations of C++.

	 The default if neither flag is given to follow the standard, but to al-
	 low  and  give a warning for old-style code that would otherwise be in-
	 valid, or have different behavior.

     -fno-gnu-keywords
	 Do not recognize "typeof" as a keyword, so that code can use this  word
	 as an identifier.  You can use the keyword "__typeof__" instead.  -ansi
	 implies -fno-gnu-keywords.

     -fno-implicit-templates
	 Never emit code for non-inline templates which are instantiated implic-
	 itly (i.e. by use); only emit code for explicit instantiations.

     -fno-implicit-inline-templates
	 Don't	emit  code  for implicit instantiations of inline templates, ei-
	 ther.	The default is to handle inlines differently  so  that	compiles
	 with  and  without  optimization will need the same set of explicit in-
	 stantiations.

     -fno-implement-inlines
	 To save space, do not emit out-of-line copies of inline functions  con-
	 trolled  by  #pragma  implementation.	This will cause linker errors if
	 these functions are not inlined everywhere they are called.

     -fms-extensions
	 Disable pedantic warnings about constructs used in  MFC,  such  as  im-
	 plicit  int  and  getting a pointer to member function via non-standard
	 syntax.

     -fno-nonansi-builtins
	 Disable built-in declarations of functions that  are  not  mandated  by
	 ANSI/ISO  C.  These include "ffs", "alloca", "_exit", "index", "bzero",
	 "conjf", and other related functions.

     -fno-operator-names
	 Do not treat the  operator  name  keywords  "and",  "bitand",	"bitor",
	 "compl", "not", "or" and "xor" as synonyms as keywords.

     -fno-optional-diags
	 Disable  diagnostics that the standard says a compiler does not need to
	 issue.  Currently, the only such diagnostic issued by G++  is	the  one
	 for a name having multiple meanings within a class.

     -fpermissive
	 Downgrade  some  diagnostics  about  nonconformant  code from errors to
	 warnings.  Thus, using -fpermissive will allow some nonconforming  code
	 to compile.

     -frepo
	 Enable automatic template instantiation at link time.	This option also
	 implies -fno-implicit-templates.

     -fno-rtti
	 Disable  generation of information about every class with virtual func-
	 tions for use by the C++  runtime  type  identification  features  (dy-
	 namic_cast  and typeid).  If you don't use those parts of the language,
	 you can save some space by using this flag.  Note that  exception  han-
	 dling uses the same information, but it will generate it as needed. The
	 dynamic_cast  operator  can still be used for casts that do not require
	 runtime type information, i.e. casts to "void *" or to unambiguous base
	 classes.

     -fstats
	 Emit statistics about front-end processing at the end of  the	compila-
	 tion.	This information is generally only useful to the G++ development
	 team.

     -ftemplate-depth-n
	 Set the maximum instantiation depth for template classes to n.  A limit
	 on  the template instantiation depth is needed to detect endless recur-
	 sions during template class  instantiation.   ANSI/ISO  C++  conforming
	 programs must not rely on a maximum depth greater than 17.

     -fno-threadsafe-statics
	 Do not emit the extra code to use the routines specified in the C++ ABI
	 for  thread-safe initialization of local statics.  You can use this op-
	 tion to reduce code size slightly in  code  that  doesn't  need  to  be
	 thread-safe.

     -fuse-cxa-atexit
	 Register  destructors for objects with static storage duration with the
	 "__cxa_atexit" function rather than the "atexit" function.  This option
	 is required for fully standards-compliant handling of	static	destruc-
	 tors, but will only work if your C library supports "__cxa_atexit".

     -fno-use-cxa-get-exception-ptr
	 Don't	use  the  "__cxa_get_exception_ptr"  runtime routine.  This will
	 cause "std::uncaught_exception" to be incorrect, but  is  necessary  if
	 the runtime routine is not available.

     -fvisibility-inlines-hidden
	 This switch declares that the user does not attempt to compare pointers
	 to  inline  methods where the addresses of the two functions were taken
	 in different shared objects.

	 The effect of this is that GCC may, effectively,  mark  inline  methods
	 with  "__attribute__ ((visibility ("hidden")))" so that they do not ap-
	 pear in the export table of a DSO and do not require a PLT  indirection
	 when used within the DSO.  Enabling this option can have a dramatic ef-
	 fect  on  load and link times of a DSO as it massively reduces the size
	 of the dynamic export table when the library makes heavy  use	of  tem-
	 plates.

	 The behaviour of this switch is not quite the same as marking the meth-
	 ods as hidden directly, because it does not affect static variables lo-
	 cal  to  the function or cause the compiler to deduce that the function
	 is defined in only one shared object.

	 You may mark a method as having a visibility explicitly to  negate  the
	 effect  of  the switch for that method.  For example, if you do want to
	 compare pointers to a particular inline method, you might  mark  it  as
	 having  default  visibility.  Marking the enclosing class with explicit
	 visibility will have no effect.

	 Explicitly instantiated inline methods are unaffected by this option as
	 their linkage might otherwise cross a shared library boundary.

     -fno-weak
	 Do not use weak symbol support, even if it is provided by  the  linker.
	 By  default, G++ will use weak symbols if they are available.	This op-
	 tion exists only for testing, and should not be used by  end-users;  it
	 will  result  in inferior code and has no benefits.  This option may be
	 removed in a future release of G++.

     -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 the C++ library.)

     In addition, these optimization, warning, and code generation options  have
     meanings only for C++ programs:

     -fno-default-inline
	 Do not assume inline for functions defined inside a class scope.
	   Note  that  these  functions will have linkage like inline functions;
	 they just won't be inlined by default.

     -Wabi (C++ only)
	 Warn when G++ generates code that is probably not compatible  with  the
	 vendor-neutral C++ ABI.  Although an effort has been made to warn about
	 all  such  cases,  there  are	probably  some cases that are not warned
	 about, even though G++ is generating incompatible code.  There may also
	 be cases where warnings are emitted even though the code that is gener-
	 ated will be compatible.

	 You should rewrite your code to avoid these warnings if  you  are  con-
	 cerned about the fact that code generated by G++ may not be binary com-
	 patible with code generated by other compilers.

	 The known incompatibilities at this point include:

	 *   Incorrect handling of tail-padding for bit-fields.  G++ may attempt
	     to pack data into the same byte as a base class.  For example:

		     struct A { virtual void f(); int f1 : 1; };
		     struct B : public A { int f2 : 1; };

	     In  this case, G++ will place "B::f2" into the same byte as"A::f1";
	     other compilers will not.	You can avoid this problem by explicitly
	     padding "A" so that its size is a multiple of the byte size on your
	     platform; that will cause G++ and other  compilers  to  layout  "B"
	     identically.

	 *   Incorrect handling of tail-padding for virtual bases.  G++ does not
	     use tail padding when laying out virtual bases.  For example:

		     struct A { virtual void f(); char c1; };
		     struct B { B(); char c2; };
		     struct C : public A, public virtual B {};

	     In this case, G++ will not place "B" into the tail-padding for "A";
	     other  compilers  will.   You  can avoid this problem by explicitly
	     padding "A" so that its size is a multiple of its alignment (ignor-
	     ing virtual base classes); that will cause G++ and other  compilers
	     to layout "C" identically.

	 *   Incorrect	handling of bit-fields with declared widths greater than
	     that of their underlying types, when the  bit-fields  appear  in  a
	     union.  For example:

		     union U { int i : 4096; };

	     Assuming  that  an "int" does not have 4096 bits, G++ will make the
	     union too small by the number of bits in an "int".

	 *   Empty classes can be placed at incorrect offsets.	For example:

		     struct A {};

		     struct B {
		       A a;
		       virtual void f ();
		     };

		     struct C : public B, public A {};

	     G++ will place the "A" base class of "C" at a  nonzero  offset;  it
	     should  be placed at offset zero.	G++ mistakenly believes that the
	     "A" data member of "B" is already at offset zero.

	 *   Names of template functions whose types involve "typename" or  tem-
	     plate template parameters can be mangled incorrectly.

		     template <typename Q>
		     void f(typename Q::X) {}

		     template <template <typename> class Q>
		     void f(typename Q<int>::X) {}

	     Instantiations of these templates may be mangled incorrectly.

     -Wctor-dtor-privacy (C++ only)
	 Warn  when  a	class seems unusable because all the constructors or de-
	 structors in that class are private, and it  has  neither  friends  nor
	 public static member functions.

     -Wnon-virtual-dtor (C++ only)
	 Warn  when  a class appears to be polymorphic, thereby requiring a vir-
	 tual destructor, yet it declares a non-virtual one.   This  warning  is
	 also enabled if -Weffc++ is specified.

     -Wreorder (C++ only)
	 Warn  when  the order of member initializers given in the code does not
	 match the order in which they must be executed.  For instance:

		 struct A {
		   int i;
		   int j;
		   A(): j (0), i (1) { }
		 };

	 The compiler will rearrange the member initializers  for  i  and  j  to
	 match	the declaration order of the members, emitting a warning to that
	 effect.  This warning is enabled by -Wall.

     The following -W... options are not affected by -Wall.

     -Weffc++ (C++ only)
	 Warn about violations of the following style guidelines from Scott Mey-
	 ers' Effective C++ book:

	 *   Item 11:  Define a copy constructor and an assignment operator  for
	     classes with dynamically allocated memory.

	 *   Item 12:  Prefer initialization to assignment in constructors.

	 *   Item 14:  Make destructors virtual in base classes.

	 *   Item 15:  Have "operator=" return a reference to *this.

	 *   Item  23:	 Don't try to return a reference when you must return an
	     object.

	 Also warn about violations of the following style guidelines from Scott
	 Meyers' More Effective C++ book:

	 *   Item 6:  Distinguish between prefix and postfix forms of  increment
	     and decrement operators.

	 *   Item 7:  Never overload "&&", "||", or ",".

	 When  selecting this option, be aware that the standard library headers
	 do not obey all of these guidelines; use grep -v to  filter  out  those
	 warnings.

     -Wno-deprecated (C++ only)
	 Do not warn about usage of deprecated features.

     -Wstrict-null-sentinel (C++ only)
	 Warn  also  about the use of an uncasted "NULL" as sentinel.  When com-
	 piling only with GCC this is a valid sentinel, as "NULL" is defined  to
	 "__null".   Although  it is a null pointer constant not a null pointer,
	 it is guaranteed to of the same size as a pointer.  But this use is not
	 portable across different compilers.

     -Wno-non-template-friend (C++ only)
	 Disable warnings when non-templatized	friend	functions  are	declared
	 within a template.  Since the advent of explicit template specification
	 support  in  G++, if the name of the friend is an unqualified-id (i.e.,
	 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 templa-
	 tized function.  Because this non-conforming behavior is no longer  the
	 default  behavior for G++, -Wnon-template-friend allows the compiler to
	 check existing code for potential trouble spots and is on  by	default.
	 This  new  compiler  behavior	can  be  turned  off  with -Wno-non-tem-
	 plate-friend which keeps the conformant compiler code but disables  the
	 helpful warning.

     -Wold-style-cast (C++ only)
	 Warn if an old-style (C-style) cast to a non-void type is used within a
	 C++  program.	The new-style casts (dynamic_cast, static_cast, reinter-
	 pret_cast, and const_cast) are less vulnerable  to  unintended  effects
	 and much easier to search for.

     -Woverloaded-virtual (C++ only)
	 Warn  when  a	function declaration hides virtual functions from a base
	 class.  For example, in:

		 struct A {
		   virtual void f();
		 };

		 struct B: public A {
		   void f(int);
		 };

	 the "A" class version of "f" is hidden in "B", and code like:

		 B* b;
		 b->f();

	 will fail to compile.

     -Wno-pmf-conversions (C++ only)
	 Disable the diagnostic for converting a bound pointer to  member  func-
	 tion to a plain pointer.

     -Wsign-promo (C++ only)
	 Warn when overload resolution chooses a promotion from unsigned or enu-
	 merated type to a signed type, over a conversion to an unsigned type of
	 the  same  size.   Previous  versions	of G++ would try to preserve un-
	 signedness, but the standard mandates the current behavior.

		 struct A {
		   operator int ();
		   A& operator = (int);
		 };

		 main ()
		 {
		   A a,b;
		   a = b;
		 }

	 In this example, G++ will synthesize a default  A&  operator  =  (const
	 A&);, while cfront will use the user-defined operator =.

     Options to Control Diagnostic Messages Formatting

     Traditionally,  diagnostic messages have been formatted irrespective of the
     output device's aspect (e.g. its width, ...).  The options described  below
     can  be  used to control the diagnostic messages formatting algorithm, e.g.
     how many characters per line, how often source location information  should
     be  reported.   Right  now, only the C++ front end can honor these options.
     However it is expected, in the near future, that the remaining  front  ends
     would be able to digest them correctly.

     -fmessage-length=n
	 Try to format error messages so that they fit on lines of about n char-
	 acters.  The default is 72 characters for g++ and 0 for the rest of the
	 front	ends supported by GCC.	If n is zero, then no line-wrapping will
	 be done; each error message will appear on a single line.

     -fdiagnostics-show-location=once
	 Only meaningful in line-wrapping mode.  Instructs the	diagnostic  mes-
	 sages	reporter  to  emit once source location information; that is, in
	 case the message is too long to fit on a single physical line	and  has
	 to  be wrapped, the source location won't be emitted (as prefix) again,
	 over and over, in subsequent continuation lines.  This is  the  default
	 behavior.

     -fdiagnostics-show-location=every-line
	 Only  meaningful  in line-wrapping mode.  Instructs the diagnostic mes-
	 sages reporter to emit the same source location information (as prefix)
	 for physical lines that result from the process of breaking  a  message
	 which is too long to fit on a single line.

     -fdiagnostics-show-option
	 This  option instructs the diagnostic machinery to add text to each di-
	 agnostic emitted, which indicates which command  line	option	directly
	 controls  that diagnostic, when such an option is known to the diagnos-
	 tic machinery.

     Options to Request or Suppress Warnings

     Warnings are diagnostic messages that report constructions  which	are  not
     inherently  erroneous but which are risky or suggest there may have been an
     error.

     You can request many specific warnings with options beginning -W, for exam-
     ple -Wimplicit to request warnings on implicit declarations.  Each of these
     specific warning options also has a negative form beginning -Wno-	to  turn
     off  warnings;  for  example, -Wno-implicit.  This manual lists only one of
     the two forms, whichever is not the default.

     The following options control the amount and kinds of warnings produced  by
     GCC;  for	further, language-specific options also refer to C++ Dialect Op-
     tions.

     -fsyntax-only
	 Check the code for syntax errors, but don't do anything beyond that.

     -pedantic
	 Issue all the warnings demanded by strict ISO C and ISO C++; reject all
	 programs that use forbidden extensions, and some other programs that do
	 not follow ISO C and ISO C++.	For ISO C, follows the	version  of  the
	 ISO C standard specified by any -std option used.

	 Valid	ISO C and ISO C++ programs should compile properly with or with-
	 out this option (though a rare few will require -ansi or a -std  option
	 specifying  the  required version of ISO C).  However, without this op-
	 tion, certain GNU extensions and traditional C  and  C++  features  are
	 supported as well.  With this option, they are rejected.

	 -pedantic does not cause warning messages for use of the alternate key-
	 words	whose  names  begin and end with __.  Pedantic warnings are also
	 disabled in the expression that follows "__extension__".  However, only
	 system header files should use these escape  routes;  application  pro-
	 grams should avoid them.

	 Some users try to use -pedantic to check programs for strict ISO C con-
	 formance.   They soon find that it does not do quite what they want: it
	 finds some non-ISO practices, but not all---only those for which ISO  C
	 requires  a diagnostic, and some others for which diagnostics have been
	 added.

	 A feature to report any failure to conform to ISO C might be useful  in
	 some  instances,  but	would  require	considerable additional work and
	 would be quite different from -pedantic.  We don't have plans	to  sup-
	 port such a feature in the near future.

	 Where	the  standard  specified with -std represents a GNU extended di-
	 alect of C, such as gnu89 or gnu99, there is a corresponding base stan-
	 dard, the version of ISO C on which the GNU extended dialect is  based.
	 Warnings  from  -pedantic are given where they are required by the base
	 standard.  (It would not make sense for such warnings to be given  only
	 for  features	not  in the specified GNU C dialect, since by definition
	 the GNU dialects of C include all features the compiler  supports  with
	 the given option, and there would be nothing to warn about.)

     -pedantic-errors
	 Like -pedantic, except that errors are produced rather than warnings.

     -w  Inhibit all warning messages.

     -Wno-import
	 Inhibit warning messages about the use of #import.

     -Wchar-subscripts
	 Warn  if an array subscript has type "char".  This is a common cause of
	 error, as programmers often forget that this type is signed on some ma-
	 chines.  This warning is enabled by -Wall.

     -Wcomment
	 Warn whenever a comment-start sequence /* appears in a /*  comment,  or
	 whenever  a Backslash-Newline appears in a // comment.  This warning is
	 enabled by -Wall.

     -Wfatal-errors
	 This option causes the compiler to abort compilation on the first error
	 occurred rather than trying to keep going and	printing  further  error
	 messages.

     -Wformat
	 Check	calls to "printf" and "scanf", etc., to make sure that the argu-
	 ments supplied have types appropriate to the format  string  specified,
	 and  that  the  conversions  specified in the format string make sense.
	 This includes standard functions, and others specified  by  format  at-
	 tributes, in the "printf", "scanf", "strftime" and "strfmon" (an X/Open
	 extension,  not  in  the C standard) families (or other target-specific
	 families).  Which functions are checked without format attributes  hav-
	 ing  been  specified depends on the standard version selected, and such
	 checks of functions without the attribute  specified  are  disabled  by
	 -ffreestanding or -fno-builtin.

	 The  formats  are  checked against the format features supported by GNU
	 libc version 2.2.  These include all ISO C90 and C99 features, as  well
	 as features from the Single Unix Specification and some BSD and GNU ex-
	 tensions.  Other library implementations may not support all these fea-
	 tures;  GCC  does  not  support warning about features that go beyond a
	 particular library's limitations.  However, if -pedantic is  used  with
	 -Wformat,  warnings  will be given about format features not in the se-
	 lected standard version (but not for "strfmon" formats, since those are
	 not in any version of the C standard).

	 Since -Wformat also checks for null format arguments for several  func-
	 tions, -Wformat also implies -Wnonnull.

	 -Wformat  is  included in -Wall.  For more control over some aspects of
	 format  checking,  the  options  -Wformat-y2k,  -Wno-format-extra-args,
	 -Wno-format-zero-length,  -Wformat-nonliteral,  -Wformat-security,  and
	 -Wformat=2 are available, but are not included in -Wall.

     -Wformat-y2k
	 If -Wformat is specified, also warn about "strftime" formats which  may
	 yield only a two-digit year.

     -Wno-format-extra-args
	 If  -Wformat  is  specified,  do  not	warn about excess arguments to a
	 "printf" or "scanf" format function.  The  C  standard  specifies  that
	 such arguments are ignored.

	 Where	the  unused arguments lie between used arguments that are speci-
	 fied with $ operand number specifications, normally warnings are  still
	 given,  since	the  implementation  could not know what type to pass to
	 "va_arg" to skip the unused arguments.  However, in the case of "scanf"
	 formats, this option will suppress the warning if the unused  arguments
	 are  all  pointers,  since the Single Unix Specification says that such
	 unused arguments are allowed.

     -Wno-format-zero-length
	 If -Wformat is specified, do not warn about zero-length formats.  The C
	 standard specifies that zero-length formats are allowed.

     -Wformat-nonliteral
	 If -Wformat is specified, also warn if  the  format  string  is  not  a
	 string  literal  and  so  cannot be checked, unless the format function
	 takes its format arguments as a "va_list".

     -Wformat-security
	 If -Wformat is specified, also warn about uses of format functions that
	 represent possible security problems.	At  present,  this  warns  about
	 calls	to "printf" and "scanf" functions where the format string is not
	 a string literal and there are  no  format  arguments,  as  in  "printf
	 (foo);".   This  may  be a security hole if the format string came from
	 untrusted input and contains %n.  (This is currently a subset	of  what
	 -Wformat-nonliteral warns about, but in future warnings may be added to
	 -Wformat-security that are not included in -Wformat-nonliteral.)

     -Wformat=2
	 Enable -Wformat plus format checks not included in -Wformat.  Currently
	 equivalent  to  -Wformat  -Wformat-nonliteral	-Wformat-security -Wfor-
	 mat-y2k.

     -Wnonnull
	 Warn about passing a null pointer for arguments marked as  requiring  a
	 non-null value by the "nonnull" function attribute.

	 -Wnonnull  is	included in -Wall and -Wformat.  It can be disabled with
	 the -Wno-nonnull option.

     -Winit-self (C, C++ only)
	 Warn about uninitialized variables which  are	initialized  with  them-
	 selves.  Note this option can only be used with the -Wuninitialized op-
	 tion, which in turn only works with -O1 and above.

	 For example, GCC will warn about "i" being uninitialized in the follow-
	 ing snippet only when -Winit-self has been specified:

		 int f()
		 {
		   int i = i;
		   return i;
		 }

     -Wimplicit-int
	 Warn  when  a declaration does not specify a type.  This warning is en-
	 abled by -Wall.

     -Wimplicit-function-declaration
     -Werror-implicit-function-declaration
	 Give a warning (or error) whenever a function is used before being  de-
	 clared.   The form -Wno-error-implicit-function-declaration is not sup-
	 ported.  This warning is enabled by -Wall (as a warning, not an error).

     -Wimplicit
	 Same as -Wimplicit-int and -Wimplicit-function-declaration.  This warn-
	 ing is enabled by -Wall.

     -Wmain
	 Warn if the type of main is suspicious.  main should be a function with
	 external linkage, returning int, taking either zero arguments, two,  or
	 three	arguments  of  appropriate  types.   This  warning is enabled by
	 -Wall.

     -Wmissing-braces
	 Warn if an aggregate or union initializer is not fully  bracketed.   In
	 the  following  example,  the initializer for a is not fully bracketed,
	 but that for b is fully bracketed.

		 int a[2][2] = { 0, 1, 2, 3 };
		 int b[2][2] = { { 0, 1 }, { 2, 3 } };

	 This warning is enabled by -Wall.

     -Wmissing-include-dirs (C and C++ only)
	 Warn if a user-supplied include directory does not exist.

     -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.
	 Only the warning for an assignment used as a truth value  is  supported
	 when  compiling C++; the other warnings are only supported when compil-
	 ing C.

	 Also warn if a comparison like x<=y<=z appears; this is  equivalent  to
	 (x<=y	?  1 : 0) <= z, which is a different interpretation from that of
	 ordinary mathematical notation.

	 Also warn about constructions where there may	be  confusion  to  which
	 "if"  statement an "else" branch belongs.  Here is an example of such a
	 case:

		 {
		   if (a)
		     if (b)
		       foo ();
		   else
		     bar ();
		 }

	 In C, every "else" branch belongs to the innermost possible "if" state-
	 ment, which in this example is "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,
	 GCC will issue a warning when this flag is specified.	To eliminate the
	 warning, add explicit braces around the  innermost  "if"  statement  so
	 there is no way the "else" could belong to the enclosing "if".  The re-
	 sulting code would look like this:

		 {
		   if (a)
		     {
		       if (b)
			 foo ();
		       else
			 bar ();
		     }
		 }

	 This warning is enabled by -Wall.

     -Wsequence-point
	 Warn about code that may have undefined semantics because of violations
	 of sequence point rules in the C and C++ standards.

	 The  C  and  C++  standards defines the order in which expressions in a
	 C/C++ program are evaluated in terms of sequence points,  which  repre-
	 sent  a partial ordering between the execution of parts of the program:
	 those executed before the sequence point, and those executed after  it.
	 These occur after the evaluation of a full expression (one which is not
	 part of a larger expression), after the evaluation of the first operand
	 of  a	"&&",  "||", "? :" or "," (comma) operator, before a function is
	 called (but after the evaluation of its arguments  and  the  expression
	 denoting the called function), and in certain other places.  Other than
	 as  expressed	by  the sequence point rules, the order of evaluation of
	 subexpressions of an expression is not specified.  All these rules  de-
	 scribe only a partial order rather than a total order, since, for exam-
	 ple, if two functions are called within one expression with no sequence
	 point	between them, the order in which the functions are called is not
	 specified.  However, the standards committee have ruled  that	function
	 calls do not overlap.

	 It  is  not specified when between sequence points modifications to the
	 values of objects take effect.  Programs whose behavior depends on this
	 have undefined behavior; the C and C++ standards specify that	"Between
	 the  previous	and  next sequence point an object shall have its stored
	 value modified at most once by the evaluation of an  expression.   Fur-
	 thermore,  the prior value shall be read only to determine the value to
	 be stored.".  If a program breaks these rules, the results on any  par-
	 ticular implementation are entirely unpredictable.

	 Examples  of  code  with  undefined  behavior	are  "a = a++;", "a[n] =
	 b[n++]" and "a[i++] = i;".  Some more complicated cases are  not  diag-
	 nosed	by this option, and it may give an occasional false positive re-
	 sult, but in general it has been found fairly	effective  at  detecting
	 this sort of problem in programs.

	 The standard is worded confusingly, therefore there is some debate over
	 the precise meaning of the sequence point rules in subtle cases.  Links
	 to  discussions  of the problem, including proposed formal definitions,
	 may be found on the GCC  readings  page,  at  <http://gcc.gnu.org/read-
	 ings.html>.

	 This warning is enabled by -Wall for C and C++.

     -Wreturn-type
	 Warn whenever a function is defined with a return-type that defaults to
	 "int".   Also warn about any "return" statement with no return-value in
	 a function whose return-type is not "void".

	 For C, also warn if the return type of a function has a type  qualifier
	 such  as "const".  Such a type qualifier has no effect, since the value
	 returned by a function is not an lvalue.   ISO  C  prohibits  qualified
	 "void"  return  types on function definitions, so such return types al-
	 ways receive a warning even without this option.

	 For C++, a function without return type always  produces  a  diagnostic
	 message,  even when -Wno-return-type is specified.  The only exceptions
	 are main and functions defined in system headers.

	 This warning is enabled by -Wall.

     -Wswitch
	 Warn whenever a "switch" statement has an index of enumerated type  and
	 lacks	a "case" for one or more of the named codes of that enumeration.
	 (The presence of a "default" label prevents this warning.)  "case"  la-
	 bels  outside the enumeration range also provoke warnings when this op-
	 tion is used.	This warning is enabled by -Wall.

     -Wswitch-default
	 Warn whenever a "switch" statement does not have a "default" case.

     -Wswitch-enum
	 Warn whenever a "switch" statement has an index of enumerated type  and
	 lacks	a "case" for one or more of the named codes of that enumeration.
	 "case" labels outside the enumeration range also provoke warnings  when
	 this option is used.

     -Wtrigraphs
	 Warn  if any trigraphs are encountered that might change the meaning of
	 the program (trigraphs within comments are  not  warned  about).   This
	 warning is enabled by -Wall.

     -Wunused-function
	 Warn  whenever  a static function is declared but not defined or a non-
	 inline static function is unused.  This warning is enabled by -Wall.

     -Wunused-label
	 Warn whenever a label is declared but not used.  This	warning  is  en-
	 abled by -Wall.

	 To suppress this warning use the unused attribute.

     -Wunused-parameter
	 Warn  whenever  a  function parameter is unused aside from its declara-
	 tion.

	 To suppress this warning use the unused attribute.

     -Wunused-variable
	 Warn whenever a local variable or non-constant static variable  is  un-
	 used aside from its declaration.  This warning is enabled by -Wall.

	 To suppress this warning use the unused attribute.

     -Wunused-value
	 Warn  whenever  a  statement  computes  a result that is explicitly not
	 used.	This warning is enabled by -Wall.

	 To suppress this warning cast the expression to void.

     -Wunused
	 All the above -Wunused options combined.

	 In order to get a warning about an unused function parameter, you  must
	 either  specify -Wextra -Wunused (note that -Wall implies -Wunused), or
	 separately specify -Wunused-parameter.

     -Wuninitialized
	 Warn if an automatic variable is used without first  being  initialized
	 or if a variable may be clobbered by a "setjmp" call.

	 These	warnings  are  possible  only in optimizing compilation, because
	 they require data flow information that is computed only when	optimiz-
	 ing.	If  you  do not specify -O, you will not get these warnings. In-
	 stead, GCC will issue a warning about -Wuninitialized requiring -O.

	 If you want to warn about code which uses the	uninitialized  value  of
	 the variable in its own initializer, use the -Winit-self option.

	 These warnings occur for individual uninitialized or clobbered elements
	 of  structure,  union or array variables as well as for variables which
	 are uninitialized or clobbered as a whole.  They do not occur for vari-
	 ables or elements declared "volatile".  Because these	warnings  depend
	 on  optimization,  the  exact variables or elements for which there are
	 warnings will depend on the precise optimization options and version of
	 GCC used.

	 Note that there may be no warning about a variable that is used only to
	 compute a value that itself is never used,  because  such  computations
	 may be deleted by data flow analysis before the warnings are printed.

	 These warnings are made optional because GCC is not smart enough to see
	 all the reasons why the code might be correct despite appearing to have
	 an error.  Here is one example of how this can happen:

		 {
		   int x;
		   switch (y)
		     {
		     case 1: x = 1;
		       break;
		     case 2: x = 4;
		       break;
		     case 3: x = 5;
		     }
		   foo (x);
		 }

	 If  the  value  of "y" is always 1, 2 or 3, then "x" is always initial-
	 ized, but GCC doesn't know this.  Here is another common case:

		 {
		   int save_y;
		   if (change_y) save_y = y, y = new_y;
		   ...
		   if (change_y) y = save_y;
		 }

	 This has no bug because "save_y" is used only if it is set.

	 This option also warns when a non-volatile automatic variable might  be
	 changed  by  a  call to "longjmp".  These warnings as well are possible
	 only in optimizing compilation.

	 The compiler sees only the calls to "setjmp".	 It  cannot  know  where
	 "longjmp"  will  be  called; in fact, a signal handler could call it at
	 any point in the code.  As a result, you may get a  warning  even  when
	 there	is in fact no problem because "longjmp" cannot in fact be called
	 at the place which would cause a problem.

	 Some spurious warnings can be avoided if you declare all the  functions
	 you use that never return as "noreturn".

	 This warning is enabled by -Wall.

     -Wunknown-pragmas
	 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 -Wall command line option.

     -Wno-pragmas
	 Do not warn about misuses of pragmas, such as incorrect parameters, in-
	 valid syntax, or conflicts between pragmas.  See  also  -Wunknown-prag-
	 mas.

     -Wstrict-aliasing
	 This  option is only active when -fstrict-aliasing is active.	It warns
	 about code which might break the strict aliasing rules  that  the  com-
	 piler is using for optimization.  The warning does not catch all cases,
	 but  does attempt to catch the more common pitfalls.  It is included in
	 -Wall.

     -Wstrict-aliasing=2
	 This option is only active when -fstrict-aliasing is active.  It  warns
	 about	code  which  might break the strict aliasing rules that the com-
	 piler is using for optimization.  This warning catches more cases  than
	 -Wstrict-aliasing,  but  it will also give a warning for some ambiguous
	 cases that are safe.

     -Wstrict-overflow
     -Wstrict-overflow=n
	 This option is only active when -fstrict-overflow is active.  It  warns
	 about	cases  where the compiler optimizes based on the assumption that
	 signed overflow does not occur.  Note that it does not warn  about  all
	 cases	where  the  code might overflow: it only warns about cases where
	 the compiler implements some optimization.  Thus this	warning  depends
	 on the optimization level.

	 An  optimization  which  assumes that signed overflow does not occur is
	 perfectly safe if the values of the variables involved  are  such  that
	 overflow never does, in fact, occur.  Therefore this warning can easily
	 give  a  false  positive:  a warning about code which is not actually a
	 problem.  To help focus on important issues, several warning levels are
	 defined.  No warnings are issued for the use of undefined signed  over-
	 flow  when  estimating how many iterations a loop will require, in par-
	 ticular when determining whether a loop will be executed at all.

	 @option<-Wstrict-overflow=1>
	     Warn about cases which are both questionable  and	easy  to  avoid.
	     For example: "x + 1 > x"; with -fstrict-overflow, the compiler will
	     simplify  this to 1.  This level of -Wstrict-overflow is enabled by
	     -Wall; higher levels are not, and must be explicitly requested.

	 @option<-Wstrict-overflow=2>
	     Also warn about other cases where a comparison is simplified  to  a
	     constant.	 For  example: "abs (x) >= 0".	This can only be simpli-
	     fied when -fstrict-overflow is in effect, because	"abs  (INT_MIN)"
	     overflows to "INT_MIN", which is less than zero.  -Wstrict-overflow
	     (with no level) is the same as -Wstrict-overflow=2.

	 @option<-Wstrict-overflow=3>
	     Also  warn about other cases where a comparison is simplified.  For
	     example: "x + 1 > 1" will be simplified to "x > 0".

	 @option<-Wstrict-overflow=4>
	     Also warn about other simplifications  not  covered  by  the  above
	     cases.  For example: "(x * 10) / 5" will be simplified to "x * 2".

	 @option<-Wstrict-overflow=5>
	     Also warn about cases where the compiler reduces the magnitude of a
	     constant  involved  in a comparison.  For example: "x + 2 > y" will
	     be simplified to "x + 1 >= y".  This is reported only at the  high-
	     est  warning level because this simplification applies to many com-
	     parisons, so this warning level will give a very  large  number  of
	     false positives.

     -Wall
	 All  of  the  above -W options combined.  This enables all the warnings
	 about constructions that some users consider questionable, and that are
	 easy to avoid (or modify to prevent the warning), even  in  conjunction
	 with  macros.	 This  also  enables some language-specific warnings de-
	 scribed in C++ Dialect Options.

     The following -W... options are not implied by -Wall.  Some  of  them  warn
     about  constructions that users generally do not consider questionable, but
     which occasionally you might wish to check for; others warn about construc-
     tions that are necessary or hard to avoid in some cases, and  there  is  no
     simple way to modify the code to suppress the warning.

     -Wextra
	 (This	option used to be called -W.  The older name is still supported,
	 but the newer name is more descriptive.)  Print extra warning	messages
	 for these events:

	 *   A function can return either with or without a value.  (Falling off
	     the  end  of  the	function  body is considered returning without a
	     value.)  For example, this function would evoke such a warning:

		     foo (a)
		     {
		       if (a > 0)
			 return a;
		     }

	 *   An expression-statement or the left-hand side of a comma expression
	     contains no side effects.	To suppress the warning, cast the unused
	     expression to void.  For example, an expression such as x[i,j] will
	     cause a warning, but x[(void)i,j] will not.

	 *   An unsigned value is compared against zero with < or >=.

	 *   Storage-class specifiers like "static" are not the first things  in
	     a declaration.  According to the C Standard, this usage is obsoles-
	     cent.

	 *   If  -Wall	or  -Wunused  is also specified, warn about unused argu-
	     ments.

	 *   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 -Wno-sign-compare is also specified.)

	 *   An aggregate has an initializer which does not initialize all  mem-
	     bers.   This  warning  can  be  independently controlled by -Wmiss-
	     ing-field-initializers.

	 *   An initialized field without side effects is overridden when  using
	     designated  initializers.	 This  warning can be independently con-
	     trolled by -Woverride-init.

	 *   A function parameter  is  declared  without  a  type  specifier  in
	     K&R-style functions:

		     void foo(bar) { }

	 *   An empty body occurs in an if or else statement.

	 *   A pointer is compared against integer zero with <, <=, >, or >=.

	 *   A variable might be changed by longjmp or vfork.

	 *<(C++ only)>
	     An enumerator and a non-enumerator both appear in a conditional ex-
	     pression.

	 *<(C++ only)>
	     A	non-static  reference  or  non-static  const member appears in a
	     class without constructors.

	 *<(C++ only)>
	     Ambiguous virtual bases.

	 *<(C++ only)>
	     Subscripting an array which has been declared register.

	 *<(C++ only)>
	     Taking the address of a variable which has been declared register.

	 *<(C++ only)>
	     A base class is not initialized in a derived class' copy  construc-
	     tor.

     -Wno-div-by-zero
	 Do  not  warn	about  compile-time  integer division by zero.	Floating
	 point division by zero is not warned about, as it can be  a  legitimate
	 way of obtaining infinities and NaNs.

     -Wsystem-headers
	 Print	warning  messages  for	constructs found in system header files.
	 Warnings from system headers are normally suppressed, on the assumption
	 that they usually do not indicate real problems and would only make the
	 compiler output harder to read.  Using this command line  option  tells
	 GCC  to  emit	warnings from system headers as if they occurred in user
	 code.	However, note that using -Wall in conjunction with  this  option
	 will not warn about unknown pragmas in system headers---for that, -Wun-
	 known-pragmas must also be used.

     -Wfloat-equal
	 Warn if floating point values are used in equality comparisons.

	 The  idea  behind this is that sometimes it is convenient (for the pro-
	 grammer) to consider floating-point values as approximations  to  infi-
	 nitely  precise  real numbers.  If you are doing this, then you need to
	 compute (by analyzing the code, or in some other way)	the  maximum  or
	 likely  maximum error that the computation introduces, and allow for it
	 when performing comparisons (and when producing output,  but  that's  a
	 different  problem).	In  particular, instead of testing for equality,
	 you would check to see whether the two values have ranges that overlap;
	 and this is done with the relational operators, so equality comparisons
	 are probably mistaken.

     -Wtraditional (C only)
	 Warn about certain constructs that behave  differently  in  traditional
	 and ISO C.  Also warn about ISO C constructs that have no traditional C
	 equivalent, and/or problematic constructs which should be avoided.

	 *   Macro  parameters	that  appear within string literals in the macro
	     body.  In traditional C macro replacement takes place within string
	     literals, but does not in ISO C.

	 *   In traditional C, some preprocessor directives did not exist.  Tra-
	     ditional preprocessors would only consider a line to be a directive
	     if the # appeared in column 1 on the line.  Therefore -Wtraditional
	     warns about directives that traditional C understands but would ig-
	     nore because the # does not appear as the first  character  on  the
	     line.  It also suggests you hide directives like #pragma not under-
	     stood  by traditional C by indenting them.  Some traditional imple-
	     mentations would not recognize #elif, so it  suggests  avoiding  it
	     altogether.

	 *   A function-like macro that appears without arguments.

	 *   The unary plus operator.

	 *   The  U  integer  constant suffix, or the F or L floating point con-
	     stant suffixes.  (Traditional C does support the L suffix on  inte-
	     ger  constants.)	Note, these suffixes appear in macros defined in
	     the system headers of  most  modern  systems,  e.g.  the  _MIN/_MAX
	     macros  in  "<limits.h>".	 Use  of these macros in user code might
	     normally lead to spurious warnings, however GCC's	integrated  pre-
	     processor has enough context to avoid warning in these cases.

	 *   A	function  declared external in one block and then used after the
	     end of the block.

	 *   A "switch" statement has an operand of type "long".

	 *   A non-"static" function declaration follows a "static"  one.   This
	     construct is not accepted by some traditional C compilers.

	 *   The  ISO  type  of  an  integer  constant	has a different width or
	     signedness from its traditional type.  This warning is only  issued
	     if the base of the constant is ten.  I.e. hexadecimal or octal val-
	     ues, which typically represent bit patterns, are not warned about.

	 *   Usage of ISO string concatenation is detected.

	 *   Initialization of automatic aggregates.

	 *   Identifier  conflicts  with labels.  Traditional C lacks a separate
	     namespace for labels.

	 *   Initialization of unions.	If the initializer is zero, the  warning
	     is  omitted.   This is done under the assumption that the zero ini-
	     tializer in user code appears conditioned	on  e.g.  "__STDC__"  to
	     avoid  missing  initializer warnings and relies on default initial-
	     ization to zero in the traditional C case.

	 *   Conversions by prototypes between fixed/floating point  values  and
	     vice  versa.   The  absence of these prototypes when compiling with
	     traditional C would cause serious problems.  This is  a  subset  of
	     the  possible  conversion	warnings, for the full set use -Wconver-
	     sion.

	 *   Use of ISO C style function definitions.  This  warning  intention-
	     ally is not issued for prototype declarations or variadic functions
	     because  these  ISO  C features will appear in your code when using
	     libiberty's  traditional  C  compatibility  macros,  "PARAMS"   and
	     "VPARAMS".   This warning is also bypassed for nested functions be-
	     cause that feature is already a GCC extension and thus not relevant
	     to traditional C compatibility.

     -Wdeclaration-after-statement (C only)
	 Warn when a declaration is found after a statement in	a  block.   This
	 construct,  known  from  C++, was introduced with ISO C99 and is by de-
	 fault allowed in GCC.	It is not supported by ISO C90 and was not  sup-
	 ported by GCC versions before GCC 3.0.

     -Wundef
	 Warn if an undefined identifier is evaluated in an #if directive.

     -Wno-endif-labels
	 Do not warn whenever an #else or an #endif are followed by text.

     -Wshadow
	 Warn  whenever a local variable shadows another local variable, parame-
	 ter or global variable or whenever a built-in function is shadowed.

     -Wlarger-than-len
	 Warn whenever an object of larger than len bytes is defined.

     -Wunsafe-loop-optimizations
	 Warn if the loop cannot be optimized because the compiler could not as-
	 sume  anything  on  the  bounds  of  the  loop  indices.   With   -fun-
	 safe-loop-optimizations warn if the compiler made such assumptions.

     -Wpointer-arith
	 Warn about anything that depends on the "size of" a function type or of
	 "void".  GNU C assigns these types a size of 1, for convenience in cal-
	 culations with "void *" pointers and pointers to functions.

     -Wbad-function-cast (C only)
	 Warn  whenever a function call is cast to a non-matching type.  For ex-
	 ample, warn if "int malloc()" is cast to "anything *".

     -Wc++-compat
	 Warn about ISO C constructs that are outside of the  common  subset  of
	 ISO  C  and ISO C++, e.g. request for implicit conversion from "void *"
	 to a pointer to non-"void" type.

     -Wcast-qual
	 Warn whenever a pointer is cast so as to remove a type  qualifier  from
	 the  target  type.  For example, warn if a "const char *" is cast to an
	 ordinary "char *".

     -Wcast-align
	 Warn whenever a pointer is cast such that the required alignment of the
	 target is increased.  For example, warn if a "char *"	is  cast  to  an
	 "int  *"  on  machines  where	integers can only be accessed at two- or
	 four-byte boundaries.

     -Wwrite-strings
	 When compiling C, give string constants the type  "const  char[length]"
	 so  that copying the address of one into a non-"const" "char *" pointer
	 will get a warning; when compiling C++, warn about the deprecated  con-
	 version from string literals to "char *".  This warning, by default, is
	 enabled for C++ programs.  These warnings will help you find at compile
	 time code that can try to write into a string constant, but only if you
	 have  been  very careful about using "const" in declarations and proto-
	 types.  Otherwise, it will just be a nuisance; this is why we	did  not
	 make -Wall request these warnings.

     -Wconversion
	 Warn  if  a  prototype  causes a type conversion that is different from
	 what would happen to the same argument in the absence of  a  prototype.
	 This  includes  conversions  of fixed point to floating and vice versa,
	 and conversions changing the width or signedness of a fixed point argu-
	 ment except when the same as the default promotion.

	 Also, warn if a negative integer constant expression is implicitly con-
	 verted to an unsigned type.  For example, warn about the assignment  "x
	 =  -1"  if  "x" is unsigned.  But do not warn about explicit casts like
	 "(unsigned) -1".

     -Wsign-compare
	 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 -Wextra; to get the other warnings of
	 -Wextra without this warning, use -Wextra -Wno-sign-compare.

     -Waddress
	 Warn about suspicious uses of memory addresses. These include using the
	 address of a function	in  a  conditional  expression,  such  as  "void
	 func(void); if (func)", and comparisons against the memory address of a
	 string  literal,  such as "if (x == "abc")".  Such uses typically indi-
	 cate a programmer error: the address of a function always evaluates  to
	 true,	so their use in a conditional usually indicate that the program-
	 mer forgot the parentheses in a function call; and comparisons  against
	 string  literals result in unspecified behavior and are not portable in
	 C, so they usually indicate that the programmer intended to  use  "str-
	 cmp".	This warning is enabled by -Wall.

     -Waggregate-return
	 Warn  if  any functions that return structures or unions are defined or
	 called.  (In languages where you can return an array, this also elicits
	 a warning.)

     -Wno-attributes
	 Do not warn if an unexpected "__attribute__" is used, such as	unrecog-
	 nized	attributes, function attributes applied to variables, etc.  This
	 will not stop errors for incorrect use of supported attributes.

     -Wstrict-prototypes (C only)
	 Warn if a function is declared or defined without specifying the  argu-
	 ment  types.	(An old-style function definition is permitted without a
	 warning if preceded by  a  declaration  which	specifies  the	argument
	 types.)

     -Wold-style-definition (C only)
	 Warn  if  an old-style function definition is used.  A warning is given
	 even if there is a previous prototype.

     -Wmissing-prototypes (C only)
	 Warn if a global function is defined without a previous prototype  dec-
	 laration.   This  warning  is issued even if the definition itself pro-
	 vides a prototype.  The aim is to detect global functions that fail  to
	 be declared in header files.

     -Wmissing-declarations (C only)
	 Warn  if  a  global function is defined without a previous declaration.
	 Do so even if the definition itself provides a prototype.  Use this op-
	 tion to detect global functions that are not declared in header files.

     -Wmissing-field-initializers
	 Warn if a structure's initializer has some fields missing.   For  exam-
	 ple,  the  following  code would cause such a warning, because "x.h" is
	 implicitly zero:

		 struct s { int f, g, h; };
		 struct s x = { 3, 4 };

	 This option does not warn about designated initializers, so the follow-
	 ing modification would not trigger a warning:

		 struct s { int f, g, h; };
		 struct s x = { .f = 3, .g = 4 };

	 This warning is included in -Wextra.  To  get	other  -Wextra	warnings
	 without this one, use -Wextra -Wno-missing-field-initializers.

     -Wmissing-noreturn
	 Warn  about  functions  which	might be candidates for attribute "nore-
	 turn".  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 "noreturn" attribute,  otherwise  subtle  code
	 generation  bugs  could  be introduced.  You will not get a warning for
	 "main" in hosted C environments.

     -Wmissing-format-attribute
	 Warn about function pointers which might be candidates for "format" at-
	 tributes.  Note these are only possible candidates, not absolute  ones.
	 GCC will guess that function pointers with "format" attributes that are
	 used  in assignment, initialization, parameter passing or return state-
	 ments should have a corresponding "format" attribute in  the  resulting
	 type.	I.e. the left-hand side of the assignment or initialization, the
	 type  of  the	parameter variable, or the return type of the containing
	 function respectively should also have a "format"  attribute  to  avoid
	 the warning.

	 GCC will also warn about function definitions which might be candidates
	 for  "format"	attributes.   Again, these are only possible candidates.
	 GCC will guess that "format" attributes might be  appropriate	for  any
	 function  that  calls	a  function like "vprintf" or "vscanf", but this
	 might not always be the case, and some functions for which "format" at-
	 tributes are appropriate may not be detected.

     -Wno-multichar
	 Do not warn if a multicharacter constant  ('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.

     -Wnormalized=<none|id|nfc|nfkc>
	 In ISO C and ISO C++, two identifiers are different if they are differ-
	 ent sequences of characters.  However, sometimes when	characters  out-
	 side the basic ASCII character set are used, you can have two different
	 character  sequences  that  look the same.  To avoid confusion, the ISO
	 10646 standard sets out some normalization rules which when applied en-
	 sure that two sequences that look the same are turned into the same se-
	 quence.  GCC can warn you if you are using identifiers which  have  not
	 been normalized; this option controls that warning.

	 There	are  four  levels  of warning that GCC supports.  The default is
	 -Wnormalized=nfc, which warns about any identifier which is not in  the
	 ISO  10646  "C"  normalized form, NFC.  NFC is the recommended form for
	 most uses.

	 Unfortunately, there are some characters which ISO C and ISO C++  allow
	 in  identifiers  that	when turned into NFC aren't allowable as identi-
	 fiers.  That is, there's no way to use these symbols in portable ISO  C
	 or  C++  and  have  all  your identifiers in NFC.  -Wnormalized=id sup-
	 presses the warning for these characters.  It is hoped that future ver-
	 sions of the standards involved will correct this, which  is  why  this
	 option is not the default.

	 You  can switch the warning off for all characters by writing -Wnormal-
	 ized=none.  You would only want to do this if you were using some other
	 normalization scheme (like "D"), because otherwise you can easily  cre-
	 ate bugs that are literally impossible to see.

	 Some  characters in ISO 10646 have distinct meanings but look identical
	 in some fonts or display methodologies, especially once formatting  has
	 been  applied.   For instance "\u207F", "SUPERSCRIPT LATIN SMALL LETTER
	 N", will display just like a regular "n" which has been placed in a su-
	 perscript.  ISO 10646 defines the NFKC normalization scheme to  convert
	 all  these into a standard form as well, and GCC will warn if your code
	 is not in NFKC if you use -Wnormalized=nfkc.  This warning is	compara-
	 ble  to  warning  about every identifier that contains the letter O be-
	 cause it might be confused with the digit 0, and so is not the default,
	 but may be useful as a local coding convention if the programming envi-
	 ronment is unable to be fixed to display these characters distinctly.

     -Wno-deprecated-declarations
	 Do not warn about uses of functions, variables,  and  types  marked  as
	 deprecated by using the "deprecated" attribute.

     -Wno-overflow
	 Do not warn about compile-time overflow in constant expressions.

     -Woverride-init
	 Warn  if  an  initialized field without side effects is overridden when
	 using designated initializers.

	 This warning is included in -Wextra.  To  get	other  -Wextra	warnings
	 without this one, use -Wextra -Wno-override-init.

     -Wpacked
	 Warn  if  a structure is given the packed attribute, but the packed at-
	 tribute has no effect on the layout or size  of  the  structure.   Such
	 structures  may  be  mis-aligned  for little benefit.	For instance, in
	 this code, the variable "f.x" in "struct bar" will be	misaligned  even
	 though "struct bar" does not itself have the packed attribute:

		 struct foo {
		   int x;
		   char a, b, c, d;
		 } __attribute__((packed));
		 struct bar {
		   char z;
		   struct foo f;
		 };

     -Wpadded
	 Warn  if padding is included in a structure, either to align an element
	 of the structure or to align the whole structure.  Sometimes when  this
	 happens  it is possible to rearrange the fields of the structure to re-
	 duce the padding and so make the structure smaller.

     -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.

     -Wnested-externs (C only)
	 Warn if an "extern" declaration is encountered within a function.

     -Wunreachable-code
	 Warn if the compiler detects that code will never be executed.

	 This option is intended to warn when the compiler detects that at least
	 a whole line of source code will never be executed, because some condi-
	 tion  is  never satisfied or because it is after a procedure that never
	 returns.

	 It is possible for this option to produce a warning even  though  there
	 are  circumstances  under  which  part of the affected line can be exe-
	 cuted, so care should be  taken  when	removing  apparently-unreachable
	 code.

	 For  instance,  when a function is inlined, a warning may mean that the
	 line is unreachable in only one inlined copy of the function.

	 This option is not made part of -Wall because in a debugging version of
	 a program there is often substantial code which  checks  correct  func-
	 tioning  of the program and is, hopefully, unreachable because the pro-
	 gram does work.  Another common use of unreachable code is  to  provide
	 behavior which is selectable at compile-time.

     -Winline
	 Warn  if  a  function can not be inlined and it was declared as inline.
	 Even with this option, the compiler will not warn about failures to in-
	 line functions declared in system headers.

	 The compiler uses a variety of heuristics to determine whether  or  not
	 to inline a function.	For example, the compiler takes into account the
	 size  of the function being inlined and the amount of inlining that has
	 already been done in the current function.   Therefore,  seemingly  in-
	 significant  changes  in the source program can cause the warnings pro-
	 duced by -Winline to appear or disappear.

     -Wno-invalid-offsetof (C++ only)
	 Suppress warnings from applying the offsetof macro to a  non-POD  type.
	 According  to the 1998 ISO C++ standard, applying offsetof to a non-POD
	 type is undefined.  In existing C++ implementations, however,	offsetof
	 typically  gives  meaningful results even when applied to certain kinds
	 of non-POD types. (Such as a simple struct that fails to be a POD  type
	 only  by  virtue  of having a constructor.)  This flag is for users who
	 are aware that they are writing nonportable code and who have	deliber-
	 ately chosen to ignore the warning about it.

	 The  restrictions on offsetof may be relaxed in a future version of the
	 C++ standard.

     -Wno-int-to-pointer-cast (C only)
	 Suppress warnings from casts to pointer type of an integer of a differ-
	 ent size.

     -Wno-pointer-to-int-cast (C only)
	 Suppress warnings from casts from a pointer to an  integer  type  of  a
	 different size.

     -Winvalid-pch
	 Warn  if  a precompiled header is found in the search path but can't be
	 used.

     -Wlong-long
	 Warn if long long type is used.  This is default.  To inhibit the warn-
	 ing messages, use -Wno-long-long.  Flags -Wlong-long and -Wno-long-long
	 are taken into account only when -pedantic flag is used.

     -Wvariadic-macros
	 Warn if variadic macros are used in pedantic ISO C90 mode, or	the  GNU
	 alternate  syntax  when in pedantic ISO C99 mode.  This is default.  To
	 inhibit the warning messages, use -Wno-variadic-macros.

     -Wvolatile-register-var
	 Warn if a register variable is declared volatile.  The  volatile  modi-
	 fier does not inhibit all optimizations that may eliminate reads and/or
	 writes to register variables.

     -Wdisabled-optimization
	 Warn  if  a requested optimization pass is disabled.  This warning does
	 not generally indicate that there is anything wrong with your code;  it
	 merely  indicates  that GCC's optimizers were unable to handle the code
	 effectively.  Often, the problem is that your code is too  big  or  too
	 complex; GCC will refuse to optimize programs when the optimization it-
	 self is likely to take inordinate amounts of time.

     -Wpointer-sign
	 Warn  for pointer argument passing or assignment with different signed-
	 ness.	This option is only supported for C.  It is implied by -Wall and
	 by -pedantic, which can be disabled with -Wno-pointer-sign.

     -Werror
	 Make all warnings into errors.

     -Werror=
	 Make the specified warning into an errors.  The specifier for a warning
	 is appended, for example -Werror=switch turns the  warnings  controlled
	 by -Wswitch into errors.  This switch takes a negative form, to be used
	 to  negate -Werror for specific warnings, for example -Wno-error=switch
	 makes -Wswitch warnings not be errors, even when -Werror is in  effect.
	 You  can use the -fdiagnostics-show-option option to have each control-
	 lable warning amended with the option which controls it,  to  determine
	 what to use with this option.

	 Note that specifying -Werror=foo automatically implies -Wfoo.	However,
	 -Wno-error=foo does not imply anything.

     -Wstack-protector
	 This  option is only active when -fstack-protector is active.	It warns
	 about functions that will not be protected against stack smashing.

     -Woverlength-strings
	 Warn about string constants which are longer than the "minimum maximum"
	 length specified in the C standard.  Modern compilers	generally  allow
	 string  constants  which  are	much  longer than the standard's minimum
	 limit, but very portable programs should avoid using longer strings.

	 The limit applies after string constant  concatenation,  and  does  not
	 count	the trailing NUL.  In C89, the limit was 509 characters; in C99,
	 it was raised to 4095.  C++98 does not specify a normative minimum max-
	 imum, so we do not diagnose overlength strings in C++.

	 This  option  is  implied  by	-pedantic,  and  can  be  disabled  with
	 -Wno-overlength-strings.

     Options for Debugging Your Program or GCC

     GCC  has  various	special  options that are used for debugging either your
     program or GCC:

     -g  Produce debugging information in the operating system's  native  format
	 (stabs, COFF, XCOFF, or DWARF 2).  GDB can work with this debugging in-
	 formation.

	 On  most  systems that use stabs format, -g enables use of extra debug-
	 ging information that only GDB can use; this  extra  information  makes
	 debugging  work  better  in  GDB but will probably make other debuggers
	 crash or refuse to read the program.  If you want to control  for  cer-
	 tain  whether to generate the extra information, use -gstabs+, -gstabs,
	 -gxcoff+, -gxcoff, or -gvms (see below).

	 GCC allows you to use -g with -O.  The  shortcuts  taken  by  optimized
	 code  may  occasionally  produce surprising results: some variables you
	 declared may not exist at all; flow of control may briefly  move  where
	 you did not expect it; some statements may not be executed because they
	 compute  constant  results  or  their values were already at hand; some
	 statements may execute in different places because they were moved  out
	 of loops.

	 Nevertheless  it proves possible to debug optimized output.  This makes
	 it reasonable to use the optimizer for programs that might have bugs.

	 The following options are useful when GCC is generated with  the  capa-
	 bility for more than one debugging format.

     -ggdb
	 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.

     -gstabs
	 Produce debugging information in stabs format (if that  is  supported),
	 without  GDB  extensions.   This  is the format used by DBX on most BSD
	 systems.  On MIPS, Alpha and System V Release	4  systems  this  option
	 produces  stabs debugging output which is not understood by DBX or SDB.
	 On System V Release 4 systems this option requires the GNU assembler.

     -feliminate-unused-debug-symbols
	 Produce debugging information in stabs format (if that  is  supported),
	 for only symbols that are actually used.

     -femit-class-debug-always
	 Instead  of  emitting debugging information for a C++ class in only one
	 object file, emit it in all object files using the class.  This  option
	 should  be  used  only with debuggers that are unable to handle the way
	 GCC normally emits debugging information for classes because using this
	 option will increase the size of debugging information by as much as  a
	 factor of two.

     -gstabs+
	 Produce  debugging  information in stabs format (if that is supported),
	 using GNU extensions understood only by the GNU  debugger  (GDB).   The
	 use  of  these  extensions  is  likely to make other debuggers crash or
	 refuse to read the program.

     -gcoff
	 Produce debugging information in COFF format (if  that  is  supported).
	 This is the format used by SDB on most System V systems prior to System
	 V Release 4.

     -gxcoff
	 Produce  debugging  information in XCOFF format (if that is supported).
	 This is the format used by the DBX debugger on IBM RS/6000 systems.

     -gxcoff+
	 Produce debugging information in XCOFF format (if that  is  supported),
	 using	GNU  extensions  understood only by the GNU debugger (GDB).  The
	 use of these extensions is likely to  make  other  debuggers  crash  or
	 refuse to read the program, and may cause assemblers other than the GNU
	 assembler (GAS) to fail with an error.

     -gdwarf-2
	 Produce  debugging  information  in  DWARF version 2 format (if that is
	 supported).  This is the format used by DBX on IRIX 6.  With  this  op-
	 tion,	GCC  uses features of DWARF version 3 when they are useful; ver-
	 sion 3 is upward compatible with version 2, but may still  cause  prob-
	 lems for older debuggers.

     -gvms
	 Produce  debugging  information  in  VMS  debug format (if that is sup-
	 ported).  This is the format used by DEBUG on VMS systems.

     -glevel
     -ggdblevel
     -gstabslevel
     -gcofflevel
     -gxcofflevel
     -gvmslevel
	 Request debugging information and also use level to  specify  how  much
	 information.  The default level is 2.

	 Level	1  produces minimal information, enough for making backtraces in
	 parts of the program that you don't plan to debug.  This  includes  de-
	 scriptions  of  functions  and  external  variables, but no information
	 about local variables and no line numbers.

	 Level 3 includes extra information, such as all the  macro  definitions
	 present  in  the  program.  Some debuggers support macro expansion when
	 you use -g3.

	 -gdwarf-2 does not accept a concatenated debug level, because GCC  used
	 to  support  an option -gdwarf that meant to generate debug information
	 in version 1 of the DWARF format (which is very different from  version
	 2),  and  it  would have been too confusing.  That debug format is long
	 obsolete, but the option cannot be changed now.  Instead use  an  addi-
	 tional -glevel option to change the debug level for DWARF2.

     -feliminate-dwarf2-dups
	 Compress  DWARF2 debugging information by eliminating duplicated infor-
	 mation about each symbol.  This option only makes sense when generating
	 DWARF2 debugging information with -gdwarf-2.

     -p  Generate extra code to  write	profile  information  suitable	for  the
	 analysis  program  prof.   You  must use this option when compiling the
	 source files you want data about, and you must also use it  when  link-
	 ing.

     -pg Generate  extra  code	to  write  profile  information suitable for the
	 analysis program gprof.  You must use this option  when  compiling  the
	 source  files	you want data about, and you must also use it when link-
	 ing.

     -Q  Makes the compiler print out each function name as it is compiled,  and
	 print some statistics about each pass when it finishes.

     -ftime-report
	 Makes	the  compiler  print  some statistics about the time consumed by
	 each pass when it finishes.

     -fmem-report
	 Makes the compiler print some statistics about permanent memory alloca-
	 tion when it finishes.

     -fprofile-arcs
	 Add code so that program flow arcs are instrumented.  During  execution
	 the program records how many times each branch and call is executed and
	 how many times it is taken or returns.  When the compiled program exits
	 it  saves this data to a file called auxname.gcda for each source file.
	 The data may be used for profile-directed optimizations (-fbranch-prob-
	 abilities), or for test coverage analysis (-ftest-coverage).  Each  ob-
	 ject  file's  auxname is generated from the name of the output file, if
	 explicitly specified and it is not the final executable,  otherwise  it
	 is  the  basename  of the source file.  In both cases any suffix is re-
	 moved (e.g. foo.gcda for input file dir/foo.c, or dir/foo.gcda for out-
	 put file specified as -o dir/foo.o).

     --coverage
	 This option is used to compile and link code instrumented for	coverage
	 analysis.   The  option is a synonym for -fprofile-arcs -ftest-coverage
	 (when compiling) and -lgcov (when linking).  See the documentation  for
	 those options for more details.

	 *   Compile  the source files with -fprofile-arcs plus optimization and
	     code generation options.  For test coverage analysis, use the addi-
	     tional -ftest-coverage option.  You do not need  to  profile  every
	     source file in a program.

	 *   Link  your  object  files with -lgcov or -fprofile-arcs (the latter
	     implies the former).

	 *   Run the program on a representative workload to  generate	the  arc
	     profile  information.   This  may	be repeated any number of times.
	     You can run concurrent instances of your program, and provided that
	     the file system supports locking, the data files will be  correctly
	     updated.	Also  "fork"  calls  are  detected and correctly handled
	     (double counting will not happen).

	 *   For profile-directed optimizations, compile the source files  again
	     with  the	same  optimization  and  code  generation  options  plus
	     -fbranch-probabilities.

	 *   For test coverage analysis, use gcov to produce human readable  in-
	     formation	from the .gcno and .gcda files.  Refer to the gcov docu-
	     mentation for further information.

	 With -fprofile-arcs, for each function of your program  GCC  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 ex-
	 ecuted.   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.

     -ftest-coverage
	 Produce  a  notes  file  that the gcov code-coverage utility can use to
	 show program coverage.  Each source file's note  file	is  called  aux-
	 name.gcno.   Refer to the -fprofile-arcs option above for a description
	 of auxname and instructions on how  to  generate  test  coverage  data.
	 Coverage  data  will match the source files more closely, if you do not
	 optimize.

     -dletters
     -fdump-rtl-pass
	 Says to make debugging dumps during compilation at times  specified  by
	 letters.    This is used for debugging the RTL-based passes of the com-
	 piler.   The  file  names for most of the dumps are made by appending a
	 pass number and a word to the dumpname.  dumpname is generated from the
	 name of the output file, if explicitly specified and it is not an  exe-
	 cutable, otherwise it is the basename of the source file.

	 Most  debug  dumps can be enabled either passing a letter to the -d op-
	 tion, or with a long -fdump-rtl switch; here are the  possible  letters
	 for use in letters and pass, and their meanings:

	 -dA Annotate the assembler output with miscellaneous debugging informa-
	     tion.

	 -dB
	 -fdump-rtl-bbro
	     Dump after block reordering, to file.148r.bbro.

	 -dc
	 -fdump-rtl-combine
	     Dump after instruction combination, to the file file.129r.combine.

	 -dC
	 -fdump-rtl-ce1
	 -fdump-rtl-ce2
	     -dC  and  -fdump-rtl-ce1  enable dumping after the first if conver-
	     sion, to the file file.117r.ce1.	-dC  and  -fdump-rtl-ce2  enable
	     dumping after the second if conversion, to the file file.130r.ce2.

	 -dd
	 -fdump-rtl-btl
	 -fdump-rtl-dbr
	     -dd  and -fdump-rtl-btl enable dumping after branch target load op-
	     timization, to file.31.btl.  -dd and -fdump-rtl-dbr enable  dumping
	     after delayed branch scheduling, to file.36.dbr.

	 -dD Dump  all	macro definitions, at the end of preprocessing, in addi-
	     tion to normal output.

	 -dE
	 -fdump-rtl-ce3
	     Dump after the third if conversion, to file.146r.ce3.

	 -df
	 -fdump-rtl-cfg
	 -fdump-rtl-life
	     -df and -fdump-rtl-cfg enable dumping after control and  data  flow
	     analysis,	to file.116r.cfg.  -df and -fdump-rtl-cfg enable dumping
	     dump after life analysis, to file.128r.life1 and file.135r.life2.

	 -dg
	 -fdump-rtl-greg
	     Dump after global register allocation, to file.139r.greg.

	 -dG
	 -fdump-rtl-gcse
	 -fdump-rtl-bypass
	     -dG   and	 -fdump-rtl-gcse   enable   dumping   after   GCSE,   to
	     file.114r.gcse.   -dG  and  -fdump-rtl-bypass  enable dumping after
	     jump bypassing and control flow optimizations, to file.115r.bypass.

	 -dh
	 -fdump-rtl-eh
	     Dump after finalization of EH handling code, to file.02.eh.

	 -di
	 -fdump-rtl-sibling
	     Dump after sibling call optimizations, to file.106r.sibling.

	 -dj
	 -fdump-rtl-jump
	     Dump after the first jump optimization, to file.112r.jump.

	 -dk
	 -fdump-rtl-stack
	     Dump after conversion from registers to stack, to file.152r.stack.

	 -dl
	 -fdump-rtl-lreg
	     Dump after local register allocation, to file.138r.lreg.

	 -dL
	 -fdump-rtl-loop2
	     -dL and -fdump-rtl-loop2 enable dumping after the loop optimization
	     pass, to file.119r.loop2, file.120r.loop2_init, file.121r.loop2_in-
	     variant, and file.125r.loop2_done.

	 -dm
	 -fdump-rtl-sms
	     Dump after modulo scheduling, to file.136r.sms.

	 -dM
	 -fdump-rtl-mach
	     Dump after performing the machine dependent reorganization pass, to
	     file.155r.mach.

	 -dn
	 -fdump-rtl-rnreg
	     Dump after register renumbering, to file.147r.rnreg.

	 -dN
	 -fdump-rtl-regmove
	     Dump after the register move pass, to file.132r.regmove.

	 -do
	 -fdump-rtl-postreload
	     Dump after post-reload optimizations, to file.24.postreload.

	 -dr
	 -fdump-rtl-expand
	     Dump after RTL generation, to file.104r.expand.

	 -dR
	 -fdump-rtl-sched2
	     Dump after the second scheduling pass, to file.150r.sched2.

	 -ds
	 -fdump-rtl-cse
	     Dump after CSE (including the jump optimization that sometimes fol-
	     lows CSE), to file.113r.cse.

	 -dS
	 -fdump-rtl-sched
	     Dump after the first scheduling pass, to file.21.sched.

	 -dt
	 -fdump-rtl-cse2
	     Dump after the second CSE pass  (including  the  jump  optimization
	     that sometimes follows CSE), to file.127r.cse2.

	 -dT
	 -fdump-rtl-tracer
	     Dump after running tracer, to file.118r.tracer.

	 -dV
	 -fdump-rtl-vpt
	 -fdump-rtl-vartrack
	     -dV  and  -fdump-rtl-vpt  enable  dumping	after  the value profile
	     transformations, to file.10.vpt.  -dV and	-fdump-rtl-vartrack  en-
	     able dumping after variable tracking, to file.154r.vartrack.

	 -dw
	 -fdump-rtl-flow2
	     Dump after the second flow pass, to file.142r.flow2.

	 -dz
	 -fdump-rtl-peephole2
	     Dump after the peephole pass, to file.145r.peephole2.

	 -dZ
	 -fdump-rtl-web
	     Dump after live range splitting, to file.126r.web.

	 -da
	 -fdump-rtl-all
	     Produce all the dumps listed above.

	 -dH Produce a core dump whenever an error occurs.

	 -dm Print  statistics	on memory usage, at the end of the run, to stan-
	     dard error.

	 -dp Annotate the assembler output with a comment indicating which  pat-
	     tern  and	alternative was used.  The length of each instruction is
	     also printed.

	 -dP Dump the RTL in the assembler output as a comment before  each  in-
	     struction.  Also turns on -dp annotation.

	 -dv For  each	of  the  other	indicated  dump files (either with -d or
	     -fdump-rtl-pass), dump a representation of the control  flow  graph
	     suitable for viewing with VCG to file.pass.vcg.

	 -dx Just  generate RTL for a function instead of compiling it.  Usually
	     used with r (-fdump-rtl-expand).

	 -dy Dump debugging information during parsing, to standard error.

     -fdump-noaddr
	 When doing debugging dumps (see -d option above), suppress address out-
	 put.  This makes it more feasible to use diff on  debugging  dumps  for
	 compiler  invocations with different compiler binaries and/or different
	 text / bss / data / heap / stack / dso start locations.

     -fdump-unnumbered
	 When doing debugging dumps (see -d option above), suppress  instruction
	 numbers,  line number note and address output.  This makes it more fea-
	 sible to use diff on debugging dumps for compiler invocations with dif-
	 ferent options, in particular with and without -g.

     -fdump-translation-unit (C++ only)
     -fdump-translation-unit-options (C++ only)
	 Dump a representation of the tree structure for the entire  translation
	 unit  to  a file.  The file name is made by appending .tu to the source
	 file name.  If the -options form is used, options controls the  details
	 of the dump as described for the -fdump-tree options.

     -fdump-class-hierarchy (C++ only)
     -fdump-class-hierarchy-options (C++ only)
	 Dump  a  representation  of each class's hierarchy and virtual function
	 table layout to a file.  The file name is made by appending  .class  to
	 the  source  file name.  If the -options form is used, options controls
	 the details of the dump as described for the -fdump-tree options.

     -fdump-ipa-switch
	 Control the dumping at various stages of inter-procedural analysis lan-
	 guage tree to a file.	The file name is generated by appending a switch
	 specific suffix to the source file name.  The following dumps are  pos-
	 sible:

	 all Enables  all  inter-procedural  analysis  dumps; currently the only
	     produced dump is the cgraph dump.

	 cgraph
	     Dumps information about call-graph  optimization,	unused	function
	     removal, and inlining decisions.

     -fdump-tree-switch
     -fdump-tree-switch-options
	 Control  the  dumping	at various stages of processing the intermediate
	 language tree to a file.  The file name is  generated	by  appending  a
	 switch  specific  suffix to the source file name.  If the -options form
	 is used, options is a list of - separated options that control the  de-
	 tails	of the dump.  Not all options are applicable to all dumps, those
	 which are not meaningful will be ignored.  The  following  options  are
	 available

	 address
	     Print  the address of each node.  Usually this is not meaningful as
	     it changes according to the environment and source file.  Its  pri-
	     mary use is for tying up a dump file with a debug environment.

	 slimInhibit  dumping of members of a scope or body of a function merely
	     because that scope has been reached.  Only  dump  such  items  when
	     they  are	directly  reachable  by  some  other path.  When dumping
	     pretty-printed trees, this option inhibits dumping  the  bodies  of
	     control structures.

	 raw Print  a  raw  representation  of	the tree.  By default, trees are
	     pretty-printed into a C-like representation.

	 details
	     Enable more detailed dumps (not honored by every dump option).

	 stats
	     Enable dumping various statistics about the pass  (not  honored  by
	     every dump option).

	 blocks
	     Enable showing basic block boundaries (disabled in raw dumps).

	 vopsEnable showing virtual operands for every statement.

	 lineno
	     Enable showing line numbers for statements.

	 uid Enable showing the unique ID ("DECL_UID") for each variable.

	 all Turn on all options, except raw, slim and lineno.

	 The following tree dumps are possible:

	 original
	     Dump before any tree based optimization, to file.original.

	 optimized
	     Dump after all tree based optimization, to file.optimized.

	 inlined
	     Dump after function inlining, to file.inlined.

	 gimple
	     Dump  each  function  before and after the gimplification pass to a
	     file.  The file name is made by appending	.gimple  to  the  source
	     file name.

	 cfg Dump  the	control flow graph of each function to a file.	The file
	     name is made by appending .cfg to the source file name.

	 vcg Dump the control flow graph of each function to a file in VCG  for-
	     mat.   The  file  name is made by appending .vcg to the source file
	     name.  Note that if the file contains more than one  function,  the
	     generated	file  cannot  be used directly by VCG.	You will need to
	     cut and paste each function's graph  into	its  own  separate  file
	     first.

	 ch  Dump  each  function  after copying loop headers.	The file name is
	     made by appending .ch to the source file name.

	 ssa Dump SSA related information to a file.  The file name is	made  by
	     appending .ssa to the source file name.

	 salias
	     Dump  structure aliasing variable information to a file.  This file
	     name is made by appending .salias to the source file name.

	 alias
	     Dump aliasing information for each function.  The file name is made
	     by appending .alias to the source file name.

	 ccp Dump each function after CCP.  The file name is made  by  appending
	     .ccp to the source file name.

	 storeccp
	     Dump  each  function after STORE-CCP.  The file name is made by ap-
	     pending .storeccp to the source file name.

	 pre Dump trees after partial redundancy elimination.  The file name  is
	     made by appending .pre to the source file name.

	 fre Dump  trees  after  full  redundancy elimination.	The file name is
	     made by appending .fre to the source file name.

	 copyprop
	     Dump trees after copy propagation.  The file name is  made  by  ap-
	     pending .copyprop to the source file name.

	 store_copyprop
	     Dump  trees after store copy-propagation.	The file name is made by
	     appending .store_copyprop to the source file name.

	 dce Dump each function after dead code elimination.  The file	name  is
	     made by appending .dce to the source file name.

	 mudflap
	     Dump  each function after adding mudflap instrumentation.	The file
	     name is made by appending .mudflap to the source file name.

	 sra Dump each function after performing scalar  replacement  of  aggre-
	     gates.   The file name is made by appending .sra to the source file
	     name.

	 sinkDump each function after performing code sinking.	The file name is
	     made by appending .sink to the source file name.

	 dom Dump each function after  applying  dominator  tree  optimizations.
	     The file name is made by appending .dom to the source file name.

	 dse Dump each function after applying dead store elimination.	The file
	     name is made by appending .dse to the source file name.

	 phiopt
	     Dump  each  function  after  optimizing PHI nodes into straightline
	     code.  The file name is made by appending	.phiopt  to  the  source
	     file name.

	 forwprop
	     Dump  each function after forward propagating single use variables.
	     The file name is made by appending .forwprop  to  the  source  file
	     name.

	 copyrename
	     Dump  each  function  after  applying the copy rename optimization.
	     The file name is made by appending .copyrename to the  source  file
	     name.

	 nrv Dump  each function after applying the named return value optimiza-
	     tion on generic trees.  The file name is made by appending .nrv  to
	     the source file name.

	 vectDump each function after applying vectorization of loops.	The file
	     name is made by appending .vect to the source file name.

	 vrp Dump  each  function after Value Range Propagation (VRP).	The file
	     name is made by appending .vrp to the source file name.

	 all Enable all the available tree dumps with the flags provided in this
	     option.

     -ftree-vectorizer-verbose=n
	 This option controls the amount  of  debugging  output  the  vectorizer
	 prints.    This  information  is  written  to	standard  error,  unless
	 -fdump-tree-all or -fdump-tree-vect is specified, in which case  it  is
	 output  to  the  usual dump listing file, .vect.  For n=0 no diagnostic
	 information is reported.  If n=1 the vectorizer reports each loop  that
	 got  vectorized, and the total number of loops that got vectorized.  If
	 n=2 the vectorizer also reports non-vectorized loops  that  passed  the
	 first	analysis  phase  (vect_analyze_loop_form)  - i.e. countable, in-
	 ner-most, single-bb, single-entry/exit loops.	This is  the  same  ver-
	 bosity level that -fdump-tree-vect-stats uses.  Higher verbosity levels
	 mean  either  more  information  dumped for each reported loop, or same
	 amount of information reported for more loops: If  n=3,  alignment  re-
	 lated information is added to the reports.  If n=4, data-references re-
	 lated	information (e.g. memory dependences, memory access-patterns) is
	 added to the reports.	If n=5, the vectorizer reports also  non-vector-
	 ized  inner-most loops that did not pass the first analysis phase (i.e.
	 may not be countable, or may have complicated control-flow).	If  n=6,
	 the  vectorizer reports also non-vectorized nested loops.  For n=7, all
	 the information the vectorizer generates during its analysis and trans-
	 formation  is	reported.   This  is  the  same  verbosity  level   that
	 -fdump-tree-vect-details uses.

     -frandom-seed=string
	 This  option  provides a seed that GCC uses when it would otherwise use
	 random numbers.  It is used to generate certain symbol names that  have
	 to  be  different  in	every  compiled  file.	It is also used to place
	 unique stamps in coverage data files and the object files that  produce
	 them.	 You  can  use	the -frandom-seed option to produce reproducibly
	 identical object files.

	 The string should be different for every file you compile.

     -fsched-verbose=n
	 On targets that use instruction scheduling, this  option  controls  the
	 amount  of  debugging output the scheduler prints.  This information is
	 written to standard error, unless -dS or -dR  is  specified,  in  which
	 case it is output to the usual dump listing file, .sched or .sched2 re-
	 spectively.   However	for  n	greater  than nine, the output is always
	 printed to standard error.

	 For n greater than zero, -fsched-verbose outputs the  same  information
	 as -dRS.  For n greater than one, it also output basic block probabili-
	 ties,	detailed  ready  list  information  and  unit/insn  info.  For n
	 greater than two, it includes RTL at abort point, control-flow and  re-
	 gions	info.  And for n over four, -fsched-verbose also includes depen-
	 dence info.

     -save-temps
	 Store the usual "temporary" intermediate files permanently; place  them
	 in the current directory and name them based on the source file.  Thus,
	 compiling  foo.c  with  -c  -save-temps  would  produce files foo.i and
	 foo.s, as well as foo.o.  This creates a preprocessed foo.i output file
	 even though the compiler now normally uses an integrated preprocessor.

	 When used in combination with the -x command line  option,  -save-temps
	 is  sensible enough to avoid over writing an input source file with the
	 same extension as an intermediate file.  The corresponding intermediate
	 file  may  be	obtained  by  renaming	the  source  file  before  using
	 -save-temps.

     -time
	 Report  the  CPU  time  taken by each subprocess in the compilation se-
	 quence.  For C source files, this is the compiler proper and  assembler
	 (plus the linker if linking is done).	The output looks like this:

		 # cc1 0.12 0.01
		 # as 0.00 0.01

	 The  first  number  on each line is the "user time", that is time spent
	 executing the program itself.	The second number is "system time", time
	 spent executing operating system routines on  behalf  of  the	program.
	 Both numbers are in seconds.

     -fvar-tracking
	 Run  variable tracking pass.  It computes where variables are stored at
	 each position in code.  Better debugging information is then  generated
	 (if the debugging information format supports this information).

	 It  is  enabled  by  default when compiling with optimization (-Os, -O,
	 -O2, ...), debugging information (-g) and the debug  info  format  sup-
	 ports it.

     -print-file-name=library
	 Print	the full absolute name of the library file library that would be
	 used when linking---and don't do anything else.  With this option,  GCC
	 does not compile or link anything; it just prints the file name.

     -print-multi-directory
	 Print	the directory name corresponding to the multilib selected by any
	 other switches present in the command line.  This directory is supposed
	 to exist in GCC_EXEC_PREFIX.

     -print-multi-lib
	 Print the mapping from multilib directory names  to  compiler	switches
	 that enable them.  The directory name is separated from the switches by
	 ;,  and  each	switch starts with an @} instead of the @samp{-, without
	 spaces between multiple switches.  This is supposed to ease  shell-pro-
	 cessing.

     -print-prog-name=program
	 Like -print-file-name, but searches for a program such as cpp.

     -print-libgcc-file-name
	 Same as -print-file-name=libgcc.a.

	 This is useful when you use -nostdlib or -nodefaultlibs but you do want
	 to link with libgcc.a.  You can do

		 gcc -nostdlib <files>... `gcc -print-libgcc-file-name`

     -print-search-dirs
	 Print	the  name of the configured installation directory and a list of
	 program and library directories gcc will search---and don't do anything
	 else.

	 This is useful when gcc prints the error message installation	problem,
	 cannot  exec  cpp0: No such file or directory.  To resolve this you ei-
	 ther need to put cpp0 and the other compiler components where	gcc  ex-
	 pects	 to   find  them,  or  you  can  set  the  environment	variable
	 GCC_EXEC_PREFIX to the directory where you installed them.  Don't  for-
	 get the trailing /.

     -dumpmachine
	 Print	   the	   compiler's	  target     machine	(for	example,
	 i686-pc-linux-gnu)---and don't do anything else.

     -dumpversion
	 Print the compiler version (for example, 3.0)---and don't  do	anything
	 else.

     -dumpspecs
	 Print	the  compiler's  built-in  specs---and	don't  do anything else.
	 (This is used when GCC itself is being built.)

     -feliminate-unused-debug-types
	 Normally, when producing DWARF2 output, GCC will emit debugging  infor-
	 mation  for  all  types  declared  in a compilation unit, regardless of
	 whether or not they are actually used in that compilation unit.   Some-
	 times	this  is useful, such as if, in the debugger, you want to cast a
	 value to a type that is not actually used in your program (but  is  de-
	 clared).   More often, however, this results in a significant amount of
	 wasted space.	With this option, GCC will avoid producing debug  symbol
	 output  for  types  that are nowhere used in the source file being com-
	 piled.

     Options That Control Optimization

     These options control various sorts of optimizations.

     Without any optimization option, the compiler's goal is to reduce the  cost
     of  compilation and to make debugging produce the expected results.  State-
     ments are independent: if you stop the program with  a  breakpoint  between
     statements,  you  can then assign a new value to any variable or change the
     program counter to any other statement in the function and get exactly  the
     results you would expect from the source code.

     Turning  on  optimization	flags  makes the compiler attempt to improve the
     performance and/or code size at the expense of compilation time and  possi-
     bly the ability to debug the program.

     The  compiler  performs  optimization  based on the knowledge it has of the
     program.  Optimization levels -O and above, in particular, enable	unit-at-
     a-time  mode, which allows the compiler to consider information gained from
     later functions in the file when compiling a function.  Compiling	multiple
     files  at	once  to  a single output file in unit-at-a-time mode allows the
     compiler to use information gained from all of  the  files  when  compiling
     each of them.

     Not  all  optimizations  are controlled directly by a flag.  Only optimiza-
     tions that have a flag are listed.

     -O
     -O1 Optimize.  Optimizing compilation takes somewhat more time, and  a  lot
	 more memory for a large function.

	 With  -O,  the  compiler  tries to reduce code size and execution time,
	 without performing any optimizations that take a great deal of compila-
	 tion time.

	 -O  turns  on	the  following	optimization  flags:  -fdefer-pop  -fde-
	 layed-branch  -fguess-branch-probability -fcprop-registers -fif-conver-
	 sion  -fif-conversion2  -ftree-ccp   -ftree-dce   -ftree-dominator-opts
	 -ftree-dse    -ftree-ter    -ftree-lrs   -ftree-sra   -ftree-copyrename
	 -ftree-fre -ftree-ch -funit-at-a-time -fmerge-constants

	 -O also turns on -fomit-frame-pointer on machines where doing	so  does
	 not interfere with debugging.

     -O2 Optimize  even  more.	 GCC performs nearly all supported optimizations
	 that do not involve a space-speed tradeoff.  The compiler does not per-
	 form loop unrolling or function inlining when you specify -O2.  As com-
	 pared to -O, this option increases both compilation time and  the  per-
	 formance of the generated code.

	 -O2  turns on all optimization flags specified by -O.	It also turns on
	 the following optimization flags: -fthread-jumps -fcrossjumping -fopti-
	 mize-sibling-calls   -fcse-follow-jumps     -fcse-skip-blocks	  -fgcse
	 -fgcse-lm	  -fexpensive-optimizations	  -frerun-cse-after-loop
	 -fcaller-saves    -fpeephole2	  -fschedule-insns     -fschedule-insns2
	 -fsched-interblock	 -fsched-spec	  -fregmove    -fstrict-aliasing
	 -fstrict-overflow -fdelete-null-pointer-checks -freorder-blocks   -fre-
	 order-functions    -falign-functions	  -falign-jumps    -falign-loops
	 -falign-labels -ftree-vrp -ftree-pre

	 Please note the warning under -fgcse about  invoking  -O2  on	programs
	 that use computed gotos.

	 -O2  doesn't turn on -ftree-vrp for the Ada compiler.	This option must
	 be explicitly specified on the command line to be enabled for	the  Ada
	 compiler.

     -O3 Optimize yet more.  -O3 turns on all optimizations specified by -O2 and
	 also  turns  on the -finline-functions, -funswitch-loops and -fgcse-af-
	 ter-reload options.

     -O0 Do not optimize.  This is the default.

     -Os Optimize for size.  -Os enables all -O2 optimizations that do not typi-
	 cally increase code size.  It also performs further  optimizations  de-
	 signed to reduce code size.

	 -Os   disables  the  following  optimization  flags:  -falign-functions
	 -falign-jumps	-falign-loops  -falign-labels	-freorder-blocks   -fre-
	 order-blocks-and-partition			  -fprefetch-loop-arrays
	 -ftree-vect-loop-version

	 If you use multiple -O options, with or without level numbers, the last
	 such option is the one that is effective.

     Options of the form -fflag specify machine-independent flags.   Most  flags
     have  both positive and negative forms; the negative form of -ffoo would be
     -fno-foo.	In the table below, only one of the forms  is  listed---the  one
     you typically will use.  You can figure out the other form by either remov-
     ing no- or adding it.

     The  following options control specific optimizations.  They are either ac-
     tivated by -O options or are related to ones that are.   You  can	use  the
     following flags in the rare cases when "fine-tuning" of optimizations to be
     performed is desired.

     -fno-default-inline
	 Do  not make member functions inline by default merely because they are
	 defined inside the class scope (C++ only).  Otherwise, when you specify
	 -O, member functions defined inside class scope are compiled inline  by
	 default;  i.e.,  you  don't  need  to add inline in front of the member
	 function name.

     -fno-defer-pop
	 Always pop the arguments to each function call as soon as that function
	 returns.  For machines which must pop arguments after a function  call,
	 the  compiler	normally lets arguments accumulate on the stack for sev-
	 eral function calls and pops them all at once.

	 Disabled at levels -O, -O2, -O3, -Os.

     -fforce-mem
	 Force memory operands to be copied into registers before  doing  arith-
	 metic	on  them.  This produces better code by making all memory refer-
	 ences potential common subexpressions.  When they are not common subex-
	 pressions, instruction combination should eliminate the separate regis-
	 ter-load. This option is now a nop and will be removed in 4.3.

     -fforce-addr
	 Force memory address constants to be copied into registers before doing
	 arithmetic on them.

     -fomit-frame-pointer
	 Don't keep the frame pointer in a register  for  functions  that  don't
	 need  one.   This  avoids  the instructions to save, set up and restore
	 frame pointers; it also makes an extra register available in many func-
	 tions.  It also makes debugging impossible on some machines.

	 On some machines, such as the VAX, this flag has no effect, because the
	 standard calling sequence automatically handles the frame  pointer  and
	 nothing  is saved by pretending it doesn't exist.  The machine-descrip-
	 tion macro "FRAME_POINTER_REQUIRED" controls whether a  target  machine
	 supports this flag.

	 Enabled at levels -O, -O2, -O3, -Os.

     -foptimize-sibling-calls
	 Optimize sibling and tail recursive calls.

	 Enabled at levels -O2, -O3, -Os.

     -fno-inline
	 Don't	pay  attention to the "inline" keyword.  Normally this option is
	 used to keep the compiler from expanding any  functions  inline.   Note
	 that if you are not optimizing, no functions can be expanded inline.

     -finline-functions
	 Integrate  all  simple  functions  into  their  callers.   The compiler
	 heuristically decides which functions are simple enough to be worth in-
	 tegrating in this way.

	 If all calls to a given function are integrated, and  the  function  is
	 declared  "static",  then the function is normally not output as assem-
	 bler code in its own right.

	 Enabled at level -O3.

     -finline-functions-called-once
	 Consider all "static" functions called once  for  inlining  into  their
	 caller  even  if  they  are  not marked "inline".  If a call to a given
	 function is integrated, then the function is not  output  as  assembler
	 code in its own right.

	 Enabled if -funit-at-a-time is enabled.

     -fearly-inlining
	 Inline  functions  marked  by	"always_inline" and functions whose body
	 seems smaller than the function call overhead early before doing -fpro-
	 file-generate instrumentation and real inlining pass.	Doing  so  makes
	 profiling significantly cheaper and usually inlining faster on programs
	 having large chains of nested wrapper functions.

	 Enabled by default.

     -finline-limit=n
	 By default, GCC limits the size of functions that can be inlined.  This
	 flag allows the control of this limit for functions that are explicitly
	 marked  as  inline  (i.e.,  marked  with  the inline keyword or defined
	 within the class definition in c++).  n is the size of  functions  that
	 can be inlined in number of pseudo instructions (not counting parameter
	 handling).   The  default value of n is 600.  Increasing this value can
	 result in more inlined code at the cost of compilation time and  memory
	 consumption.	Decreasing usually makes the compilation faster and less
	 code will be inlined (which presumably means  slower  programs).   This
	 option  is  particularly  useful for programs that use inlining heavily
	 such as those based on recursive templates with C++.

	 Inlining is actually controlled by a number of parameters, which may be
	 specified  individually  by  using  --param  name=value.    The   -fin-
	 line-limit=n option sets some of these parameters as follows:

	 max-inline-insns-single
	      is set to I<n>/2.

	 max-inline-insns-auto
	      is set to I<n>/2.

	 min-inline-insns
	      is set to 130 or I<n>/4, whichever is smaller.

	 max-inline-insns-rtl
	      is set to I<n>.

	 See  below for a documentation of the individual parameters controlling
	 inlining.

	 Note: pseudo instruction represents, in this particular context, an ab-
	 stract measurement of function's size.  In no way does it  represent  a
	 count	of  assembly  instructions  and  as such its exact meaning might
	 change from one release to an another.

     -fkeep-inline-functions
	 In C, emit "static" functions that are declared "inline" into	the  ob-
	 ject  file,  even  if	the  function  has  been inlined into all of its
	 callers.  This switch does not affect functions using the  "extern  in-
	 line"	extension  in  GNU C.  In C++, emit any and all inline functions
	 into the object file.

     -fkeep-static-consts
	 Emit variables declared "static const" when optimization  isn't  turned
	 on, even if the variables aren't referenced.

	 GCC  enables this option by default.  If you want to force the compiler
	 to check if the variable was referenced, regardless of whether  or  not
	 optimization is turned on, use the -fno-keep-static-consts option.

     -fmerge-constants
	 Attempt  to  merge  identical	constants (string constants and floating
	 point constants) across compilation units.

	 This option is the default for optimized compilation if  the  assembler
	 and linker support it.  Use -fno-merge-constants to inhibit this behav-
	 ior.

	 Enabled at levels -O, -O2, -O3, -Os.

     -fmerge-all-constants
	 Attempt to merge identical constants and identical variables.

	 This  option  implies	-fmerge-constants.   In addition to -fmerge-con-
	 stants this considers e.g. even constant initialized arrays or initial-
	 ized constant variables with integral or floating  point  types.   Lan-
	 guages  like  C or C++ require each non-automatic variable to have dis-
	 tinct location, so using this option will result in non-conforming  be-
	 havior.

     -fmodulo-sched
	 Perform swing modulo scheduling immediately before the first scheduling
	 pass.	 This  pass looks at innermost loops and reorders their instruc-
	 tions by overlapping different iterations.

     -fno-branch-count-reg
	 Do not use "decrement and branch" instructions on a count register, but
	 instead generate a sequence of instructions that decrement a  register,
	 compare  it  against zero, then branch based upon the result.	This op-
	 tion is only meaningful on architectures  that  support  such	instruc-
	 tions, which include x86, PowerPC, IA-64 and S/390.

	 The default is -fbranch-count-reg.

     -fno-function-cse
	 Do  not put function addresses in registers; make each instruction that
	 calls a constant function contain the function's address explicitly.

	 This option results in less efficient code, but some strange hacks that
	 alter the assembler output may be confused by	the  optimizations  per-
	 formed when this option is not used.

	 The default is -ffunction-cse

     -fno-zero-initialized-in-bss
	 If  the  target  supports  a BSS section, GCC by default puts variables
	 that are initialized to zero into BSS.  This can save space in the  re-
	 sulting code.

	 This  option  turns  off this behavior because some programs explicitly
	 rely on variables going to the data section.  E.g., so that the result-
	 ing executable can find the beginning of that section and/or  make  as-
	 sumptions based on that.

	 The default is -fzero-initialized-in-bss.

     -fbounds-check
	 For  front-ends that support it, generate additional code to check that
	 indices used to access arrays are within the declared range.	This  is
	 currently only supported by the Java and Fortran front-ends, where this
	 option defaults to true and false respectively.

     -fmudflap -fmudflapth -fmudflapir
	 For  front-ends  that	support  it  (C  and  C++), instrument all risky
	 pointer/array	 dereferencing	 operations,   some   standard	 library
	 string/heap  functions,  and  some  other  associated	constructs  with
	 range/validity tests.	Modules so  instrumented  should  be  immune  to
	 buffer  overflows,  invalid  heap  use, and some other classes of C/C++
	 programming errors.  The instrumentation relies on a  separate  runtime
	 library  (libmudflap), which will be linked into a program if -fmudflap
	 is given at link time.  Run-time behavior of the  instrumented  program
	 is  controlled  by  the MUDFLAP_OPTIONS environment variable.	See "env
	 MUDFLAP_OPTIONS=-help a.out" for its options.

	 Use -fmudflapth instead of -fmudflap to compile and  to  link	if  your
	 program  is  multi-threaded.  Use -fmudflapir, in addition to -fmudflap
	 or -fmudflapth, if instrumentation should ignore pointer  reads.   This
	 produces  less  instrumentation  (and	therefore  faster execution) and
	 still provides  some  protection  against  outright  memory  corrupting
	 writes, but allows erroneously read data to propagate within a program.

     -fthread-jumps
	 Perform optimizations where we check to see if a jump branches to a lo-
	 cation where another comparison subsumed by the first is found.  If so,
	 the  first branch is redirected to either the destination of the second
	 branch or a point immediately following it, depending	on  whether  the
	 condition is known to be true or false.

	 Enabled at levels -O2, -O3, -Os.

     -fcse-follow-jumps
	 In  common  subexpression  elimination,  scan through jump instructions
	 when the target of the jump is not reached by any other path.	For  ex-
	 ample, when CSE encounters an "if" statement with an "else" clause, CSE
	 will follow the jump when the condition tested is false.

	 Enabled at levels -O2, -O3, -Os.

     -fcse-skip-blocks
	 This  is  similar to -fcse-follow-jumps, but causes CSE to follow jumps
	 which conditionally skip over blocks.	When  CSE  encounters  a  simple
	 "if"  statement  with	no  else clause, -fcse-skip-blocks causes CSE to
	 follow the jump around the body of the "if".

	 Enabled at levels -O2, -O3, -Os.

     -frerun-cse-after-loop
	 Re-run common subexpression elimination after	loop  optimizations  has
	 been performed.

	 Enabled at levels -O2, -O3, -Os.

     -fgcse
	 Perform a global common subexpression elimination pass.  This pass also
	 performs global constant and copy propagation.

	 Note:	When  compiling a program using computed gotos, a GCC extension,
	 you may get better runtime performance if you disable the global common
	 subexpression elimination pass by adding -fno-gcse to the command line.

	 Enabled at levels -O2, -O3, -Os.

     -fgcse-lm
	 When -fgcse-lm is enabled, global common subexpression elimination will
	 attempt to move loads which are only killed by stores into  themselves.
	 This  allows a loop containing a load/store sequence to be changed to a
	 load outside the loop, and a copy/store within the loop.

	 Enabled by default when gcse is enabled.

     -fgcse-sm
	 When -fgcse-sm is enabled, a store motion pass is run after global com-
	 mon subexpression elimination.  This pass will attempt to  move  stores
	 out  of loops.  When used in conjunction with -fgcse-lm, loops contain-
	 ing a load/store sequence can be changed to a load before the loop  and
	 a store after the loop.

	 Not enabled at any optimization level.

     -fgcse-las
	 When -fgcse-las is enabled, the global common subexpression elimination
	 pass eliminates redundant loads that come after stores to the same mem-
	 ory location (both partial and full redundancies).

	 Not enabled at any optimization level.

     -fgcse-after-reload
	 When  -fgcse-after-reload is enabled, a redundant load elimination pass
	 is performed after reload.  The purpose of this pass is to cleanup  re-
	 dundant spilling.

     -funsafe-loop-optimizations
	 If given, the loop optimizer will assume that loop indices do not over-
	 flow,	and  that the loops with nontrivial exit condition are not infi-
	 nite.	This enables a wider range of loop  optimizations  even  if  the
	 loop  optimizer  itself  cannot prove that these assumptions are valid.
	 Using -Wunsafe-loop-optimizations, the compiler will  warn  you  if  it
	 finds this kind of loop.

     -fcrossjumping
	 Perform  cross-jumping  transformation.   This  transformation  unifies
	 equivalent code and save code size.  The resulting code may or may  not
	 perform better than without cross-jumping.

	 Enabled at levels -O2, -O3, -Os.

     -fif-conversion
	 Attempt  to  transform  conditional jumps into branch-less equivalents.
	 This include use of conditional moves, min, max, set flags and abs  in-
	 structions, and some tricks doable by standard arithmetics.  The use of
	 conditional  execution  on chips where it is available is controlled by
	 "if-conversion2".

	 Enabled at levels -O, -O2, -O3, -Os.

     -fif-conversion2
	 Use conditional execution (where available)  to  transform  conditional
	 jumps into branch-less equivalents.

	 Enabled at levels -O, -O2, -O3, -Os.

     -fdelete-null-pointer-checks
	 Use  global  dataflow analysis to identify and eliminate useless checks
	 for null pointers.  The compiler  assumes  that  dereferencing  a  null
	 pointer  would  have halted the program.  If a pointer is checked after
	 it has already been dereferenced, it cannot be null.

	 In some environments, this assumption is not  true,  and  programs  can
	 safely  dereference null pointers.  Use -fno-delete-null-pointer-checks
	 to disable this optimization for programs which depend on  that  behav-
	 ior.

	 Enabled at levels -O2, -O3, -Os.

     -fexpensive-optimizations
	 Perform a number of minor optimizations that are relatively expensive.

	 Enabled at levels -O2, -O3, -Os.

     -foptimize-register-move
     -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.

	 Note -fregmove and -foptimize-register-move are the same optimization.

	 Enabled at levels -O2, -O3, -Os.

     -fdelayed-branch
	 If supported for the target machine, attempt to reorder instructions to
	 exploit instruction slots available after delayed branch instructions.

	 Enabled at levels -O, -O2, -O3, -Os.

     -fschedule-insns
	 If supported for the target machine, attempt to reorder instructions to
	 eliminate execution stalls due  to  required  data  being  unavailable.
	 This  helps  machines	that have slow floating point or memory load in-
	 structions by allowing other instructions to be issued until the result
	 of the load or floating point instruction is required.

	 Enabled at levels -O2, -O3, -Os.

     -fschedule-insns2
	 Similar to -fschedule-insns, but requests an  additional  pass  of  in-
	 struction  scheduling after register allocation has been done.  This is
	 especially useful on machines with a relatively small number of  regis-
	 ters and where memory load instructions take more than one cycle.

	 Enabled at levels -O2, -O3, -Os.

     -fno-sched-interblock
	 Don't	schedule instructions across basic blocks.  This is normally en-
	 abled by default when scheduling before register allocation, i.e.  with
	 -fschedule-insns or at -O2 or higher.

     -fno-sched-spec
	 Don't allow speculative motion of non-load instructions.  This is  nor-
	 mally	enabled  by  default when scheduling before register allocation,
	 i.e.  with -fschedule-insns or at -O2 or higher.

     -fsched-spec-load
	 Allow speculative motion of some load instructions.   This  only  makes
	 sense	when  scheduling  before register allocation, i.e. with -fsched-
	 ule-insns or at -O2 or higher.

     -fsched-spec-load-dangerous
	 Allow speculative motion of more load instructions.   This  only  makes
	 sense	when  scheduling  before register allocation, i.e. with -fsched-
	 ule-insns or at -O2 or higher.

     -fsched-stalled-insns=n
	 Define how many insns (if any) can be moved prematurely from the  queue
	 of  stalled  insns  into  the	ready list, during the second scheduling
	 pass.

     -fsched-stalled-insns-dep=n
	 Define how many insn groups (cycles) will be examined for a  dependency
	 on  a	stalled  insn  that  is candidate for premature removal from the
	 queue of stalled insns.  Has an effect only during the second	schedul-
	 ing  pass,  and  only if -fsched-stalled-insns is used and its value is
	 not zero.

     -fsched2-use-superblocks
	 When scheduling after register allocation, do use superblock scheduling
	 algorithm.  Superblock scheduling  allows  motion  across  basic  block
	 boundaries resulting on faster schedules.  This option is experimental,
	 as  not  all  machine	descriptions  used  by GCC model the CPU closely
	 enough to avoid unreliable results from the algorithm.

	 This only makes sense when scheduling after register  allocation,  i.e.
	 with -fschedule-insns2 or at -O2 or higher.

     -fsched2-use-traces
	 Use  -fsched2-use-superblocks	algorithm when scheduling after register
	 allocation and additionally perform code duplication in  order  to  in-
	 crease the size of superblocks using tracer pass.  See -ftracer for de-
	 tails on trace formation.

	 This  mode  should  produce  faster  but significantly longer programs.
	 Also without -fbranch-probabilities  the  traces  constructed	may  not
	 match the reality and hurt the performance.  This only makes sense when
	 scheduling after register allocation, i.e. with -fschedule-insns2 or at
	 -O2 or higher.

     -fsee
	 Eliminates  redundant extension instructions and move the non redundant
	 ones to optimal placement using LCM.

     -freschedule-modulo-scheduled-loops
	 The modulo scheduling comes before the  traditional  scheduling,  if  a
	 loop  was  modulo scheduled we may want to prevent the later scheduling
	 passes from changing its schedule, we use this option to control that.

     -fcaller-saves
	 Enable values to be allocated in registers that will  be  clobbered  by
	 function  calls, by emitting extra instructions to save and restore the
	 registers around such calls.  Such allocation	is  done  only	when  it
	 seems to result in better code than would otherwise be produced.

	 This  option  is always enabled by default on certain machines, usually
	 those which have no call-preserved registers to use instead.

	 Enabled at levels -O2, -O3, -Os.

     -ftree-pre
	 Perform Partial Redundancy Elimination (PRE) on trees.   This	flag  is
	 enabled by default at -O2 and -O3.

     -ftree-fre
	 Perform Full Redundancy Elimination (FRE) on trees.  The difference be-
	 tween	FRE and PRE is that FRE only considers expressions that are com-
	 puted on all paths leading to the redundant computation.  This analysis
	 faster than PRE, though it exposes fewer redundancies.   This	flag  is
	 enabled by default at -O and higher.

     -ftree-copy-prop
	 Perform  copy	propagation  on trees.	This pass eliminates unnecessary
	 copy operations.  This flag is enabled by default at -O and higher.

     -ftree-store-copy-prop
	 Perform copy propagation of memory loads and stores.  This pass  elimi-
	 nates	unnecessary  copy  operations  in memory references (structures,
	 global variables, arrays, etc).  This flag is enabled by default at -O2
	 and higher.

     -ftree-salias
	 Perform structural alias analysis on trees.  This flag  is  enabled  by
	 default at -O and higher.

     -fipa-pta
	 Perform interprocedural pointer analysis.

     -ftree-sink
	 Perform  forward  store  motion  on trees.  This flag is enabled by de-
	 fault at -O and higher.

     -ftree-ccp
	 Perform sparse conditional constant propagation (CCP) on  trees.   This
	 pass  only operates on local scalar variables and is enabled by default
	 at -O and higher.

     -ftree-store-ccp
	 Perform sparse conditional constant propagation (CCP) on  trees.   This
	 pass  operates  on  both  local  scalar variables and memory stores and
	 loads (global variables, structures, arrays, etc).  This  flag  is  en-
	 abled by default at -O2 and higher.

     -ftree-dce
	 Perform  dead code elimination (DCE) on trees.  This flag is enabled by
	 default at -O and higher.

     -ftree-dominator-opts
	 Perform a variety of simple scalar cleanups (constant/copy propagation,
	 redundancy elimination, range propagation  and  expression  simplifica-
	 tion)	based  on  a  dominator tree traversal.  This also performs jump
	 threading (to reduce jumps to jumps). This flag is enabled  by  default
	 at -O and higher.

     -ftree-ch
	 Perform  loop header copying on trees.  This is beneficial since it in-
	 creases effectiveness of code motion optimizations.  It also saves  one
	 jump.	This flag is enabled by default at -O and higher.  It is not en-
	 abled for -Os, since it usually increases code size.

     -ftree-loop-optimize
	 Perform  loop	optimizations on trees.  This flag is enabled by default
	 at -O and higher.

     -ftree-loop-linear
	 Perform linear loop transformations on tree.	This  flag  can  improve
	 cache performance and allow further loop optimizations to take place.

     -ftree-loop-im
	 Perform  loop	invariant motion on trees.  This pass moves only invari-
	 ants that would be hard to handle at RTL level (function calls,  opera-
	 tions	 that	expand	 to   nontrivial   sequences  of  insns).   With
	 -funswitch-loops it also moves operands of conditions that are  invari-
	 ant  out  of  the  loop,  so that we can use just trivial invariantness
	 analysis in loop unswitching.	The pass also includes store motion.

     -ftree-loop-ivcanon
	 Create a canonical counter for number of iterations  in  the  loop  for
	 that  determining  number  of iterations requires complicated analysis.
	 Later optimizations then may determine the number easily.  Useful espe-
	 cially in connection with unrolling.

     -fivopts
	 Perform induction variable optimizations (strength reduction, induction
	 variable merging and induction variable elimination) on trees.

     -ftree-sra
	 Perform scalar replacement of aggregates.  This pass replaces structure
	 references with scalars to prevent committing structures to memory  too
	 early.  This flag is enabled by default at -O and higher.

     -ftree-copyrename
	 Perform  copy renaming on trees.  This pass attempts to rename compiler
	 temporaries to other variables at copy locations, usually resulting  in
	 variable  names  which  more  closely	resemble the original variables.
	 This flag is enabled by default at -O and higher.

     -ftree-ter
	 Perform temporary expression replacement during the SSA->normal  phase.
	 Single  use/single  def  temporaries are replaced at their use location
	 with their defining expression.  This results in non-GIMPLE  code,  but
	 gives	the  expanders	much  more complex trees to work on resulting in
	 better RTL generation.  This is enabled by default at -O and higher.

     -ftree-lrs
	 Perform live range splitting during the  SSA->normal  phase.	Distinct
	 live ranges of a variable are split into unique variables, allowing for
	 better  optimization  later.	This  is  enabled  by  default at -O and
	 higher.

     -ftree-vectorize
	 Perform loop vectorization on trees.

     -ftree-vect-loop-version
	 Perform loop versioning when doing loop vectorization on trees.  When a
	 loop appears to be vectorizable except that data alignment or data  de-
	 pendence  cannot be determined at compile time then vectorized and non-
	 vectorized versions of the loop are generated along with runtime checks
	 for alignment or dependence to control which version is executed.  This
	 option is enabled by default except at level -Os where it is disabled.

     -ftree-vrp
	 Perform Value Range Propagation on trees.  This is similar to the  con-
	 stant	propagation  pass,  but  instead of values, ranges of values are
	 propagated.  This allows the optimizers  to  remove  unnecessary  range
	 checks  like  array  bound checks and null pointer checks.  This is en-
	 abled by default at -O2 and higher.  Null pointer check elimination  is
	 only done if -fdelete-null-pointer-checks is enabled.

     -ftracer
	 Perform  tail duplication to enlarge superblock size.	This transforma-
	 tion simplifies the control flow of the function allowing  other  opti-
	 mizations to do better job.

     -funroll-loops
	 Unroll  loops	whose  number of iterations can be determined at compile
	 time or upon entry to the loop.  -funroll-loops implies -frerun-cse-af-
	 ter-loop.  This option makes code larger, and may or may  not	make  it
	 run faster.

     -funroll-all-loops
	 Unroll  all loops, even if their number of iterations is uncertain when
	 the loop is entered.  This usually  makes  programs  run  more  slowly.
	 -funroll-all-loops implies the same options as -funroll-loops,

     -fsplit-ivs-in-unroller
	 Enables expressing of values of induction variables in later iterations
	 of  the  unrolled  loop  using  the value in the first iteration.  This
	 breaks long dependency chains, thus improving efficiency of the  sched-
	 uling passes.

	 Combination of -fweb and CSE is often sufficient to obtain the same ef-
	 fect.	However in cases the loop body is more complicated than a single
	 basic	block,	this  is  not reliable.  It also does not work at all on
	 some of the architectures due to restrictions in the CSE pass.

	 This optimization is enabled by default.

     -fvariable-expansion-in-unroller
	 With this option, the compiler will create multiple copies of some  lo-
	 cal variables when unrolling a loop which can result in superior code.

     -fprefetch-loop-arrays
	 If  supported	by the target machine, generate instructions to prefetch
	 memory to improve the performance of loops that access large arrays.

	 This option may generate better or worse code; results are  highly  de-
	 pendent on the structure of loops within the source code.

	 Disabled at level -Os.

     -fno-peephole
     -fno-peephole2
	 Disable  any  machine-specific  peephole optimizations.  The difference
	 between -fno-peephole and -fno-peephole2 is in how they are implemented
	 in the compiler; some targets use one, some use the other,  a	few  use
	 both.

	 -fpeephole  is  enabled by default.  -fpeephole2 enabled at levels -O2,
	 -O3, -Os.

     -fno-guess-branch-probability
	 Do not guess branch probabilities using heuristics.

	 GCC will use heuristics to guess branch probabilities if they	are  not
	 provided  by profiling feedback (-fprofile-arcs).  These heuristics are
	 based on the control flow graph.   If	some  branch  probabilities  are
	 specified  by	__builtin_expect,  then  the  heuristics will be used to
	 guess branch probabilities for the rest of the control flow graph, tak-
	 ing the __builtin_expect info into account.  The  interactions  between
	 the  heuristics and __builtin_expect can be complex, and in some cases,
	 it may be useful to disable the  heuristics  so  that	the  effects  of
	 __builtin_expect are easier to understand.

	 The default is -fguess-branch-probability at levels -O, -O2, -O3, -Os.

     -freorder-blocks
	 Reorder basic blocks in the compiled function in order to reduce number
	 of taken branches and improve code locality.

	 Enabled at levels -O2, -O3.

     -freorder-blocks-and-partition
	 In addition to reordering basic blocks in the compiled function, in or-
	 der  to  reduce number of taken branches, partitions hot and cold basic
	 blocks into separate sections of the assembly and .o files, to  improve
	 paging and cache locality performance.

	 This optimization is automatically turned off in the presence of excep-
	 tion handling, for linkonce sections, for functions with a user-defined
	 section  attribute  and on any architecture that does not support named
	 sections.

     -freorder-functions
	 Reorder functions in the object file in order to improve code locality.
	 This is implemented by using special subsections ".text.hot"  for  most
	 frequently  executed  functions  and ".text.unlikely" for unlikely exe-
	 cuted functions.  Reordering is done by the linker so object file  for-
	 mat must support named sections and linker must place them in a reason-
	 able way.

	 Also  profile	feedback must be available in to make this option effec-
	 tive.	See -fprofile-arcs for details.

	 Enabled at levels -O2, -O3, -Os.

     -fstrict-aliasing
	 Allows the compiler to assume the strictest aliasing  rules  applicable
	 to  the language being compiled.  For C (and C++), this activates opti-
	 mizations 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 exam-
	 ple, an "unsigned int" can alias an "int", but not a "void*" or a "dou-
	 ble".	A character type may alias any other type.

	 Pay special attention to code like this:

		 union a_union {
		   int i;
		   double d;
		 };

		 int f() {
		   a_union t;
		   t.d = 3.0;
		   return t.i;
		 }

	 The practice of reading from a different union member than the one most
	 recently written to  (called  "type-punning")	is  common.   Even  with
	 -fstrict-aliasing,  type-punning is allowed, provided the memory is ac-
	 cessed through the union type.  So, the code above  will  work  as  ex-
	 pected.  However, this code might not:

		 int f() {
		   a_union t;
		   int* ip;
		   t.d = 3.0;
		   ip = &t.i;
		   return *ip;
		 }

	 Every	language that wishes to perform language-specific alias analysis
	 should define a function that computes, given an "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 "c_get_alias_set".

	 Enabled at levels -O2, -O3, -Os.

     -fstrict-overflow
	 Allow the compiler to assume strict signed overflow rules, depending on
	 the language being compiled.  For C (and C++) this means that	overflow
	 when  doing  arithmetic  with	signed numbers is undefined, which means
	 that the compiler may assume that it will  not  happen.   This  permits
	 various  optimizations.   For example, the compiler will assume that an
	 expression like "i + 10 > i" will always be true for signed "i".   This
	 assumption  is  only  valid if signed overflow is undefined, as the ex-
	 pression is false if "i + 10"	overflows  when  using	twos  complement
	 arithmetic.   When  this  option  is in effect any attempt to determine
	 whether an operation on signed numbers will overflow  must  be  written
	 carefully to not actually involve overflow.

	 See  also the -fwrapv option.	Using -fwrapv means that signed overflow
	 is fully defined: it wraps.  When -fwrapv is used, there is no  differ-
	 ence  between -fstrict-overflow and -fno-strict-overflow.  With -fwrapv
	 certain types of overflow are permitted.  For example, if the	compiler
	 gets  an  overflow  when  doing arithmetic on constants, the overflowed
	 value can still be used with -fwrapv, but not otherwise.

	 The -fstrict-overflow option is enabled at levels -O2, -O3, -Os.

     -falign-functions
     -falign-functions=n
	 Align the start of functions to the next power-of-two greater	than  n,
	 skipping  up  to  n  bytes.   For instance, -falign-functions=32 aligns
	 functions to the next 32-byte boundary, but -falign-functions=24  would
	 align to the next 32-byte boundary only if this can be done by skipping
	 23 bytes or less.

	 -fno-align-functions  and  -falign-functions=1  are equivalent and mean
	 that functions will not be aligned.

	 Some assemblers only support this flag when n is a  power  of	two;  in
	 that case, it is rounded up.

	 If n is not specified or is zero, use a machine-dependent default.

	 Enabled at levels -O2, -O3.

     -falign-labels
     -falign-labels=n
	 Align	all  branch targets to a power-of-two boundary, skipping up to n
	 bytes like -falign-functions.	This option can easily make code slower,
	 because it must insert dummy operations for when the branch  target  is
	 reached in the usual flow of the code.

	 -fno-align-labels and -falign-labels=1 are equivalent and mean that la-
	 bels will not be aligned.

	 If  -falign-loops  or -falign-jumps are applicable and are greater than
	 this value, then their values are used instead.

	 If n is not specified or is zero, use a machine-dependent default which
	 is very likely to be 1, meaning no alignment.

	 Enabled at levels -O2, -O3.

     -falign-loops
     -falign-loops=n
	 Align loops to a power-of-two boundary, skipping up  to  n  bytes  like
	 -falign-functions.   The  hope  is  that the loop will be executed many
	 times, which will make up for any execution of the dummy operations.

	 -fno-align-loops and -falign-loops=1 are equivalent and mean that loops
	 will not be aligned.

	 If n is not specified or is zero, use a machine-dependent default.

	 Enabled at levels -O2, -O3.

     -falign-jumps
     -falign-jumps=n
	 Align branch targets to a power-of-two  boundary,  for  branch  targets
	 where	the  targets  can  only  be reached by jumping, skipping up to n
	 bytes like -falign-functions.	In this case, no dummy	operations  need
	 be executed.

	 -fno-align-jumps and -falign-jumps=1 are equivalent and mean that loops
	 will not be aligned.

	 If n is not specified or is zero, use a machine-dependent default.

	 Enabled at levels -O2, -O3.

     -funit-at-a-time
	 Parse the whole compilation unit before starting to produce code.  This
	 allows  some extra optimizations to take place but consumes more memory
	 (in general).	There are some compatibility issues with  unit-at-a-time
	 mode:

	 *   enabling  unit-at-a-time  mode  may change the order in which func-
	     tions, variables, and top-level "asm" statements are  emitted,  and
	     will  likely  break  code relying on some particular ordering.  The
	     majority of such top-level "asm" statements,  though,  can  be  re-
	     placed  by  "section"  attributes.  The fno-toplevel-reorder option
	     may be used to keep the ordering used in the  input  file,  at  the
	     cost of some optimizations.

	 *   unit-at-a-time mode removes unreferenced static variables and func-
	     tions.   This  may  result  in  undefined	references when an "asm"
	     statement refers directly to variables or functions that are other-
	     wise unused.  In that case either the  variable/function  shall  be
	     listed as an operand of the "asm" statement operand or, in the case
	     of top-level "asm" statements the attribute "used" shall be used on
	     the declaration.

	 *   Static  functions now can use non-standard passing conventions that
	     may break "asm" statements calling functions directly.  Again,  at-
	     tribute "used" will prevent this behavior.

	 As  a	temporary  workaround, -fno-unit-at-a-time can be used, but this
	 scheme may not be supported by future releases of GCC.

	 Enabled at levels -O, -O2, -O3, -Os.

     -fno-toplevel-reorder
	 Do not reorder top-level functions, variables,  and  "asm"  statements.
	 Output them in the same order that they appear in the input file.  When
	 this option is used, unreferenced static variables will not be removed.
	 This option is intended to support existing code which relies on a par-
	 ticular ordering.  For new code, it is better to use attributes.

     -fweb
	 Constructs  webs  as commonly used for register allocation purposes and
	 assign each web individual pseudo register.  This allows  the	register
	 allocation  pass  to  operate on pseudos directly, but also strengthens
	 several other optimization passes, such  as  CSE,  loop  optimizer  and
	 trivial dead code remover.  It can, however, make debugging impossible,
	 since variables will no longer stay in a "home register".

	 Enabled by default with -funroll-loops.

     -fwhole-program
	 Assume that the current compilation unit represents whole program being
	 compiled.   All  public  functions  and variables with the exception of
	 "main" and those merged by attribute "externally_visible" become static
	 functions and in a affect gets more aggressively optimized by interpro-
	 cedural optimizers.  While this option is equivalent to proper  use  of
	 "static" keyword for programs consisting of single file, in combination
	 with  option --combine this flag can be used to compile most of smaller
	 scale C programs since the functions and variables become local for the
	 whole combined compilation unit, not for the single source file itself.

     -fno-cprop-registers
	 After register  allocation  and  post-register  allocation  instruction
	 splitting, we perform a copy-propagation pass to try to reduce schedul-
	 ing dependencies and occasionally eliminate the copy.

	 Disabled at levels -O, -O2, -O3, -Os.

     -fprofile-generate
	 Enable  options  usually  used for instrumenting application to produce
	 profile useful for later recompilation with profile feedback based  op-
	 timization.   You  must  use -fprofile-generate both when compiling and
	 when linking your program.

	 The following options are  enabled:  "-fprofile-arcs",  "-fprofile-val-
	 ues", "-fvpt".

     -fprofile-use
	 Enable  profile feedback directed optimizations, and optimizations gen-
	 erally profitable only with profile feedback available.

	 The following options are enabled:  "-fbranch-probabilities",	"-fvpt",
	 "-funroll-loops", "-fpeel-loops", "-ftracer"

     The  following  options  control compiler behavior regarding floating point
     arithmetic.  These options trade off between speed  and  correctness.   All
     must be specifically enabled.

     -ffloat-store
	 Do  not  store floating point variables in registers, and inhibit other
	 options that might change whether a floating point value is taken  from
	 a register or memory.

	 This  option  prevents undesirable excess precision on machines such as
	 the 68000 where the floating registers (of the 68881) keep more  preci-
	 sion than a "double" is supposed to have.  Similarly for the x86 archi-
	 tecture.  For most programs, the excess precision does only good, but a
	 few  programs	rely  on  the precise definition of IEEE floating point.
	 Use -ffloat-store for such programs, after modifying them to store  all
	 pertinent intermediate computations into variables.

     -ffast-math
	 Sets  -fno-math-errno, -funsafe-math-optimizations, -fno-trapping-math,
	 -ffinite-math-only, -fno-rounding-math,  -fno-signaling-nans  and  fcx-
	 limited-range.

	 This  option  causes  the  preprocessor macro "__FAST_MATH__" to be de-
	 fined.

	 This option should never be turned on by any -O option since it can re-
	 sult in incorrect output for programs which depend on an  exact  imple-
	 mentation of IEEE or ISO rules/specifications for math functions.

     -fno-math-errno
	 Do  not set ERRNO after calling math functions that are executed with a
	 single instruction, e.g., sqrt.  A program that relies on  IEEE  excep-
	 tions for math error handling may want to use this flag for speed while
	 maintaining IEEE arithmetic compatibility.

	 This option should never be turned on by any -O option since it can re-
	 sult  in  incorrect output for programs which depend on an exact imple-
	 mentation of IEEE or ISO rules/specifications for math functions.

	 The default is -fmath-errno.

	 On Darwin systems, the math  library  never  sets  "errno".   There  is
	 therefore  no	reason for the compiler to consider the possibility that
	 it might, and -fno-math-errno is the default.

     -funsafe-math-optimizations
	 Allow optimizations for floating-point arithmetic that (a) assume  that
	 arguments  and results are valid and (b) may violate IEEE or ANSI stan-
	 dards.  When used at link-time, it may  include  libraries  or  startup
	 files	that  change the default FPU control word or other similar opti-
	 mizations.

	 This option should never be turned on by any -O option since it can re-
	 sult in incorrect output for programs which depend on an  exact  imple-
	 mentation of IEEE or ISO rules/specifications for math functions.

	 The default is -fno-unsafe-math-optimizations.

     -ffinite-math-only
	 Allow	optimizations for floating-point arithmetic that assume that ar-
	 guments and results are not NaNs or +-Infs.

	 This option should never be turned on by any -O option since it can re-
	 sult in incorrect output for programs which depend on an  exact  imple-
	 mentation of IEEE or ISO rules/specifications.

	 The default is -fno-finite-math-only.

     -fno-trapping-math
	 Compile  code	assuming  that floating-point operations cannot generate
	 user-visible traps.  These traps include division  by	zero,  overflow,
	 underflow,  inexact  result and invalid operation.  This option implies
	 -fno-signaling-nans.  Setting this option may allow faster code if  one
	 relies on "non-stop" IEEE arithmetic, for example.

	 This option should never be turned on by any -O option since it can re-
	 sult  in  incorrect output for programs which depend on an exact imple-
	 mentation of IEEE or ISO rules/specifications for math functions.

	 The default is -ftrapping-math.

     -frounding-math
	 Disable transformations and optimizations that assume default	floating
	 point	rounding behavior.  This is round-to-zero for all floating point
	 to integer conversions, and round-to-nearest for all  other  arithmetic
	 truncations.	This option should be specified for programs that change
	 the FP rounding mode dynamically, or that may be executed with  a  non-
	 default rounding mode.  This option disables constant folding of float-
	 ing  point expressions at compile-time (which may be affected by round-
	 ing mode) and arithmetic transformations that are unsafe in  the  pres-
	 ence of sign-dependent rounding modes.

	 The default is -fno-rounding-math.

	 This option is experimental and does not currently guarantee to disable
	 all  GCC optimizations that are affected by rounding mode.  Future ver-
	 sions of GCC may provide finer control  of  this  setting  using  C99's
	 "FENV_ACCESS" pragma.	This command line option will be used to specify
	 the default state for "FENV_ACCESS".

     -frtl-abstract-sequences
	 It  is a size optimization method. This option is to find identical se-
	 quences of code, which can be turned into pseudo-procedures   and  then
	 replace   all	 occurrences  with  calls to  the  newly created subrou-
	 tine. It is kind of an opposite of -finline-functions.  This  optimiza-
	 tion runs at RTL level.

     -fsignaling-nans
	 Compile  code assuming that IEEE signaling NaNs may generate user-visi-
	 ble traps during floating-point operations.  Setting this  option  dis-
	 ables	optimizations  that  may change the number of exceptions visible
	 with signaling NaNs.  This option implies -ftrapping-math.

	 This option causes the preprocessor macro "__SUPPORT_SNAN__" to be  de-
	 fined.

	 The default is -fno-signaling-nans.

	 This option is experimental and does not currently guarantee to disable
	 all GCC optimizations that affect signaling NaN behavior.

     -fsingle-precision-constant
	 Treat	floating  point constant as single precision constant instead of
	 implicitly converting it to double precision constant.

     -fcx-limited-range
     -fno-cx-limited-range
	 When enabled, this option states that a range	reduction  step  is  not
	 needed  when  performing complex division.  The default is -fno-cx-lim-
	 ited-range, but is enabled by -ffast-math.

	 This option controls the  default  setting  of  the  ISO  C99	"CX_LIM-
	 ITED_RANGE" pragma.  Nevertheless, the option applies to all languages.

     The  following  options control optimizations that may improve performance,
     but are not enabled by any -O options.  This section includes  experimental
     options that may produce broken code.

     -fbranch-probabilities
	 After	running  a program compiled with -fprofile-arcs, you can compile
	 it a second time using -fbranch-probabilities, to improve optimizations
	 based on the number of times each branch was taken.  When  the  program
	 compiled  with  -fprofile-arcs exits it saves arc execution counts to a
	 file called sourcename.gcda for each source file   The  information  in
	 this  data  file  is  very  dependent on the structure of the generated
	 code, so you must use the same source code and  the  same  optimization
	 options for both compilations.

	 With  -fbranch-probabilities,	GCC  puts  a  REG_BR_PROB  note  on each
	 JUMP_INSN and CALL_INSN.  These can be used  to  improve  optimization.
	 Currently,  they  are	only  used  in one place: in reorg.c, instead of
	 guessing which path a branch is mostly to take, the REG_BR_PROB  values
	 are used to exactly determine which path is taken more often.

     -fprofile-values
	 If  combined  with -fprofile-arcs, it adds code so that some data about
	 values of expressions in the program is gathered.

	 With -fbranch-probabilities, it reads back the data gathered from  pro-
	 filing  values  of  expressions and adds REG_VALUE_PROFILE notes to in-
	 structions for their later usage in optimizations.

	 Enabled with -fprofile-generate and -fprofile-use.

     -fvpt
	 If combined with -fprofile-arcs, it instructs the  compiler  to  add  a
	 code to gather information about values of expressions.

	 With  -fbranch-probabilities, it reads back the data gathered and actu-
	 ally performs the optimizations based on them.  Currently the optimiza-
	 tions include specialization of division operation using the  knowledge
	 about the value of the denominator.

     -frename-registers
	 Attempt  to avoid false dependencies in scheduled code by making use of
	 registers left over after register allocation.  This optimization  will
	 most benefit processors with lots of registers.  Depending on the debug
	 information  format  adopted by the target, however, it can make debug-
	 ging impossible, since variables will no longer stay in a "home  regis-
	 ter".

	 Enabled by default with -funroll-loops.

     -ftracer
	 Perform  tail duplication to enlarge superblock size.	This transforma-
	 tion simplifies the control flow of the function allowing  other  opti-
	 mizations to do better job.

	 Enabled with -fprofile-use.

     -funroll-loops
	 Unroll  loops	whose  number of iterations can be determined at compile
	 time or upon entry to the loop.  -funroll-loops implies -frerun-cse-af-
	 ter-loop, -fweb and -frename-registers.  It also turns on complete loop
	 peeling (i.e. complete removal of loops with small constant  number  of
	 iterations).  This option makes code larger, and may or may not make it
	 run faster.

	 Enabled with -fprofile-use.

     -funroll-all-loops
	 Unroll  all loops, even if their number of iterations is uncertain when
	 the loop is entered.  This usually  makes  programs  run  more  slowly.
	 -funroll-all-loops implies the same options as -funroll-loops.

     -fpeel-loops
	 Peels	the  loops for that there is enough information that they do not
	 roll much (from profile feedback).  It  also  turns  on  complete  loop
	 peeling  (i.e.  complete removal of loops with small constant number of
	 iterations).

	 Enabled with -fprofile-use.

     -fmove-loop-invariants
	 Enables the loop invariant motion pass in the RTL loop optimizer.   En-
	 abled at level -O1

     -funswitch-loops
	 Move  branches with loop invariant conditions out of the loop, with du-
	 plicates of the loop on both branches (modified according to result  of
	 the condition).

     -ffunction-sections
     -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  func-
	 tion  or the name of the data item determines the section's name in the
	 output file.

	 Use these options on systems where the linker can perform optimizations
	 to improve locality of reference in the instruction space.   Most  sys-
	 tems using the ELF object format and SPARC processors running Solaris 2
	 have linkers with such optimizations.	AIX may have these optimizations
	 in the future.

	 Only  use  these options when there are significant benefits from doing
	 so.  When you specify these options, the assembler and linker will cre-
	 ate larger object and executable files and will also  be  slower.   You
	 will  not be able to use "gprof" on all systems if you specify this op-
	 tion and you may have problems with debugging if you specify both  this
	 option and -g.

     -fbranch-target-load-optimize
	 Perform branch target register load optimization before prologue / epi-
	 logue	threading.  The use of target registers can typically be exposed
	 only during reload, thus hoisting loads out of loops and  doing  inter-
	 block scheduling needs a separate optimization pass.

     -fbranch-target-load-optimize2
	 Perform  branch target register load optimization after prologue / epi-
	 logue threading.

     -fbtr-bb-exclusive
	 When performing branch target register load optimization,  don't  reuse
	 branch target registers in within any basic block.

     -fstack-protector
	 Emit  extra  code to check for buffer overflows, such as stack smashing
	 attacks.  This is done by adding a guard  variable  to  functions  with
	 vulnerable  objects.	This  includes	functions  that call alloca, and
	 functions with buffers larger than 8 bytes.  The guards are initialized
	 when a function is entered and then checked when  the	function  exits.
	 If a guard check fails, an error message is printed and the program ex-
	 its.

     -fstack-protector-all
	 Like -fstack-protector except that all functions are protected.

     -fsection-anchors
	 Try  to  reduce  the  number  of symbolic address calculations by using
	 shared "anchor" symbols to address nearby objects.  This transformation
	 can help to reduce the number of GOT entries and GOT accesses	on  some
	 targets.

	 For example, the implementation of the following function "foo":

		 static int a, b, c;
		 int foo (void) { return a + b + c; }

	 would	usually  calculate  the addresses of all three variables, but if
	 you compile it with -fsection-anchors, it  will  access  the  variables
	 from  a common anchor point instead.  The effect is similar to the fol-
	 lowing pseudocode (which isn't valid C):

		 int foo (void)
		 {
		   register int *xr = &x;
		   return xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
		 }

	 Not all targets support this option.

     --param name=value
	 In some places, GCC uses various constants to control the amount of op-
	 timization that is done.  For example, GCC will  not  inline  functions
	 that  contain more that a certain number of instructions.  You can con-
	 trol some of these constants on the command-line using the --param  op-
	 tion.

	 The  names  of  specific parameters, and the meaning of the values, are
	 tied to the internals of the compiler, and are subject to change  with-
	 out notice in future releases.

	 In  each case, the value is an integer.  The allowable choices for name
	 are given in the following table:

	 salias-max-implicit-fields
	     The maximum number of fields in a variable without direct structure
	     accesses for which structure aliasing will consider trying to track
	     each field.  The default is 5

	 salias-max-array-elements
	     The maximum number of elements an array can have and  its	elements
	     still be tracked individually by structure aliasing. The default is
	     4

	 sra-max-structure-size
	     The  maximum structure size, in bytes, at which the scalar replace-
	     ment of aggregates (SRA) optimization will  perform  block  copies.
	     The  default value, 0, implies that GCC will select the most appro-
	     priate size itself.

	 sra-field-structure-ratio
	     The threshold ratio (as a percentage) between  instantiated  fields
	     and  the  complete structure size.  We say that if the ratio of the
	     number of bytes in instantiated fields to the number  of  bytes  in
	     the  complete  structure  exceeds this parameter, then block copies
	     are not used.  The default is 75.

	 max-crossjump-edges
	     The maximum number of incoming edges to consider for  crossjumping.
	     The  algorithm  used  by  -fcrossjumping is O(N^2) in the number of
	     edges incoming to each block.  Increasing values mean more  aggres-
	     sive  optimization,  making the compile time increase with probably
	     small improvement in executable size.

	 min-crossjump-insns
	     The minimum number of instructions which must be matched at the end
	     of two blocks before crossjumping will be performed on them.   This
	     value  is	ignored  in the case where all instructions in the block
	     being crossjumped from are matched.  The default value is 5.

	 max-grow-copy-bb-insns
	     The maximum code size expansion factor when  copying  basic  blocks
	     instead  of  jumping.  The expansion is relative to a jump instruc-
	     tion.  The default value is 8.

	 max-goto-duplication-insns
	     The maximum number of instructions to duplicate  to  a  block  that
	     jumps  to a computed goto.  To avoid O(N^2) behavior in a number of
	     passes,  GCC  factors  computed  gotos  early  in	the  compilation
	     process,  and  unfactors  them  as late as possible.  Only computed
	     jumps at the end of a basic blocks with no more  than  max-goto-du-
	     plication-insns are unfactored.  The default value is 8.

	 max-delay-slot-insn-search
	     The  maximum number of instructions to consider when looking for an
	     instruction to fill a delay slot.	If more than this arbitrary num-
	     ber of instructions is searched, the time savings from filling  the
	     delay  slot  will	be minimal so stop searching.  Increasing values
	     mean more aggressive optimization, making the compile time increase
	     with probably small improvement in executable run time.

	 max-delay-slot-live-search
	     When trying to fill delay slots, the maximum number of instructions
	     to consider when searching for a block with valid live register in-
	     formation.  Increasing this arbitrarily chosen value means more ag-
	     gressive optimization, increasing the compile time.  This parameter
	     should be removed when the delay slot code is rewritten to maintain
	     the control-flow graph.

	 max-gcse-memory
	     The approximate maximum amount of memory that will be allocated  in
	     order  to perform the global common subexpression elimination opti-
	     mization.	If more memory than specified is required, the optimiza-
	     tion will not be done.

	 max-gcse-passes
	     The maximum number of passes of GCSE to run.  The default is 1.

	 max-pending-list-length
	     The maximum number of pending dependencies  scheduling  will  allow
	     before  flushing  the current state and starting over.  Large func-
	     tions with few branches or calls can create excessively large lists
	     which needlessly consume memory and resources.

	 max-inline-insns-single
	     Several parameters control the tree inliner used in gcc.  This num-
	     ber sets the maximum number of instructions (counted in  GCC's  in-
	     ternal  representation)  in a single function that the tree inliner
	     will consider for inlining.  This only affects  functions	declared
	     inline  and  methods implemented in a class declaration (C++).  The
	     default value is 450.

	 max-inline-insns-auto
	     When you use -finline-functions (included in -O3), a lot  of  func-
	     tions  that  would  otherwise not be considered for inlining by the
	     compiler will be investigated.  To  those	functions,  a  different
	     (more  restrictive) limit compared to functions declared inline can
	     be applied.  The default value is 90.

	 large-function-insns
	     The limit specifying really large functions.  For functions  larger
	     than  this  limit after inlining inlining is constrained by --param
	     large-function-growth.  This parameter is useful primarily to avoid
	     extreme compilation time caused by non-linear  algorithms	used  by
	     the  backend.   This  parameter is ignored when -funit-at-a-time is
	     not used.	The default value is 2700.

	 large-function-growth
	     Specifies maximal growth of large function caused	by  inlining  in
	     percents.	 This  parameter is ignored when -funit-at-a-time is not
	     used.  The default value is 100 which limits large function  growth
	     to 2.0 times the original size.

	 large-unit-insns
	     The  limit specifying large translation unit.  Growth caused by in-
	     lining of units larger than this limit is limited	by  --param  in-
	     line-unit-growth.	 For  small  units this might be too tight (con-
	     sider unit consisting of function A that is inline and B that  just
	     calls  A  three  time.   If B is small relative to A, the growth of
	     unit is 300\% and yet such inlining is very sane.	For  very  large
	     units consisting of small inlininable functions however the overall
	     unit  growth limit is needed to avoid exponential explosion of code
	     size.  Thus for smaller units, the size  is  increased  to  --param
	     large-unit-insns  before  applying --param inline-unit-growth.  The
	     default is 10000

	 inline-unit-growth
	     Specifies maximal overall growth of the compilation unit caused  by
	     inlining.	 This  parameter is ignored when -funit-at-a-time is not
	     used.  The default value is 50 which  limits  unit  growth  to  1.5
	     times the original size.

	 max-inline-insns-recursive
	 max-inline-insns-recursive-auto
	     Specifies	maximum  number of instructions out-of-line copy of self
	     recursive inline function can grow into by performing recursive in-
	     lining.

	     For functions declared inline --param max-inline-insns-recursive is
	     taken into account.  For function not  declared  inline,  recursive
	     inlining  happens only when -finline-functions (included in -O3) is
	     enabled and --param max-inline-insns-recursive-auto is  used.   The
	     default value is 450.

	 max-inline-recursive-depth
	 max-inline-recursive-depth-auto
	     Specifies maximum recursion depth used by the recursive inlining.

	     For functions declared inline --param max-inline-recursive-depth is
	     taken  into  account.   For function not declared inline, recursive
	     inlining happens only when -finline-functions (included in -O3)  is
	     enabled  and  --param max-inline-recursive-depth-auto is used.  The
	     default value is 450.

	 min-inline-recursive-probability
	     Recursive inlining is profitable only for function having deep  re-
	     cursion  in  average and can hurt for function having little recur-
	     sion depth by increasing the prologue size or complexity  of  func-
	     tion body to other optimizers.

	     When profile feedback is available (see -fprofile-generate) the ac-
	     tual  recursion depth can be guessed from probability that function
	     will recurse via given call expression.  This parameter limits  in-
	     lining  only  to  call  expression  whose probability exceeds given
	     threshold (in percents).  The default value is 10.

	 inline-call-cost
	     Specify cost of call instruction relative to simple arithmetics op-
	     erations (having cost of 1).  Increasing this cost disqualifies in-
	     lining of non-leaf functions and at the same time increases size of
	     leaf function that is believed to reduce function size by being in-
	     lined.  In effect it increases amount of inlining for  code  having
	     large  abstraction penalty (many functions that just pass the argu-
	     ments to other functions) and decrease inlining for code  with  low
	     abstraction penalty.  The default value is 16.

	 max-unrolled-insns
	     The  maximum number of instructions that a loop should have if that
	     loop is unrolled, and if the loop is unrolled,  it  determines  how
	     many times the loop code is unrolled.

	 max-average-unrolled-insns
	     The maximum number of instructions biased by probabilities of their
	     execution	that a loop should have if that loop is unrolled, and if
	     the loop is unrolled, it determines how many times the loop code is
	     unrolled.

	 max-unroll-times
	     The maximum number of unrollings of a single loop.

	 max-peeled-insns
	     The maximum number of instructions that a loop should have if  that
	     loop  is  peeled, and if the loop is peeled, it determines how many
	     times the loop code is peeled.

	 max-peel-times
	     The maximum number of peelings of a single loop.

	 max-completely-peeled-insns
	     The maximum number of insns of a completely peeled loop.

	 max-completely-peel-times
	     The maximum number of iterations of a loop to be suitable for  com-
	     plete peeling.

	 max-unswitch-insns
	     The maximum number of insns of an unswitched loop.

	 max-unswitch-level
	     The maximum number of branches unswitched in a single loop.

	 lim-expensive
	     The  minimum  cost of an expensive expression in the loop invariant
	     motion.

	 iv-consider-all-candidates-bound
	     Bound on number of candidates for induction  variables  below  that
	     all  candidates  are  considered for each use in induction variable
	     optimizations.  Only the most relevant candidates are considered if
	     there are more candidates, to avoid quadratic time complexity.

	 iv-max-considered-uses
	     The induction variable optimizations give up on loops that  contain
	     more induction variable uses.

	 iv-always-prune-cand-set-bound
	     If  number  of candidates in the set is smaller than this value, we
	     always try to remove unnecessary ivs from the set during its  opti-
	     mization when a new iv is added to the set.

	 scev-max-expr-size
	     Bound  on	size  of  expressions used in the scalar evolutions ana-
	     lyzer.  Large expressions slow the analyzer.

	 vect-max-version-checks
	     The maximum number of runtime checks that can be performed when do-
	     ing loop versioning in the vectorizer.  See option ftree-vect-loop-
	     version for more information.

	 max-iterations-to-track
	     The maximum number of iterations of a loop the  brute  force  algo-
	     rithm  for  analysis of # of iterations of the loop tries to evalu-
	     ate.

	 hot-bb-count-fraction
	     Select fraction of the maximal count of repetitions of basic  block
	     in program given basic block needs to have to be considered hot.

	 hot-bb-frequency-fraction
	     Select  fraction  of  the	maximal frequency of executions of basic
	     block in function given basic block needs to have to be  considered
	     hot

	 max-predicted-iterations
	     The  maximum number of loop iterations we predict statically.  This
	     is useful in cases where function contain single  loop  with  known
	     bound  and other loop with unknown.  We predict the known number of
	     iterations correctly, while the unknown number of iterations  aver-
	     age  to  roughly 10.  This means that the loop without bounds would
	     appear artificially cold relative to the other one.

	 tracer-dynamic-coverage
	 tracer-dynamic-coverage-feedback
	     This value is used to limit superblock  formation	once  the  given
	     percentage of executed instructions is covered.  This limits unnec-
	     essary code size expansion.

	     The  tracer-dynamic-coverage-feedback  is	used  only  when profile
	     feedback is available.  The real profiles (as opposed to statically
	     estimated ones) are much less balanced allowing the threshold to be
	     larger value.

	 tracer-max-code-growth
	     Stop tail duplication once code growth has reached  given	percent-
	     age.  This is rather hokey argument, as most of the duplicates will
	     be  eliminated  later  in	cross  jumping, so it may be set to much
	     higher values than is the desired code growth.

	 tracer-min-branch-ratio
	     Stop reverse growth when the reverse probability of  best	edge  is
	     less than this threshold (in percent).

	 tracer-min-branch-ratio
	 tracer-min-branch-ratio-feedback
	     Stop forward growth if the best edge do have probability lower than
	     this threshold.

	     Similarly	to  tracer-dynamic-coverage  two values are present, one
	     for compilation for profile feedback and one for compilation  with-
	     out.   The  value for compilation with profile feedback needs to be
	     more conservative (higher) in order to make tracer effective.

	 max-cse-path-length
	     Maximum number of basic blocks on path that cse considers.  The de-
	     fault is 10.

	 max-cse-insns
	     The maximum instructions CSE process before flushing.  The  default
	     is 1000.

	 global-var-threshold
	     Counts  the  number  of  function calls (n) and the number of call-
	     clobbered variables (v).  If nxv is larger than this limit, a  sin-
	     gle  artificial variable will be created to represent all the call-
	     clobbered variables at function call sites.  This artificial  vari-
	     able  will  then  be  made  to alias every call-clobbered variable.
	     (done as "int * size_t" on the host machine; beware overflow).

	 max-aliased-vops
	     Maximum number of virtual operands allowed to represent aliases be-
	     fore triggering the alias grouping heuristic.  Alias  grouping  re-
	     duces  compile  times and memory consumption needed for aliasing at
	     the expense of precision loss in alias information.

	 ggc-min-expand
	     GCC uses a garbage collector to manage its own  memory  allocation.
	     This  parameter  specifies  the  minimum  percentage  by  which the
	     garbage collector's heap should be allowed to expand  between  col-
	     lections.	Tuning this may improve compilation speed; it has no ef-
	     fect on code generation.

	     The  default  is  30% + 70% * (RAM/1GB) with an upper bound of 100%
	     when RAM >= 1GB.  If "getrlimit" is available, the notion of  "RAM"
	     is the smallest of actual RAM and "RLIMIT_DATA" or "RLIMIT_AS".  If
	     GCC  is  not  able  to  calculate RAM on a particular platform, the
	     lower bound of 30% is used.  Setting this	parameter  and	ggc-min-
	     heapsize  to zero causes a full collection to occur at every oppor-
	     tunity.  This is extremely slow, but can be useful for debugging.

	 ggc-min-heapsize
	     Minimum size of the garbage collector's heap before it begins both-
	     ering to collect garbage.	The first collection  occurs  after  the
	     heap  expands  by	ggc-min-expand% beyond ggc-min-heapsize.  Again,
	     tuning this may improve compilation speed, and  has  no  effect  on
	     code generation.

	     The  default  is the smaller of RAM/8, RLIMIT_RSS, or a limit which
	     tries to ensure that RLIMIT_DATA or RLIMIT_AS are not exceeded, but
	     with a lower bound of 4096 (four megabytes) and an upper  bound  of
	     131072  (128  megabytes).	If GCC is not able to calculate RAM on a
	     particular platform, the lower bound is used.  Setting this parame-
	     ter very large effectively disables  garbage  collection.	 Setting
	     this  parameter and ggc-min-expand to zero causes a full collection
	     to occur at every opportunity.

	 max-reload-search-insns
	     The maximum number of instruction reload should look  backward  for
	     equivalent  register.  Increasing values mean more aggressive opti-
	     mization, making the compile time increase with  probably	slightly
	     better performance.  The default value is 100.

	 max-cselib-memory-locations
	     The  maximum number of memory locations cselib should take into ac-
	     count.  Increasing values mean more aggressive optimization, making
	     the compile time increase with  probably  slightly  better  perfor-
	     mance.  The default value is 500.

	 max-flow-memory-locations
	     Similar  as  max-cselib-memory-locations but for dataflow liveness.
	     The default value is 100.

	 reorder-blocks-duplicate
	 reorder-blocks-duplicate-feedback
	     Used by basic block reordering pass to decide whether to use uncon-
	     ditional branch or duplicate the code on its destination.	Code  is
	     duplicated  when its estimated size is smaller than this value mul-
	     tiplied by the estimated size of  unconditional  jump  in	the  hot
	     spots of the program.

	     The  reorder-block-duplicate-feedback  is	used  only  when profile
	     feedback is available and may be set to higher values than reorder-
	     block-duplicate since information about the hot spots is more accu-
	     rate.

	 max-sched-ready-insns
	     The maximum number of instructions ready to be issued the scheduler
	     should consider at any given time during the first scheduling pass.
	     Increasing values mean more thorough searches, making the	compila-
	     tion time increase with probably little benefit.  The default value
	     is 100.

	 max-sched-region-blocks
	     The  maximum  number of blocks in a region to be considered for in-
	     terblock scheduling.  The default value is 10.

	 max-sched-region-insns
	     The maximum number of insns in a region to be  considered	for  in-
	     terblock scheduling.  The default value is 100.

	 min-spec-prob
	     The  minimum  probability	(in percents) of reaching a source block
	     for interblock speculative scheduling.  The default value is 40.

	 max-sched-extend-regions-iters
	     The maximum number of iterations through CFG to extend regions.   0
	     -	disable  region extension, N - do at most N iterations.  The de-
	     fault value is 0.

	 max-sched-insn-conflict-delay
	     The maximum conflict delay for an insn to be considered for  specu-
	     lative motion.  The default value is 3.

	 sched-spec-prob-cutoff
	     The  minimal  probability	of speculation success (in percents), so
	     that speculative insn will be scheduled.  The default value is 40.

	 max-last-value-rtl
	     The maximum size measured as number of RTLs that can be recorded in
	     an expression in combiner for a pseudo register as last known value
	     of that register.	The default is 10000.

	 integer-share-limit
	     Small integer constants can use a shared data  structure,	reducing
	     the  compiler's  memory  usage and increasing its speed.  This sets
	     the maximum value of a  shared  integer  constant's.   The  default
	     value is 256.

	 min-virtual-mappings
	     Specifies the minimum number of virtual mappings in the incremental
	     SSA  updater  that should be registered to trigger the virtual map-
	     pings heuristic defined  by  virtual-mappings-ratio.   The  default
	     value is 100.

	 virtual-mappings-ratio
	     If  the number of virtual mappings is virtual-mappings-ratio bigger
	     than the number of virtual symbols to be updated, then  the  incre-
	     mental  SSA  updater  switches  to a full update for those symbols.
	     The default ratio is 3.

	 ssp-buffer-size
	     The minimum size of buffers (i.e. arrays) that will  receive  stack
	     smashing protection when -fstack-protection is used.

	 max-jump-thread-duplication-stmts
	     Maximum  number  of  statements allowed in a block that needs to be
	     duplicated when threading jumps.

	 max-fields-for-field-sensitive
	     Maximum number of fields in a structure we will treat  in	a  field
	     sensitive manner during pointer analysis.

     Options Controlling the Preprocessor

     These  options  control  the  C preprocessor, which is run on each C source
     file before actual compilation.

     If you use the -E option, nothing is done except  preprocessing.	Some  of
     these  options make sense only together with -E because they cause the pre-
     processor output to be unsuitable for actual compilation.

	 You can use -Wp,option to bypass the compiler driver  and  pass  option
	 directly through to the preprocessor.	If option contains commas, it is
	 split	into  multiple options at the commas.  However, many options are
	 modified, translated or interpreted by the compiler driver before being
	 passed to the preprocessor, and -Wp forcibly bypasses this phase.   The
	 preprocessor's  direct interface is undocumented and subject to change,
	 so whenever possible you should avoid using -Wp and let the driver han-
	 dle the options instead.

     -Xpreprocessor option
	 Pass option as an option to the preprocessor.	You can use this to sup-
	 ply system-specific preprocessor options which GCC does not know how to
	 recognize.

	 If you want to pass an option that takes  an  argument,  you  must  use
	 -Xpreprocessor twice, once for the option and once for the argument.

     -D name
	 Predefine name as a macro, with definition 1.

     -D name=definition
	 The  contents	of definition are tokenized and processed as if they ap-
	 peared during translation phase three in a #define directive.	In  par-
	 ticular,  the	definition will be truncated by embedded newline charac-
	 ters.

	 If you are invoking the preprocessor from a shell or shell-like program
	 you may need to use the shell's quoting syntax  to  protect  characters
	 such as spaces that have a meaning in the shell syntax.

	 If  you wish to define a function-like macro on the command line, write
	 its argument list with surrounding parentheses before the  equals  sign
	 (if  any).  Parentheses are meaningful to most shells, so you will need
	 to quote the option.  With  sh  and  csh,  -D'name(args...)=definition'
	 works.

	 -D and -U options are processed in the order they are given on the com-
	 mand  line.   All -imacros file and -include file options are processed
	 after all -D and -U options.

     -U name
	 Cancel any previous definition of name, either  built	in  or	provided
	 with a -D option.

     -undef
	 Do not predefine any system-specific or GCC-specific macros.  The stan-
	 dard predefined macros remain defined.

     -I dir
	 Add  the  directory  dir  to the list of directories to be searched for
	 header files.	Directories named by -I are searched before the standard
	 system include directories.  If the directory dir is a standard  system
	 include  directory,  the  option  is ignored to ensure that the default
	 search order for system directories and the special treatment of system
	 headers are not defeated .

     -o file
	 Write output to file.	This is the same as specifying file as the  sec-
	 ond  non-option argument to cpp.  gcc has a different interpretation of
	 a second non-option argument, so you must use -o to specify the  output
	 file.

     -Wall
	 Turns on all optional warnings which are desirable for normal code.  At
	 present this is -Wcomment, -Wtrigraphs, -Wmultichar and a warning about
	 integer  promotion causing a change of sign in "#if" expressions.  Note
	 that many of the preprocessor's warnings are on by default and have  no
	 options to control them.

     -Wcomment
     -Wcomments
	 Warn  whenever  a comment-start sequence /* appears in a /* comment, or
	 whenever a backslash-newline appears in a // comment.	(Both forms have
	 the same effect.)

     -Wtrigraphs
	 Most trigraphs in comments cannot affect the meaning  of  the	program.
	 However,  a trigraph that would form an escaped newline (??/ at the end
	 of a line) can, by changing where the comment begins or  ends.   There-
	 fore,	only trigraphs that would form escaped newlines produce warnings
	 inside a comment.

	 This option is implied by -Wall.  If -Wall is not given, this option is
	 still enabled unless trigraphs are enabled.  To get trigraph conversion
	 without warnings, but get the	other  -Wall  warnings,  use  -trigraphs
	 -Wall -Wno-trigraphs.

     -Wtraditional
	 Warn  about  certain  constructs that behave differently in traditional
	 and ISO C.  Also warn about ISO C constructs that have no traditional C
	 equivalent, and problematic constructs which should be avoided.

     -Wimport
	 Warn the first time #import is used.

     -Wundef
	 Warn whenever an identifier which is not a macro is encountered  in  an
	 #if  directive, outside of defined.  Such identifiers are replaced with
	 zero.

     -Wunused-macros
	 Warn about macros defined in the main file that are unused.  A macro is
	 used if it is expanded or tested for existence at least once.	The pre-
	 processor will also warn if the macro has not been used at the time  it
	 is redefined or undefined.

	 Built-in macros, macros defined on the command line, and macros defined
	 in include files are not warned about.

	 Note: If a macro is actually used, but only used in skipped conditional
	 blocks,  then	CPP  will  report it as unused.  To avoid the warning in
	 such a case, you might improve the scope of the macro's definition  by,
	 for  example,	moving	it into the first skipped block.  Alternatively,
	 you could provide a dummy use with something like:

		 #if defined the_macro_causing_the_warning
		 #endif

     -Wendif-labels
	 Warn whenever an #else or an #endif are followed by text.  This usually
	 happens in code of the form

		 #if FOO
		 ...
		 #else FOO
		 ...
		 #endif FOO

	 The second and third "FOO" should be in comments, but often are not  in
	 older programs.  This warning is on by default.

     -Werror
	 Make  all  warnings into hard errors.	Source code which triggers warn-
	 ings will be rejected.

     -Wsystem-headers
	 Issue warnings for code in system headers.  These are normally  unhelp-
	 ful in finding bugs in your own code, therefore suppressed.  If you are
	 responsible for the system library, you may want to see them.

     -w  Suppress all warnings, including those which GNU CPP issues by default.

     -pedantic
	 Issue	all the mandatory diagnostics listed in the C standard.  Some of
	 them are left out by default, since they trigger frequently on harmless
	 code.

     -pedantic-errors
	 Issue all the mandatory diagnostics, and make all mandatory diagnostics
	 into errors.  This includes mandatory diagnostics that GCC issues with-
	 out -pedantic but treats as warnings.

     -M  Instead of outputting the result of preprocessing, output a rule  suit-
	 able for make describing the dependencies of the main source file.  The
	 preprocessor  outputs one make rule containing the object file name for
	 that source file, a colon, and the names of all the included files, in-
	 cluding those coming from -include or -imacros command line options.

	 Unless specified explicitly (with -MT or -MQ),  the  object  file  name
	 consists  of  the  basename of the source file with any suffix replaced
	 with object file suffix.  If there are many  included	files  then  the
	 rule is split into several lines using \-newline.  The rule has no com-
	 mands.

	 This  option does not suppress the preprocessor's debug output, such as
	 -dM.  To avoid mixing such debug output with the dependency  rules  you
	 should  explicitly  specify the dependency output file with -MF, or use
	 an environment variable like DEPENDENCIES_OUTPUT.   Debug  output  will
	 still be sent to the regular output stream as normal.

	 Passing  -M  to  the driver implies -E, and suppresses warnings with an
	 implicit -w.

     -MM Like -M but do not mention header files that are found in system header
	 directories, nor header files that  are  included,  directly  or  indi-
	 rectly, from such a header.

	 This  implies	that the choice of angle brackets or double quotes in an
	 #include directive does not in itself	determine  whether  that  header
	 will  appear  in -MM dependency output.  This is a slight change in se-
	 mantics from GCC versions 3.0 and earlier.

     -MF file
	 When used with -M or -MM, specifies a file to	write  the  dependencies
	 to.   If no -MF switch is given the preprocessor sends the rules to the
	 same place it would have sent preprocessed output.

	 When used with the driver options -MD or -MMD, -MF  overrides	the  de-
	 fault dependency output file.

     -MG In  conjunction with an option such as -M requesting dependency genera-
	 tion, -MG assumes missing header files are  generated	files  and  adds
	 them  to  the dependency list without raising an error.  The dependency
	 filename is  taken  directly  from  the  "#include"  directive  without
	 prepending  any  path.   -MG  also suppresses preprocessed output, as a
	 missing header file renders this useless.

	 This feature is used in automatic updating of makefiles.

     -MP This option instructs CPP to add a phony  target  for	each  dependency
	 other	than  the  main  file, causing each to depend on nothing.  These
	 dummy rules work around errors make gives if you  remove  header  files
	 without updating the Makefile to match.

	 This is typical output:

		 test.o: test.c test.h

		 test.h:

     -MT target
	 Change the target of the rule emitted by dependency generation.  By de-
	 fault	CPP  takes  the name of the main input file, including any path,
	 deletes any file suffix such as .c, and appends  the  platform's  usual
	 object suffix.  The result is the target.

	 An -MT option will set the target to be exactly the string you specify.
	 If you want multiple targets, you can specify them as a single argument
	 to -MT, or use multiple -MT options.

	 For example, -MT '$(objpfx)foo.o' might give

		 $(objpfx)foo.o: foo.c

     -MQ target
	 Same  as  -MT,  but it quotes any characters which are special to Make.
	 -MQ '$(objpfx)foo.o' gives

		 $$(objpfx)foo.o: foo.c

	 The default target is automatically quoted, as if it  were  given  with
	 -MQ.

     -MD -MD  is  equivalent to -M -MF file, except that -E is not implied.  The
	 driver determines file based on whether an -o option is given.   If  it
	 is,  the driver uses its argument but with a suffix of .d, otherwise it
	 take the basename of the input file and applies a .d suffix.

	 If -MD is used in conjunction with -E, any -o switch is  understood  to
	 specify  the dependency output file, but if used without -E, each -o is
	 understood to specify a target object file.

	 Since -E is not implied, -MD can be used to generate a dependency  out-
	 put file as a side-effect of the compilation process.

     -MMDLike  -MD  except  mention  only  user  header files, not system header
	 files.

     -fpch-deps
	 When using precompiled headers, this flag will  cause	the  dependency-
	 output  flags	to also list the files from the precompiled header's de-
	 pendencies.  If not specified only  the  precompiled  header  would  be
	 listed  and  not  the	files  that were used to create it because those
	 files are not consulted when a precompiled header is used.

     -fpch-preprocess
	 This option allows use of a precompiled header together  with	-E.   It
	 inserts  a special "#pragma", "#pragma GCC pch_preprocess "<filename>""
	 in the output to mark the place where the precompiled header was found,
	 and its filename.  When -fpreprocessed is in use, GCC	recognizes  this
	 "#pragma" and loads the PCH.

	 This  option is off by default, because the resulting preprocessed out-
	 put is only really suitable as input to GCC.	It  is	switched  on  by
	 -save-temps.

	 You should not write this "#pragma" in your own code, but it is safe to
	 edit the filename if the PCH file is available in a different location.
	 The filename may be absolute or it may be relative to GCC's current di-
	 rectory.

     -x c
     -x c++
     -x assembler-with-cpp
	 Specify  the source language: C, C++, or assembly.  This has nothing to
	 do with standards conformance or extensions; it  merely  selects  which
	 base syntax to expect.  If you give none of these options, cpp will de-
	 duce  the  language from the extension of the source file: .c, .cc, .m,
	 or .S.  Some other common extensions for C++ and assembly are also rec-
	 ognized.  If cpp does not recognize the extension, it	will  treat  the
	 file as C; this is the most generic mode.

	 Note:	Previous  versions of cpp accepted a -lang option which selected
	 both the language and the standards conformance level.  This option has
	 been removed, because it conflicts with the -l option.

     -std=standard
     -ansi
	 Specify the standard to which the code should conform.   Currently  CPP
	 knows about C and C++ standards; others may be added in the future.

	 standard may be one of:

	 "iso9899:1990"
	 "c89"
	     The  ISO  C standard from 1990.  c89 is the customary shorthand for
	     this version of the standard.

	     The -ansi option is equivalent to -std=c89.

	 "iso9899:199409"
	     The 1990 C standard, as amended in 1994.

	 "iso9899:1999"
	 "c99"
	 "iso9899:199x"
	 "c9x"
	     The revised ISO C standard, published  in	December  1999.   Before
	     publication, this was known as C9X.

	 "gnu89"
	     The 1990 C standard plus GNU extensions.  This is the default.

	 "gnu99"
	 "gnu9x"
	     The 1999 C standard plus GNU extensions.

	 "c++98"
	     The 1998 ISO C++ standard plus amendments.

	 "gnu++98"
	     The  same	as  -std=c++98 plus GNU extensions.  This is the default
	     for C++ code.

     -I- Split the include path.  Any directories specified with -I options  be-
	 fore	-I-   are   searched  only  for  headers  requested  with  "#in-
	 clude "file""; they are not searched for "#include <file>".   If  addi-
	 tional  directories  are specified with -I options after the -I-, those
	 directories are searched for all #include directives.

	 In addition, -I- inhibits the use of the directory of the current  file
	 directory  as	the  first search directory for "#include "file"".  This
	 option has been deprecated.

     -nostdinc
	 Do not search the standard system directories for header  files.   Only
	 the  directories  you have specified with -I options (and the directory
	 of the current file, if appropriate) are searched.

     -nostdinc++
	 Do not search for header files in the	C++-specific  standard	directo-
	 ries, but do still search the other standard directories.  (This option
	 is used when building the C++ library.)

     -include file
	 Process  file as if "#include "file"" appeared as the first line of the
	 primary source file.  However, the first directory searched for file is
	 the preprocessor's working directory instead of the directory	contain-
	 ing  the  main  source file.  If not found there, it is searched for in
	 the remainder of the "#include "..."" search chain as normal.

	 If multiple -include options are given, the files are included  in  the
	 order they appear on the command line.

     -imacros file
	 Exactly like -include, except that any output produced by scanning file
	 is  thrown away.  Macros it defines remain defined.  This allows you to
	 acquire all the macros from a header without also processing its decla-
	 rations.

	 All files specified by -imacros are processed before all  files  speci-
	 fied by -include.

     -idirafter dir
	 Search  dir for header files, but do it after all directories specified
	 with -I and the standard system directories have been	exhausted.   dir
	 is treated as a system include directory.

     -iprefix prefix
	 Specify  prefix  as the prefix for subsequent -iwithprefix options.  If
	 the prefix represents a directory, you should include the final /.

     -iwithprefix dir
     -iwithprefixbefore dir
	 Append dir to the prefix specified previously with  -iprefix,	and  add
	 the resulting directory to the include search path.  -iwithprefixbefore
	 puts  it  in  the same place -I would; -iwithprefix puts it where -idi-
	 rafter would.

     -isysroot dir
	 This option is like the --sysroot option, but applies	only  to  header
	 files.  See the --sysroot option for more information.

     -imultilib dir
	 Use  dir  as a subdirectory of the directory containing target-specific
	 C++ headers.

     -isystem dir
	 Search dir for header files, after all directories specified by -I  but
	 before the standard system directories.  Mark it as a system directory,
	 so  that  it gets the same special treatment as is applied to the stan-
	 dard system directories.

     -iquote dir
	 Search dir only for header files requested with "#include "file""; they
	 are not searched for "#include <file>", before all  directories  speci-
	 fied by -I and before the standard system directories.

     -fdollars-in-identifiers
	 Accept $ in identifiers.

     -fextended-identifiers
	 Accept universal character names in identifiers.  This option is exper-
	 imental;  in a future version of GCC, it will be enabled by default for
	 C99 and C++.

     -fpreprocessed
	 Indicate to the preprocessor that the input file has already been  pre-
	 processed.   This suppresses things like macro expansion, trigraph con-
	 version, escaped newline splicing, and processing of  most  directives.
	 The preprocessor still recognizes and removes comments, so that you can
	 pass  a file preprocessed with -C to the compiler without problems.  In
	 this mode the integrated preprocessor is little more than  a  tokenizer
	 for the front ends.

	 -fpreprocessed  is implicit if the input file has one of the extensions
	 .i, .ii or .mi.  These are  the  extensions  that  GCC  uses  for  pre-
	 processed files created by -save-temps.

     -ftabstop=width
	 Set the distance between tab stops.  This helps the preprocessor report
	 correct  column  numbers  in warnings or errors, even if tabs appear on
	 the line.  If the value is less than 1 or greater than 100, the  option
	 is ignored.  The default is 8.

     -fexec-charset=charset
	 Set  the  execution  character  set, used for string and character con-
	 stants.  The default is UTF-8.  charset can be any  encoding  supported
	 by the system's "iconv" library routine.

     -fwide-exec-charset=charset
	 Set  the wide execution character set, used for wide string and charac-
	 ter constants.  The default is UTF-32 or UTF-16, whichever  corresponds
	 to  the width of "wchar_t".  As with -fexec-charset, charset can be any
	 encoding supported by the system's "iconv"  library  routine;	however,
	 you  will  have  problems  with  encodings  that  do not fit exactly in
	 "wchar_t".

     -finput-charset=charset
	 Set the input character set, used for translation  from  the  character
	 set  of the input file to the source character set used by GCC.  If the
	 locale does not specify, or GCC cannot get this  information  from  the
	 locale, the default is UTF-8.	This can be overridden by either the lo-
	 cale  or  this  command line option.  Currently the command line option
	 takes precedence if there's a conflict.  charset can  be  any	encoding
	 supported by the system's "iconv" library routine.

     -fworking-directory
	 Enable  generation  of linemarkers in the preprocessor output that will
	 let the compiler know the current working directory at the time of pre-
	 processing.  When this option is enabled, the preprocessor  will  emit,
	 after	the  initial  linemarker,  a  second linemarker with the current
	 working directory followed by two slashes.  GCC will  use  this  direc-
	 tory,	when  it's  present  in the preprocessed input, as the directory
	 emitted as the current working directory in some debugging  information
	 formats.  This option is implicitly enabled if debugging information is
	 enabled,  but	this  can  be inhibited with the negated form -fno-work-
	 ing-directory.  If the -P flag is present in the command line, this op-
	 tion has no effect, since no "#line" directives are emitted whatsoever.

     -fno-show-column
	 Do not print column numbers in diagnostics.  This may be  necessary  if
	 diagnostics are being scanned by a program that does not understand the
	 column numbers, such as dejagnu.

     -A predicate=answer
	 Make an assertion with the predicate predicate and answer answer.  This
	 form  is  preferred  to  the  older form -A predicate(answer), which is
	 still supported, because it does not use shell special characters.

     -A -predicate=answer
	 Cancel an assertion with the predicate predicate and answer answer.

     -dCHARS
	 CHARS is a sequence of one or more of	the  following	characters,  and
	 must  not  be preceded by a space.  Other characters are interpreted by
	 the compiler proper, or reserved for future versions of GCC, and so are
	 silently ignored.  If you specify characters whose behavior  conflicts,
	 the result is undefined.

	 M   Instead of the normal output, generate a list of #define directives
	     for  all  the macros defined during the execution of the preproces-
	     sor, including predefined macros.	This gives you a way of  finding
	     out what is predefined in your version of the preprocessor.  Assum-
	     ing you have no file foo.h, the command

		     touch foo.h; cpp -dM foo.h

	     will show all the predefined macros.

	 D   Like  M  except in two respects: it does not include the predefined
	     macros, and it outputs both the #define directives and  the  result
	     of  preprocessing.   Both kinds of output go to the standard output
	     file.

	 N   Like D, but emit only the macro names, not their expansions.

	 I   Output #include directives in addition to the result of preprocess-
	     ing.

     -P  Inhibit generation of linemarkers in the output from the  preprocessor.
	 This might be useful when running the preprocessor on something that is
	 not  C  code,	and will be sent to a program which might be confused by
	 the linemarkers.

     -C  Do not discard comments.  All comments are passed through to the output
	 file, except for comments in processed directives,  which  are  deleted
	 along with the directive.

	 You  should  be  prepared for side effects when using -C; it causes the
	 preprocessor to treat comments as tokens in their own right.  For exam-
	 ple, comments appearing at the start of what would be a directive  line
	 have  the  effect  of	turning  that line into an ordinary source line,
	 since the first token on the line is no longer a #.

     -CC Do not discard comments, including during  macro  expansion.	This  is
	 like  -C,  except that comments contained within macros are also passed
	 through to the output file where the macro is expanded.

	 In addition to the side-effects of the -C option, the -CC option causes
	 all C++-style comments inside a macro to be converted to  C-style  com-
	 ments.   This	is to prevent later use of that macro from inadvertently
	 commenting out the remainder of the source line.

	 The -CC option is generally used to support lint comments.

     -traditional-cpp
	 Try to imitate the behavior of old-fashioned C  preprocessors,  as  op-
	 posed to ISO C preprocessors.

     -trigraphs
	 Process  trigraph  sequences.	These are three-character sequences, all
	 starting with ??, that are defined by ISO C to stand for single charac-
	 ters.	For example, ??/ stands for \, so '??/n' is a character constant
	 for a newline.  By default, GCC ignores trigraphs, but in standard-con-
	 forming modes it converts them.  See the -std and -ansi options.

	 The nine trigraphs and their replacements are

		 Trigraph:	 ??(  ??)  ??<	??>  ??=  ??/  ??'  ??!  ??-
		 Replacement:	   [	]    {	  }    #    \	 ^    |    ~

     -remap
	 Enable special code to work around file systems which only permit  very
	 short file names, such as MS-DOS.

     --help
     --target-help
	 Print	text  describing all the command line options instead of prepro-
	 cessing anything.

     -v  Verbose mode.	Print out GNU CPP's version number at the  beginning  of
	 execution, and report the final form of the include path.

     -H  Print	the  name  of each header file used, in addition to other normal
	 activities.  Each name is indented to show how  deep  in  the	#include
	 stack	it  is.  Precompiled header files are also printed, even if they
	 are found to be invalid; an invalid precompiled header file is  printed
	 with ...x and a valid one with ...! .

     -version
     --version
	 Print	out  GNU  CPP's  version number.  With one dash, proceed to pre-
	 process as normal.  With two dashes, exit immediately.

     Passing Options to the Assembler

     You can pass options to the assembler.

     -Wa,option
	 Pass option as an option to the assembler.  If option contains  commas,
	 it is split into multiple options at the commas.

     -Xassembler option
	 Pass  option as an option to the assembler.  You can use this to supply
	 system-specific assembler options which GCC does not know how to recog-
	 nize.

	 If you want to pass an option that takes  an  argument,  you  must  use
	 -Xassembler twice, once for the option and once for the argument.

     Options for Linking

     These  options  come into play when the compiler links object files into an
     executable output file.  They are meaningless if the compiler is not  doing
     a link step.

     object-file-name
	 A file name that does not end in a special recognized suffix is consid-
	 ered  to  name  an  object  file or library.  (Object files are distin-
	 guished from libraries by the linker according to the	file  contents.)
	 If linking is done, these object files are used as input to the linker.

     -c
     -S
     -E  If any of these options is used, then the linker is not run, and object
	 file names should not be used as arguments.

     -llibrary
     -l library
	 Search the library named library when linking.  (The second alternative
	 with  the  library  as a separate argument is only for POSIX compliance
	 and is not recommended.)

	 It makes a difference where in the command you write this  option;  the
	 linker  searches  and processes libraries and object files in the order
	 they are specified.  Thus, foo.o -lz bar.o  searches  library	z  after
	 file  foo.o but before bar.o.	If bar.o refers to functions in z, those
	 functions may not be loaded.

	 The linker searches a standard list of  directories  for  the	library,
	 which is actually a file named liblibrary.a.  The linker then uses this
	 file as if it had been specified precisely by name.

	 The  directories  searched  include several standard system directories
	 plus any that you specify with -L.

	 Normally the files found this way  are  library  files---archive  files
	 whose	members are object files.  The linker handles an archive file by
	 scanning through it for members which define symbols that have  so  far
	 been  referenced  but not defined.  But if the file that is found is an
	 ordinary object file, it is linked in the usual fashion.  The only dif-
	 ference between using an -l option and specifying a file name	is  that
	 -l surrounds library with lib and .a and searches several directories.

     -nostartfiles
	 Do  not  use the standard system startup files when linking.  The stan-
	 dard system libraries are used normally,  unless  -nostdlib  or  -node-
	 faultlibs is used.

     -nodefaultlibs
	 Do  not  use  the standard system libraries when linking.  Only the li-
	 braries you specify will be passed to the linker.  The standard startup
	 files are used normally, unless -nostartfiles is  used.   The	compiler
	 may  generate	calls  to  "memcmp",  "memset",  "memcpy" and "memmove".
	 These entries are usually resolved by entries	in  libc.   These  entry
	 points should be supplied through some other mechanism when this option
	 is specified.

     -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 compiler may generate  calls	to  "memcmp",  "memset",
	 "memcpy"  and "memmove".  These entries are usually resolved by entries
	 in libc.  These entry points should  be  supplied  through  some  other
	 mechanism when this option is specified.

	 One  of the standard libraries bypassed by -nostdlib and -nodefaultlibs
	 is libgcc.a, a library of internal subroutines that GCC uses  to  over-
	 come  shortcomings  of  particular  machines, or special needs for some
	 languages.

	 In most cases, you need libgcc.a even when  you  want	to  avoid  other
	 standard  libraries.	In  other  words,  when you specify -nostdlib or
	 -nodefaultlibs you should usually specify -lgcc as well.  This  ensures
	 that  you have no unresolved references to internal GCC library subrou-
	 tines.  (For example, __main, used to ensure C++ constructors	will  be
	 called.)

     -pieProduce  a position independent executable on targets which support it.
	 For predictable results, you must also specify the same set of  options
	 that  were  used  to  generate code (-fpie, -fPIE, or model suboptions)
	 when you specify this option.

     -rdynamic
	 Pass the flag -export-dynamic to the ELF linker, on targets  that  sup-
	 port  it.  This  instructs the linker to add all symbols, not only used
	 ones, to the dynamic symbol table. This option is needed for some  uses
	 of "dlopen" or to allow obtaining backtraces from within a program.

     -s  Remove all symbol table and relocation information from the executable.

     -static
	 On systems that support dynamic linking, this prevents linking with the
	 shared libraries.  On other systems, this option has no effect.

     -shared
	 Produce  a shared object which can then be linked with other objects to
	 form an executable.  Not all systems support  this  option.   For  pre-
	 dictable  results,  you  must also specify the same set of options that
	 were used to generate code (-fpic, -fPIC, or model suboptions) when you
	 specify this option.[1]

     -shared-libgcc
     -static-libgcc
	 On systems that provide libgcc as a shared library, these options force
	 the use of either the shared or static  version  respectively.   If  no
	 shared  version  of  libgcc was built when the compiler was configured,
	 these options have no effect.

	 There are several situations in which an  application	should	use  the
	 shared  libgcc instead of the static version.	The most common of these
	 is when the application wishes to throw  and  catch  exceptions  across
	 different  shared  libraries.	 In  that case, each of the libraries as
	 well as the application itself should use the shared libgcc.

	 Therefore, the G++ and GCJ  drivers  automatically  add  -shared-libgcc
	 whenever  you	build a shared library or a main executable, because C++
	 and Java programs typically use exceptions, so this is the right  thing
	 to do.

	 If, instead, you use the GCC driver to create shared libraries, you may
	 find  that  they  will not always be linked with the shared libgcc.  If
	 GCC finds, at its configuration time, that you have a non-GNU linker or
	 a GNU linker that does not support option --eh-frame-hdr, it will  link
	 the  shared version of libgcc into shared libraries by default.  Other-
	 wise, it will take advantage of the linker and optimize away the  link-
	 ing  with the shared version of libgcc, linking with the static version
	 of libgcc by default.	This allows exceptions to propagate through such
	 shared libraries, without incurring relocation costs  at  library  load
	 time.

	 However,  if a library or main executable is supposed to throw or catch
	 exceptions, you must link it using the G++ or GCJ driver, as  appropri-
	 ate  for  the	languages  used  in  the  program,  or	using the option
	 -shared-libgcc, such that it is linked with the shared libgcc.

     -symbolic
	 Bind references to global symbols when building a shared object.   Warn
	 about	any  unresolved references (unless overridden by the link editor
	 option -Xlinker -z -Xlinker defs).  Only a few systems support this op-
	 tion.

     -Xlinker option
	 Pass option as an option to the linker.  You can  use	this  to  supply
	 system-specific  linker  options  which GCC does not know how to recog-
	 nize.

	 If you want to pass an option that takes  an  argument,  you  must  use
	 -Xlinker twice, once for the option and once for the argument.  For ex-
	 ample,  to  pass  -assert  definitions, you must write -Xlinker -assert
	 -Xlinker definitions.	It does not work to write -Xlinker "-assert def-
	 initions", because this passes the entire string as a single  argument,
	 which is not what the linker expects.

     -Wl,option
	 Pass  option as an option to the linker.  If option contains commas, it
	 is split into multiple options at the commas.

     -u symbol
	 Pretend the symbol symbol is undefined, to  force  linking  of  library
	 modules  to  define  it.   You can use -u multiple times with different
	 symbols to force loading of additional library modules.

     Options for Directory Search

     These options specify directories to search for header files, for libraries
     and for parts of the compiler:

     -Idir
	 Add the directory 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.   However,  you
	 should  not use this option to add directories that contain vendor-sup-
	 plied system header files (use -isystem for that).   If  you  use  more
	 than one -I option, the directories are scanned in left-to-right order;
	 the standard system directories come after.

	 If  a	standard system include directory, or a directory specified with
	 -isystem, is also specified with -I, the -I  option  will  be	ignored.
	 The  directory  will still be searched but as a system directory at its
	 normal position in the system include chain.  This is	to  ensure  that
	 GCC's	procedure  to  fix buggy system headers and the ordering for the
	 include_next directive are not inadvertently changed.	 If  you  really
	 need to change the search order for system directories, use the -nostd-
	 inc and/or -isystem options.

     -iquotedir
	 Add  the  directory  dir  to  the head of the list of directories to be
	 searched for header files only for the case of  #include  "file";  they
	 are not searched for #include <file>, otherwise just like -I.

     -Ldir
	 Add directory dir to the list of directories to be searched for -l.

     -Bprefix
	 This option specifies where to find the executables, libraries, include
	 files, and data files of the compiler itself.

	 The  compiler	driver	program runs one or more of the subprograms cpp,
	 cc1, as and ld.  It tries prefix as a prefix for each program it  tries
	 to run, both with and without machine/version/.

	 For  each  subprogram to be run, the compiler driver first tries the -B
	 prefix, if any.  If that name is not found, or if -B was not specified,
	 the driver tries two standard prefixes,  which  are  /usr/lib/gcc/  and
	 /usr/local/lib/gcc/.	If  neither of those results in a file name that
	 is found, the unmodified program name is searched for using the  direc-
	 tories specified in your PATH environment variable.

	 The compiler will check to see if the path provided by the -B refers to
	 a directory, and if necessary it will add a directory separator charac-
	 ter at the end of the path.

	 -B  prefixes that effectively specify directory names also apply to li-
	 braries in the linker, because the compiler  translates  these  options
	 into  -L  options for the linker.  They also apply to includes files in
	 the preprocessor, because the compiler translates  these  options  into
	 -isystem  options for the preprocessor.  In this case, the compiler ap-
	 pends include to the prefix.

	 The run-time support file libgcc.a can also be searched for  using  the
	 -B  prefix, if needed.  If it is not found there, the two standard pre-
	 fixes above are tried, and that is all.  The file is left  out  of  the
	 link if it is not found by those means.

	 Another  way  to specify a prefix much like the -B prefix is to use the
	 environment variable GCC_EXEC_PREFIX.

	 As a special kludge, if the path provided by -B is [dir/]stageN/, where
	 N is a number in the range  0	to  9,	then  it  will	be  replaced  by
	 [dir/]include.  This is to help with boot-strapping the compiler.

     -specs=file
	 Process  file	after  the compiler reads in the standard specs file, in
	 order to override the defaults that the gcc driver  program  uses  when
	 determining  what  switches to pass to cc1, cc1plus, as, ld, etc.  More
	 than one -specs=file can be specified on the command line, and they are
	 processed in order, from left to right.

     --sysroot=dir
	 Use dir as the logical root directory for headers and	libraries.   For
	 example,  if the compiler would normally search for headers in /usr/in-
	 clude and libraries in /usr/lib, it will instead search dir/usr/include
	 and dir/usr/lib.

	 If you use both this option and the -isysroot option, then  the  --sys-
	 root  option will apply to libraries, but the -isysroot option will ap-
	 ply to header files.

	 The GNU linker (beginning with version 2.16) has the necessary  support
	 for  this  option.   If  your	linker does not support this option, the
	 header file aspect of --sysroot will still work, but the library aspect
	 will not.

     -I- This option has been deprecated.  Please use -iquote instead for -I di-
	 rectories before the -I- and remove the -I-.  Any directories you spec-
	 ify with -I options before the -I- option are	searched  only	for  the
	 case of #include "file"; they are not searched for #include <file>.

	 If  additional directories are specified with -I options after the -I-,
	 these directories are searched for all #include directives.   (Ordinar-
	 ily all -I directories are used this way.)

	 In  addition,	the -I- option inhibits the use of the current directory
	 (where the current input file came from) as the first search  directory
	 for  #include	"file".  There is no way to override this effect of -I-.
	 With -I. you can specify searching the directory which was current when
	 the compiler was invoked.  That is not exactly the  same  as  what  the
	 preprocessor does by default, but it is often satisfactory.

	 -I-  does  not  inhibit  the use of the standard system directories for
	 header files.	Thus, -I- and -nostdinc are independent.

     Specifying Target Machine and Compiler Version

     The usual way to run GCC is to run  the  executable  called  gcc,	or  <ma-
     chine>-gcc  when  cross-compiling, or <machine>-gcc-<version> to run a ver-
     sion other than the one that was installed last.  Sometimes this is  incon-
     venient, so GCC provides options that will switch to another cross-compiler
     or version.

     -b machine
	 The argument machine specifies the target machine for compilation.

	 The  value  to  use for machine is the same as was specified as the ma-
	 chine type when configuring GCC as a cross-compiler.  For example, if a
	 cross-compiler was configured with configure arm-elf, meaning	to  com-
	 pile  for an arm processor with elf binaries, then you would specify -b
	 arm-elf to run that cross compiler.  Because there  are  other  options
	 beginning with -b, the configuration must contain a hyphen.

     -V version
	 The  argument	version  specifies which version of GCC to run.  This is
	 useful when multiple versions	are  installed.   For  example,  version
	 might be 4.0, meaning to run GCC version 4.0.

     The  -V  and  -b  options	work by running the <machine>-gcc-<version> exe-
     cutable, so there's no real reason to use them if you can just run that di-
     rectly.

     Hardware Models and Configurations

     Earlier we discussed the standard option -b which chooses	among  different
     installed	compilers  for completely different target machines, such as VAX
     vs. 68000 vs. 80386.

     In addition, each of these target machine types can have  its  own  special
     options,  starting with -m, to choose among various hardware models or con-
     figurations---for example, 68010 vs 68020, floating coprocessor or none.  A
     single installed version of the compiler can compile for any model or  con-
     figuration, according to the options specified.

     Some  configurations  of  the  compiler also support additional special op-
     tions, usually for compatibility with other compilers on the same platform.

     ARC Options

     These options are defined for ARC implementations:

     -EL Compile code for little endian mode.  This is the default.

     -EB Compile code for big endian mode.

     -mmangle-cpu
	 Prepend the name of the cpu to all public symbol names.   In  multiple-
	 processor  systems, there are many ARC variants with different instruc-
	 tion and register set characteristics.  This flag  prevents  code  com-
	 piled	for one cpu to be linked with code compiled for another.  No fa-
	 cility exists for handling variants that are "almost identical".   This
	 is an all or nothing option.

     -mcpu=cpu
	 Compile  code for ARC variant cpu.  Which variants are supported depend
	 on the configuration.	All variants support -mcpu=base, this is the de-
	 fault.

     -mtext=text-section
     -mdata=data-section
     -mrodata=readonly-data-section
	 Put functions, data, and readonly data in  text-section,  data-section,
	 and  readonly-data-section  respectively by default.  This can be over-
	 ridden with the "section" attribute.

     ARM Options

     These -m options are defined for Advanced	RISC  Machines	(ARM)  architec-
     tures:

     -mabi=name
	 Generate code for the specified ABI.  Permissible values are: apcs-gnu,
	 atpcs, aapcs, aapcs-linux and iwmmxt.

     -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.  Specifying -fomit-frame-pointer with
	 this option will cause the stack frames not to be  generated  for  leaf
	 functions.  The default is -mno-apcs-frame.

     -mapcs
	 This is a synonym for -mapcs-frame.

     -mthumb-interwork
	 Generate code which supports calling between the ARM and Thumb instruc-
	 tion  sets.  Without this option the two instruction sets cannot be re-
	 liably used inside one program.  The default  is  -mno-thumb-interwork,
	 since slightly larger code is generated when -mthumb-interwork is spec-
	 ified.

     -mno-sched-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 recognizable set
	 of instructions (or in fact one of a choice from a small set of differ-
	 ent function prologues), and this information can be used to locate the
	 start	if functions inside an executable piece of code.  The default is
	 -msched-prolog.

     -mhard-float
	 Generate output containing floating point instructions.   This  is  the
	 default.

     -msoft-float
	 Generate  output containing library calls for floating point.	Warning:
	 the requisite libraries are not available for all  ARM  targets.   Nor-
	 mally	the  facilities  of the machine's usual C compiler are used, but
	 this cannot be done directly in cross-compilation.  You must make  your
	 own arrangements to provide suitable library functions for cross-compi-
	 lation.

	 -msoft-float  changes the calling convention in the output file; there-
	 fore, it is only useful if you compile all of a program with  this  op-
	 tion.	 In  particular,  you need to compile libgcc.a, the library that
	 comes with GCC, with -msoft-float in order for this to work.

     -mfloat-abi=name
	 Specifies which ABI to use for floating point values.	Permissible val-
	 ues are: soft, softfp and hard.

	 soft and hard are equivalent to -msoft-float and  -mhard-float  respec-
	 tively.   softfp  allows the generation of floating point instructions,
	 but still uses the soft-float calling conventions.

     -mlittle-endian
	 Generate code for a processor running in little-endian mode.	This  is
	 the default for all standard configurations.

     -mbig-endian
	 Generate  code  for a processor running in big-endian mode; the default
	 is to compile code for a little-endian processor.

     -mwords-little-endian
	 This option only applies when generating code	for  big-endian  proces-
	 sors.	 Generate  code  for a little-endian word order but a big-endian
	 byte order.  That is, a byte order of the form  32107654.   Note:  this
	 option  should  only be used if you require compatibility with code for
	 big-endian ARM processors generated by versions of the  compiler  prior
	 to 2.8.

     -mcpu=name
	 This  specifies  the  name  of the target ARM processor.  GCC uses this
	 name to determine what kind of instructions it can emit when generating
	 assembly code.  Permissible 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, arm7tdmi-s,	arm8,  strongarm,  strongarm110,  strongarm1100,
	 arm8,	 arm810,  arm9,  arm9e,  arm920,  arm920t,  arm922t,  arm946e-s,
	 arm966e-s,  arm968e-s,  arm926ej-s,   arm940t,   arm9tdmi,   arm10tdmi,
	 arm1020t,   arm1026ej-s,   arm10e,   arm1020e,   arm1022e,  arm1136j-s,
	 arm1136jf-s, mpcore, mpcorenovfp,  arm1176jz-s,  arm1176jzf-s,  xscale,
	 iwmmxt, ep9312.

     -mtune=name
	 This  option  is very similar to the -mcpu= option, except that instead
	 of specifying the actual target processor type, and  hence  restricting
	 which	instructions  can be used, it specifies that GCC should tune the
	 performance of the code as if the target were of the type specified  in
	 this  option, but still choosing the instructions that it will generate
	 based on the cpu specified by a -mcpu= option.  For some ARM  implemen-
	 tations better performance can be obtained by using this option.

     -march=name
	 This  specifies the name of the target ARM architecture.  GCC uses this
	 name to determine what kind of instructions it can emit when generating
	 assembly code.  This option can be used in conjunction with or  instead
	 of  the  -mcpu=  option.   Permissible names are: armv2, armv2a, armv3,
	 armv3m, armv4, armv4t, armv5, armv5t, armv5te, armv6,	armv6j,  iwmmxt,
	 ep9312.

     -mfpu=name
     -mfpe=number
     -mfp=number
	 This  specifies what floating point hardware (or hardware emulation) is
	 available on the target.  Permissible names are: fpa, fpe2, fpe3,  mav-
	 erick,  vfp.  -mfp and -mfpe are synonyms for -mfpu=fpenumber, for com-
	 patibility with older versions of GCC.

	 If -msoft-float is specified this  specifies  the  format  of	floating
	 point values.

     -mstructure-size-boundary=n
	 The  size of all structures and unions will be rounded up to a multiple
	 of the number of bits set by this option.  Permissible values are 8, 32
	 and 64.  The default value varies for different  toolchains.	For  the
	 COFF  targeted toolchain the default value is 8.  A value of 64 is only
	 allowed if the underlying ABI supports it.

	 Specifying the larger number can produce faster, more	efficient  code,
	 but  can  also  increase the size of the program.  Different values are
	 potentially incompatible.  Code compiled with one value  cannot  neces-
	 sarily  expect  to  work  with  code or libraries compiled with another
	 value, if they exchange information using structures or unions.

     -mabort-on-noreturn
	 Generate a call to the function "abort" at  the  end  of  a  "noreturn"
	 function.  It will be executed if the function tries to return.

     -mlong-calls
     -mno-long-calls
	 Tells	the  compiler to perform function calls by first loading the ad-
	 dress of the function into a register and then performing a  subroutine
	 call  on  this  register.  This switch is needed if the target function
	 will lie outside of the 64 megabyte  addressing  range  of  the  offset
	 based version of subroutine call instruction.

	 Even  if  this switch is enabled, not all function calls will be turned
	 into long calls.  The heuristic is  that  static  functions,  functions
	 which	have  the  short-call  attribute,  functions that are inside the
	 scope of a #pragma no_long_calls directive and functions whose  defini-
	 tions	have  already been compiled within the current compilation unit,
	 will not be turned into long calls.  The exception to this rule is that
	 weak function definitions, functions with the	long-call  attribute  or
	 the  section  attribute,  and	functions that are within the scope of a
	 #pragma long_calls directive, will always be turned into long calls.

	 This feature is not enabled  by  default.   Specifying  -mno-long-calls
	 will  restore	the default behavior, as will placing the function calls
	 within the scope of a #pragma	long_calls_off	directive.   Note  these
	 switches  have  no  effect on how the compiler generates code to handle
	 function calls via function pointers.

     -mnop-fun-dllimport
	 Disable support for the "dllimport" attribute.

     -msingle-pic-base
	 Treat the register used for PIC addressing as	read-only,  rather  than
	 loading  it  in the prologue for each function.  The run-time system is
	 responsible for initializing this register with  an  appropriate  value
	 before execution begins.

     -mpic-register=reg
	 Specify the register to be used for PIC addressing.  The default is R10
	 unless stack-checking is enabled, when R9 is used.

     -mcirrus-fix-invalid-insns
	 Insert  NOPs  into  the  instruction  stream to in order to work around
	 problems with invalid Maverick instruction combinations.   This  option
	 is only valid if the -mcpu=ep9312 option has been used to enable gener-
	 ation of instructions for the Cirrus Maverick floating point co-proces-
	 sor.	This option is not enabled by default, since the problem is only
	 present in older Maverick implementations.  The default can  be  re-en-
	 abled by use of the -mno-cirrus-fix-invalid-insns switch.

     -mpoke-function-name
	 Write the name of each function into the text section, directly preced-
	 ing the function prologue.  The generated code is similar to this:

		      t0
			  .ascii "arm_poke_function_name", 0
			  .align
		      t1
			  .word 0xff000000 + (t1 - t0)
		      arm_poke_function_name
			  mov	  ip, sp
			  stmfd   sp!, {fp, ip, lr, pc}
			  sub	  fp, ip, #4

	 When  performing  a stack backtrace, code can inspect the value of "pc"
	 stored at "fp + 0".  If the trace function then looks at location "pc -
	 12" and the top 8 bits are set, then we know that there is  a	function
	 name  embedded  immediately  preceding  this  location  and  has length
	 "((pc[-3]) & 0xff000000)".

     -mthumb
	 Generate code for the 16-bit Thumb instruction set.  The default is  to
	 use the 32-bit ARM instruction set.

     -mtpcs-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 -mno-tpcs-frame.

     -mtpcs-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 -mno-apcs-leaf-frame.

     -mcallee-super-interworking
	 Gives	all  externally  visible functions in the file being compiled an
	 ARM instruction set header which switches to Thumb mode before  execut-
	 ing the rest of the function.	This allows these functions to be called
	 from non-interworking code.

     -mcaller-super-interworking
	 Allows calls via function pointers (including virtual functions) to ex-
	 ecute correctly regardless of whether the target code has been compiled
	 for interworking or not.  There is a small overhead in the cost of exe-
	 cuting a function pointer if this option is enabled.

     -mtp=name
	 Specify  the  access  model  for the thread local storage pointer.  The
	 valid models are soft,  which	generates  calls  to  "__aeabi_read_tp",
	 cp15,	which fetches the thread pointer from "cp15" directly (supported
	 in the arm6k architecture), and auto, which  uses  the  best  available
	 method for the selected processor.  The default setting is auto.

     AVR Options

     These options are defined for AVR implementations:

     -mmcu=mcu
	 Specify ATMEL AVR instruction set or MCU type.

	 Instruction  set avr1 is for the minimal AVR core, not supported by the
	 C compiler, only for assembler  programs  (MCU  types:  at90s1200,  at-
	 tiny10, attiny11, attiny12, attiny15, attiny28).

	 Instruction  set  avr2 (default) is for the classic AVR core with up to
	 8K program memory space (MCU  types:  at90s2313,  at90s2323,  attiny22,
	 at90s2333,   at90s2343,  at90s4414,  at90s4433,  at90s4434,  at90s8515,
	 at90c8534, at90s8535).

	 Instruction set avr3 is for the classic AVR core with up to  128K  pro-
	 gram	memory	space  (MCU  types:  atmega103,  atmega603,  at43usb320,
	 at76c711).

	 Instruction set avr4 is for the enhanced AVR core with up to 8K program
	 memory space (MCU types: atmega8, atmega83, atmega85).

	 Instruction set avr5 is for the enhanced AVR core with up to 128K  pro-
	 gram memory space (MCU types: atmega16, atmega161, atmega163, atmega32,
	 atmega323, atmega64, atmega128, at43usb355, at94k).

     -msize
	 Output instruction sizes to the asm file.

     -minit-stack=N
	 Specify  the  initial	stack  address, which may be a symbol or numeric
	 value, __stack is the default.

     -mno-interrupts
	 Generated code is not compatible with hardware interrupts.   Code  size
	 will be smaller.

     -mcall-prologues
	 Functions  prologues/epilogues  expanded as call to appropriate subrou-
	 tines.  Code size will be smaller.

     -mno-tablejump
	 Do not generate tablejump insns which sometimes increase code size.

     -mtiny-stack
	 Change only the low 8 bits of the stack pointer.

     -mint8
	 Assume int to be 8 bit integer.  This affects the sizes of all types: A
	 char will be 1 byte, an int will be 1 byte, an long will be 2 bytes and
	 long long will be 4 bytes.  Please note that this option does not  com-
	 ply to the C standards, but it will provide you with smaller code size.

     Blackfin Options

     -momit-leaf-frame-pointer
	 Don't	keep  the  frame pointer in a register for leaf functions.  This
	 avoids the instructions to save, set up and restore frame pointers  and
	 makes	an  extra  register  available	in  leaf  functions.  The option
	 -fomit-frame-pointer removes the frame pointer for all functions  which
	 might make debugging harder.

     -mspecld-anomaly
	 When enabled, the compiler will ensure that the generated code does not
	 contain  speculative loads after jump instructions.  This option is en-
	 abled by default.

     -mno-specld-anomaly
	 Don't generate extra code to prevent speculative loads from occurring.

     -mcsync-anomaly
	 When enabled, the compiler will ensure that the generated code does not
	 contain  CSYNC  or  SSYNC  instructions  too  soon  after   conditional
	 branches.  This option is enabled by default.

     -mno-csync-anomaly
	 Don't	generate  extra code to prevent CSYNC or SSYNC instructions from
	 occurring too soon after a conditional branch.

     -mlow-64k
	 When enabled, the compiler is free to take advantage of  the  knowledge
	 that the entire program fits into the low 64k of memory.

     -mno-low-64k
	 Assume that the program is arbitrarily large.	This is the default.

     -mid-shared-library
	 Generate code that supports shared libraries via the library ID method.
	 This allows for execute in place and shared libraries in an environment
	 without virtual memory management.  This option implies -fPIC.

     -mno-id-shared-library
	 Generate  code  that doesn't assume ID based shared libraries are being
	 used.	This is the default.

     -mshared-library-id=n
	 Specified the identification number of the ID based shared library  be-
	 ing compiled.	Specifying a value of 0 will generate more compact code,
	 specifying other values will force the allocation of that number to the
	 current  library  but	is no more space or time efficient than omitting
	 this option.

     -mlong-calls
     -mno-long-calls
	 Tells the compiler to perform function calls by first loading	the  ad-
	 dress	of the function into a register and then performing a subroutine
	 call on this register.  This switch is needed if  the	target	function
	 will  lie  outside  of  the 24 bit addressing range of the offset based
	 version of subroutine call instruction.

	 This feature is not enabled  by  default.   Specifying  -mno-long-calls
	 will  restore the default behavior.  Note these switches have no effect
	 on how the compiler generates code to handle function calls  via  func-
	 tion pointers.

     CRIS Options

     These options are defined specifically for the CRIS ports.

     -march=architecture-type
     -mcpu=architecture-type
	 Generate  code  for the specified architecture.  The choices for archi-
	 tecture-type are v3, v8 and v10 for  respectively  ETRAX 4,  ETRAX 100,
	 and  ETRAX 100 LX.  Default is v0 except for cris-axis-linux-gnu, where
	 the default is v10.

     -mtune=architecture-type
	 Tune to architecture-type everything  applicable  about  the  generated
	 code,	except	for  the ABI and the set of available instructions.  The
	 choices for architecture-type are the same as for  -march=architecture-
	 type.

     -mmax-stack-frame=n
	 Warn when the stack frame of a function exceeds n bytes.

     -melinux-stacksize=n
	 Only  available  with	the cris-axis-aout target.  Arranges for indica-
	 tions in the program to the kernel loader that the stack of the program
	 should be set to n bytes.

     -metrax4
     -metrax100
	 The options -metrax4 and -metrax100  are  synonyms  for  -march=v3  and
	 -march=v8 respectively.

     -mmul-bug-workaround
     -mno-mul-bug-workaround
	 Work  around a bug in the "muls" and "mulu" instructions for CPU models
	 where it applies.  This option is active by default.

     -mpdebug
	 Enable CRIS-specific verbose debug-related information in the	assembly
	 code.	 This option also has the effect to turn off the #NO_APP format-
	 ted-code indicator to the assembler at the beginning  of  the	assembly
	 file.

     -mcc-init
	 Do  not  use  condition-code  results from previous instruction; always
	 emit compare and test instructions before use of condition codes.

     -mno-side-effects
	 Do not emit instructions with side-effects in	addressing  modes  other
	 than post-increment.

     -mstack-align
     -mno-stack-align
     -mdata-align
     -mno-data-align
     -mconst-align
     -mno-const-align
	 These	options  (no-options)  arranges (eliminate arrangements) for the
	 stack-frame, individual data and constants to be aligned for the  maxi-
	 mum  single  data access size for the chosen CPU model.  The default is
	 to arrange for 32-bit alignment.  ABI details such as structure  layout
	 are not affected by these options.

     -m32-bit
     -m16-bit
     -m8-bit
	 Similar  to  the  stack- data- and const-align options above, these op-
	 tions arrange for stack-frame, writable data and constants  to  all  be
	 32-bit, 16-bit or 8-bit aligned.  The default is 32-bit alignment.

     -mno-prologue-epilogue
     -mprologue-epilogue
	 With  -mno-prologue-epilogue, the normal function prologue and epilogue
	 that sets up the stack-frame are omitted and no return instructions  or
	 return  sequences  are generated in the code.	Use this option only to-
	 gether with visual inspection of the compiled code: no warnings or  er-
	 rors  are generated when call-saved registers must be saved, or storage
	 for local variable needs to be allocated.

     -mno-gotplt
     -mgotplt
	 With -fpic and -fPIC, don't  generate	(do  generate)	instruction  se-
	 quences  that load addresses for functions from the PLT part of the GOT
	 rather than (traditional on other architectures) calls to the PLT.  The
	 default is -mgotplt.

     -maout
	 Legacy no-op option only recognized with the cris-axis-aout target.

     -melf
	 Legacy no-op option only recognized with the  cris-axis-elf  and  cris-
	 axis-linux-gnu targets.

     -melinux
	 Only  recognized  with  the  cris-axis-aout  target, where it selects a
	 GNU/linux-like  multilib,  include  files  and  instruction   set   for
	 -march=v8.

     -mlinux
	 Legacy  no-op	option only recognized with the cris-axis-linux-gnu tar-
	 get.

     -simThis  option,	recognized  for  the  cris-axis-aout  and  cris-axis-elf
	 arranges  to link with input-output functions from a simulator library.
	 Code, initialized data and zero-initialized data are allocated consecu-
	 tively.

     -sim2
	 Like -sim, but pass  linker  options  to  locate  initialized	data  at
	 0x40000000 and zero-initialized data at 0x80000000.

     CRX Options

     These options are defined specifically for the CRX ports.

     -mmac
	 Enable  the  use  of  multiply-accumulate instructions. Disabled by de-
	 fault.

     -mpush-args
	 Push instructions will be used to pass outgoing  arguments  when  func-
	 tions are called. Enabled by default.

     Darwin Options

     These  options are defined for all architectures running the Darwin operat-
     ing system.

     FSF GCC on Darwin does not create "fat" object files; it will create an ob-
     ject file for the single architecture that it was built to target.  Apple's
     GCC on Darwin does create "fat" files if multiple -arch options  are  used;
     it does so by running the compiler or linker multiple times and joining the
     results together with lipo.

     The  subtype of the file created (like ppc7400 or ppc970 or i686) is deter-
     mined by the flags that specify the ISA that GCC is targetting, like  -mcpu
     or -march.  The -force_cpusubtype_ALL option can be used to override this.

     The  Darwin  tools  vary  in their behavior when presented with an ISA mis-
     match.  The assembler, as, will only permit instructions to  be  used  that
     are  valid  for the subtype of the file it is generating, so you cannot put
     64-bit instructions in an ppc750 object file.  The linker	for  shared  li-
     braries,  /usr/bin/libtool, will fail and print an error if asked to create
     a shared library with a less restrictive subtype than its input files  (for
     instance,	trying	to  put a ppc970 object file in a ppc7400 library).  The
     linker for executables, ld, will quietly give the executable the  most  re-
     strictive subtype of any of its input files.

     -Fdir
	 Add  the framework directory dir to the head of the list of directories
	 to be searched for header files.   These  directories	are  interleaved
	 with  those  specified by -I options and are scanned in a left-to-right
	 order.

	 A framework directory is a directory with frameworks in it.   A  frame-
	 work  is a directory with a "Headers" and/or "PrivateHeaders" directory
	 contained directly in it that ends in	".framework".	The  name  of  a
	 framework  is	the  name  of this directory excluding the ".framework".
	 Headers associated with the framework are found in one of those two di-
	 rectories, with "Headers" being searched first.  A  subframework  is  a
	 framework  directory  that  is in a framework's "Frameworks" directory.
	 Includes of subframework headers can only  appear  in	a  header  of  a
	 framework  that contains the subframework, or in a sibling subframework
	 header.  Two subframeworks are siblings  if  they  occur  in  the  same
	 framework.   A  subframework  should not have the same name as a frame-
	 work, a warning will be issued if this is violated.  Currently  a  sub-
	 framework  cannot  have subframeworks, in the future, the mechanism may
	 be extended to support this.  The standard frameworks can be  found  in
	 "/System/Library/Frameworks" and "/Library/Frameworks".  An example in-
	 clude	looks  like "#include <Framework/header.h>", where Framework de-
	 notes the name of the framework and header.h is found in the  "Private-
	 Headers" or "Headers" directory.

     -gused
	 Emit debugging information for symbols that are used.	For STABS debug-
	 ging format, this enables -feliminate-unused-debug-symbols.  This is by
	 default ON.

     -gfull
	 Emit debugging information for all symbols and types.

     -mmacosx-version-min=version
	 The  earliest	version  of  MacOS X that this executable will run on is
	 version.  Typical values of version include 10.1, 10.2, and 10.3.9.

	 The default for this option is to make choices that  seem  to	be  most
	 useful.

     -mkernel
	 Enable  kernel  development  mode.   The  -mkernel option sets -static,
	 -fno-common,  -fno-cxa-atexit,  -fno-exceptions,   -fno-non-call-excep-
	 tions,  -fapple-kext,	-fno-weak  and -fno-rtti where applicable.  This
	 mode	also   sets   -mno-altivec,   -msoft-float,   -fno-builtin   and
	 -mlong-branch for PowerPC targets.

     -mone-byte-bool
	 Override  the	defaults  for  bool so that sizeof(bool)==1.  By default
	 sizeof(bool) is 4 when compiling for Darwin/PowerPC and 1 when  compil-
	 ing for Darwin/x86, so this option has no effect on x86.

	 Warning: The -mone-byte-bool switch causes GCC to generate code that is
	 not  binary  compatible with code generated without that switch.  Using
	 this switch may require recompiling all other modules in a program, in-
	 cluding system libraries.  Use this switch to conform to a  non-default
	 data model.

     -mfix-and-continue
     -ffix-and-continue
     -findirect-data
	 Generate code suitable for fast turn around development.  Needed to en-
	 able  gdb to dynamically load ".o" files into already running programs.
	 -findirect-data and -ffix-and-continue are provided for backwards  com-
	 patibility.

     -all_load
	 Loads	all members of static archive libraries.  See man ld(1) for more
	 information.

     -arch_errors_fatal
	 Cause the errors having to do with files that have the wrong  architec-
	 ture to be fatal.

     -bind_at_load
	 Causes  the  output file to be marked such that the dynamic linker will
	 bind all undefined references when the file is loaded or launched.

     -bundle
	 Produce a Mach-o bundle format file.  See man ld(1) for  more	informa-
	 tion.

     -bundle_loader executable
	 This  option  specifies  the  executable that will be loading the build
	 output file being linked.  See man ld(1) for more information.

     -dynamiclib
	 When passed this option, GCC will produce a dynamic library instead  of
	 an executable when linking, using the Darwin libtool command.

     -force_cpusubtype_ALL
	 This  causes  GCC's output file to have the ALL subtype, instead of one
	 controlled by the -mcpu or -march option.

     -allowable_client	client_name
     -client_name
     -compatibility_version
     -current_version
     -dead_strip
     -dependency-file
     -dylib_file
     -dylinker_install_name
     -dynamic
     -exported_symbols_list
     -filelist
     -flat_namespace
     -force_flat_namespace
     -headerpad_max_install_names
     -image_base
     -init
     -install_name
     -keep_private_externs
     -multi_module
     -multiply_defined
     -multiply_defined_unused
     -noall_load
     -no_dead_strip_inits_and_terms
     -nofixprebinding
     -nomultidefs
     -noprebind
     -noseglinkedit
     -pagezero_size
     -prebind
     -prebind_all_twolevel_modules
     -private_bundle
     -read_only_relocs
     -sectalign
     -sectobjectsymbols
     -whyload
     -seg1addr
     -sectcreate
     -sectobjectsymbols
     -sectorder
     -segaddr
     -segs_read_only_addr
     -segs_read_write_addr
     -seg_addr_table
     -seg_addr_table_filename
     -seglinkedit
     -segprot
     -segs_read_only_addr
     -segs_read_write_addr
     -single_module
     -static
     -sub_library
     -sub_umbrella
     -twolevel_namespace
     -umbrella
     -undefined
     -unexported_symbols_list
     -weak_reference_mismatches
     -whatsloaded
	 These options are passed to the Darwin linker.  The Darwin  linker  man
	 page describes them in detail.

     DEC Alpha Options

     These -m options are defined for the DEC Alpha implementations:

     -mno-soft-float
     -msoft-float
	 Use (do not use) the hardware floating-point instructions for floating-
	 point	 operations.   When  -msoft-float  is  specified,  functions  in
	 libgcc.a will be used to  perform  floating-point  operations.   Unless
	 they  are  replaced  by routines that emulate the floating-point opera-
	 tions, or compiled in such a way as to call such  emulations  routines,
	 these	routines will issue floating-point operations.	 If you are com-
	 piling for an Alpha without floating-point operations, you must  ensure
	 that the library is built so as not to call them.

	 Note  that  Alpha implementations without floating-point operations are
	 required to have floating-point registers.

     -mfp-reg
     -mno-fp-regs
	 Generate code that uses (does not use) the floating-point register set.
	 -mno-fp-regs implies -msoft-float.  If the floating-point register  set
	 is not used, floating point operands are passed in integer registers as
	 if  they  were integers and floating-point results are passed in $0 in-
	 stead of $f0.	This is a non-standard calling sequence, so any function
	 with a floating-point argument or return value called by code	compiled
	 with -mno-fp-regs must also be compiled with that option.

	 A  typical  use  of this option is building a kernel that does not use,
	 and hence need not save and restore, any floating-point registers.

     -mieee
	 The Alpha architecture implements floating-point hardware optimized for
	 maximum performance.  It is mostly compliant  with  the  IEEE	floating
	 point	standard.   However, for full compliance, software assistance is
	 required.  This option generates code fully IEEE compliant code  except
	 that the inexact-flag is not maintained (see below).  If this option is
	 turned on, the preprocessor macro "_IEEE_FP" is defined during compila-
	 tion.	 The  resulting  code is less efficient but is able to correctly
	 support denormalized numbers and exceptional IEEE values such as not-a-
	 number and plus/minus infinity.  Other Alpha compilers call this option
	 -ieee_with_no_inexact.

     -mieee-with-inexact
	 This is like -mieee except the generated code also maintains  the  IEEE
	 inexact-flag.	 Turning on this option causes the generated code to im-
	 plement  fully-compliant  IEEE  math.	 In  addition	to   "_IEEE_FP",
	 "_IEEE_FP_EXACT" is defined as a preprocessor macro.  On some Alpha im-
	 plementations	the resulting code may execute significantly slower than
	 the code generated by default.  Since there is very  little  code  that
	 depends  on  the inexact-flag, you should normally not specify this op-
	 tion.	Other Alpha compilers call this option -ieee_with_inexact.

     -mfp-trap-mode=trap-mode
	 This option controls what floating-point  related  traps  are	enabled.
	 Other	Alpha compilers call this option -fptm trap-mode.  The trap mode
	 can be set to one of four values:

	 n   This is the default (normal) setting.  The only traps that are  en-
	     abled are the ones that cannot be disabled in software (e.g., divi-
	     sion by zero trap).

	 u   In  addition to the traps enabled by n, underflow traps are enabled
	     as well.

	 su  Like u, but the instructions are marked to  be  safe  for	software
	     completion (see Alpha architecture manual for details).

	 sui Like su, but inexact traps are enabled as well.

     -mfp-rounding-mode=rounding-mode
	 Selects the IEEE rounding mode.  Other Alpha compilers call this option
	 -fprm rounding-mode.  The rounding-mode can be one of:

	 n   Normal  IEEE rounding mode.  Floating point numbers are rounded to-
	     wards the nearest machine number or towards the even machine number
	     in case of a tie.

	 m   Round towards minus infinity.

	 c   Chopped rounding mode.  Floating point numbers are rounded  towards
	     zero.

	 d   Dynamic  rounding mode.  A field in the floating point control reg-
	     ister (fpcr, see Alpha architecture reference manual) controls  the
	     rounding  mode  in effect.  The C library initializes this register
	     for rounding towards plus infinity.  Thus, unless your program mod-
	     ifies the fpcr, d corresponds to round towards plus infinity.

     -mtrap-precision=trap-precision
	 In the Alpha architecture, floating point traps  are  imprecise.   This
	 means	without  software  assistance it is impossible to recover from a
	 floating trap and program execution normally needs  to  be  terminated.
	 GCC can generate code that can assist operating system trap handlers in
	 determining  the exact location that caused a floating point trap.  De-
	 pending on the requirements of an application, different levels of pre-
	 cisions can be selected:

	 p   Program precision.  This option is the default  and  means  a  trap
	     handler can only identify which program caused a floating point ex-
	     ception.

	 f   Function  precision.   The  trap handler can determine the function
	     that caused a floating point exception.

	 i   Instruction precision.  The trap handler can  determine  the  exact
	     instruction that caused a floating point exception.

	 Other Alpha compilers provide the equivalent options called -scope_safe
	 and -resumption_safe.

     -mieee-conformant
	 This  option marks the generated code as IEEE conformant.  You must not
	 use this option unless you also specify -mtrap-precision=i  and  either
	 -mfp-trap-mode=su  or	-mfp-trap-mode=sui.   Its only effect is to emit
	 the line .eflag 48 in the function prologue of the  generated	assembly
	 file.	 Under	DEC  Unix, this has the effect that IEEE-conformant math
	 library routines will be linked in.

     -mbuild-constants
	 Normally GCC 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 segment at runtime.

	 Use this option to require GCC to construct 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 be-
	 fore it can find the variables and constants in its own data segment.

     -malpha-as
     -mgas
	 Select  whether to generate code to be assembled by the vendor-supplied
	 assembler (-malpha-as) or by the GNU assembler -mgas.

     -mbwx
     -mno-bwx
     -mcix
     -mno-cix
     -mfix
     -mno-fix
     -mmax
     -mno-max
	 Indicate whether GCC should generate code to use the optional BWX, CIX,
	 FIX and MAX instruction sets.	The default is to  use	the  instruction
	 sets  supported  by the CPU type specified via -mcpu= option or that of
	 the CPU on which GCC was built if none was specified.

     -mfloat-vax
     -mfloat-ieee
	 Generate code that uses (does not use)  VAX  F  and  G  floating  point
	 arithmetic instead of IEEE single and double precision.

     -mexplicit-relocs
     -mno-explicit-relocs
	 Older	Alpha  assemblers provided no way to generate symbol relocations
	 except via assembler macros.  Use of these macros does not allow  opti-
	 mal instruction scheduling.  GNU binutils as of version 2.12 supports a
	 new  syntax  that  allows the compiler to explicitly mark which reloca-
	 tions should apply to which instructions.  This option is mostly useful
	 for debugging, as GCC detects the capabilities of the assembler when it
	 is built and sets the default accordingly.

     -msmall-data
     -mlarge-data
	 When -mexplicit-relocs is in effect, static data is  accessed	via  gp-
	 relative  relocations.  When -msmall-data is used, objects 8 bytes long
	 or smaller are placed in a small data area (the  ".sdata"  and  ".sbss"
	 sections) and are accessed via 16-bit relocations off of the $gp regis-
	 ter.	This  limits the size of the small data area to 64KB, but allows
	 the variables to be directly accessed via a single instruction.

	 The default is -mlarge-data.  With this option the data area is limited
	 to just below 2GB.  Programs that require more than 2GB  of  data  must
	 use  "malloc"	or "mmap" to allocate the data in the heap instead of in
	 the program's data segment.

	 When generating code for shared libraries, -fpic  implies  -msmall-data
	 and -fPIC implies -mlarge-data.

     -msmall-text
     -mlarge-text
	 When  -msmall-text  is  used, the compiler assumes that the code of the
	 entire program (or shared library) fits in 4MB, and is  thus  reachable
	 with a branch instruction.  When -msmall-data is used, the compiler can
	 assume that all local symbols share the same $gp value, and thus reduce
	 the number of instructions required for a function call from 4 to 1.

	 The default is -mlarge-text.

     -mcpu=cpu_type
	 Set  the  instruction set and instruction scheduling parameters for ma-
	 chine type cpu_type.  You can specify either the EV style name  or  the
	 corresponding	chip number.  GCC supports scheduling parameters for the
	 EV4, EV5 and EV6 family of processors and will choose the default  val-
	 ues  for the instruction set from the processor you specify.  If you do
	 not specify a processor type, GCC will  default  to  the  processor  on
	 which the compiler was built.

	 Supported values for cpu_type are

	 ev4
	 ev45
	 21064
	     Schedules as an EV4 and has no instruction set extensions.

	 ev5
	 21164
	     Schedules as an EV5 and has no instruction set extensions.

	 ev56
	 21164a
	     Schedules as an EV5 and supports the BWX extension.

	 pca56
	 21164pc
	 21164PC
	     Schedules as an EV5 and supports the BWX and MAX extensions.

	 ev6
	 21264
	     Schedules as an EV6 and supports the BWX, FIX, and MAX extensions.

	 ev67
	 21264a
	     Schedules	as an EV6 and supports the BWX, CIX, FIX, and MAX exten-
	     sions.

     -mtune=cpu_type
	 Set  only  the  instruction  scheduling  parameters  for  machine  type
	 cpu_type.  The instruction set is not changed.

     -mmemory-latency=time
	 Sets  the latency the scheduler should assume for typical memory refer-
	 ences as seen by the application.  This number is highly  dependent  on
	 the  memory access patterns used by the application and the size of the
	 external cache on the machine.

	 Valid options for time are

	 number
	     A decimal number representing clock cycles.

	 L1
	 L2
	 L3
	 mainThe 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.

     DEC Alpha/VMS Options

     These -m options are defined for the DEC Alpha/VMS implementations:

     -mvms-return-codes
	 Return  VMS  condition codes from main.  The default is to return POSIX
	 style condition (e.g. error) codes.

     FRV Options

     -mgpr-32
	 Only use the first 32 general purpose registers.

     -mgpr-64
	 Use all 64 general purpose registers.

     -mfpr-32
	 Use only the first 32 floating point registers.

     -mfpr-64
	 Use all 64 floating point registers

     -mhard-float
	 Use hardware instructions for floating point operations.

     -msoft-float
	 Use library routines for floating point operations.

     -malloc-cc
	 Dynamically allocate condition code registers.

     -mfixed-cc
	 Do not try to dynamically allocate condition code registers,  only  use
	 "icc0" and "fcc0".

     -mdword
	 Change ABI to use double word insns.

     -mno-dword
	 Do not use double word instructions.

     -mdouble
	 Use floating point double instructions.

     -mno-double
	 Do not use floating point double instructions.

     -mmedia
	 Use media instructions.

     -mno-media
	 Do not use media instructions.

     -mmuladd
	 Use multiply and add/subtract instructions.

     -mno-muladd
	 Do not use multiply and add/subtract instructions.

     -mfdpic
	 Select  the  FDPIC  ABI,  that  uses  function descriptors to represent
	 pointers to functions.  Without any PIC/PIE-related options, it implies
	 -fPIE.  With -fpic or -fpie, it assumes GOT entries and small data  are
	 within  a  12-bit range from the GOT base address; with -fPIC or -fPIE,
	 GOT offsets are computed with 32 bits.

     -minline-plt
	 Enable inlining of PLT entries in function calls to functions that  are
	 not known to bind locally.  It has no effect without -mfdpic.	It's en-
	 abled	by  default if optimizing for speed and compiling for shared li-
	 braries (i.e., -fPIC or -fpic), or when an optimization option such  as
	 -O3 or above is present in the command line.

     -mTLS
	 Assume a large TLS segment when generating thread-local code.

     -mtls
	 Do not assume a large TLS segment when generating thread-local code.

     -mgprel-ro
	 Enable the use of "GPREL" relocations in the FDPIC ABI for data that is
	 known to be in read-only sections.  It's enabled by default, except for
	 -fpic	or  -fpie:  even though it may help make the global offset table
	 smaller, it trades 1 instruction for 4.  With -fPIC or -fPIE, it trades
	 3 instructions for 4, one of which may be shared by  multiple	symbols,
	 and  it  avoids  the need for a GOT entry for the referenced symbol, so
	 it's more likely to be a win.	If it is not, -mno-gprel-ro can be  used
	 to disable it.

     -multilib-library-pic
	 Link  with  the (library, not FD) pic libraries.  It's implied by -mli-
	 brary-pic, as well as by -fPIC and -fpic without -mfdpic.   You  should
	 never have to use it explicitly.

     -mlinked-fp
	 Follow the EABI requirement of always creating a frame pointer whenever
	 a  stack frame is allocated.  This option is enabled by default and can
	 be disabled with -mno-linked-fp.

     -mlong-calls
	 Use indirect addressing to call functions outside the current	compila-
	 tion  unit.  This allows the functions to be placed anywhere within the
	 32-bit address space.

     -malign-labels
	 Try to align labels to an 8-byte boundary by inserting  nops  into  the
	 previous  packet.   This option only has an effect when VLIW packing is
	 enabled.  It doesn't create new packets; it merely adds nops to  exist-
	 ing ones.

     -mlibrary-pic
	 Generate position-independent EABI code.

     -macc-4
	 Use only the first four media accumulator registers.

     -macc-8
	 Use all eight media accumulator registers.

     -mpack
	 Pack VLIW instructions.

     -mno-pack
	 Do not pack VLIW instructions.

     -mno-eflags
	 Do not mark ABI switches in e_flags.

     -mcond-move
	 Enable the use of conditional-move instructions (default).

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mno-cond-move
	 Disable the use of conditional-move instructions.

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mscc
	 Enable the use of conditional set instructions (default).

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mno-scc
	 Disable the use of conditional set instructions.

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mcond-exec
	 Enable the use of conditional execution (default).

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mno-cond-exec
	 Disable the use of conditional execution.

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mvliw-branch
	 Run a pass to pack branches into VLIW instructions (default).

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mno-vliw-branch
	 Do not run a pass to pack branches into VLIW instructions.

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mmulti-cond-exec
	 Enable  optimization  of  "&&"  and  "||" in conditional execution (de-
	 fault).

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mno-multi-cond-exec
	 Disable optimization of "&&" and "||" in conditional execution.

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mnested-cond-exec
	 Enable nested conditional execution optimizations (default).

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -mno-nested-cond-exec
	 Disable nested conditional execution optimizations.

	 This switch is mainly for debugging the compiler and will likely be re-
	 moved in a future version.

     -moptimize-membar
	 This switch removes redundant "membar" instructions from  the	compiler
	 generated code.  It is enabled by default.

     -mno-optimize-membar
	 This  switch  disables  the automatic removal of redundant "membar" in-
	 structions from the generated code.

     -mtomcat-stats
	 Cause gas to print out tomcat statistics.

     -mcpu=cpu
	 Select the processor type for which to generate code.	Possible  values
	 are frv, fr550, tomcat, fr500, fr450, fr405, fr400, fr300 and simple.

     GNU/Linux Options

     These -m options are defined for GNU/Linux targets:

     -mglibc
	 Use the GNU C library instead of uClibc.  This is the default except on
	 *-*-linux-*uclibc* targets.

     -muclibc
	 Use  uClibc  instead  of  the	GNU  C	library.  This is the default on
	 *-*-linux-*uclibc* targets.

     H8/300 Options

     These -m options are defined for the H8/300 implementations:

     -mrelax
	 Shorten some address references at link time, when possible;  uses  the
	 linker option -relax.

     -mh Generate code for the H8/300H.

     -ms Generate code for the H8S.

     -mn Generate  code for the H8S and H8/300H in the normal mode.  This switch
	 must be used either with -mh or -ms.

     -ms2600
	 Generate code for the H8S/2600.  This switch must be used with -ms.

     -mint32
	 Make "int" data 32 bits by default.

     -malign-300
	 On the H8/300H and H8S, use the same alignment rules as for the H8/300.
	 The default for the H8/300H and H8S is to align longs and floats  on  4
	 byte  boundaries.   -malign-300  causes  them	to  be aligned on 2 byte
	 boundaries.  This option has no effect on the H8/300.

     HPPA Options

     These -m options are defined for the HPPA family of computers:

     -march=architecture-type
	 Generate code for the specified architecture.	The choices  for  archi-
	 tecture-type  are  1.0  for  PA 1.0, 1.1 for PA 1.1, and 2.0 for PA 2.0
	 processors.  Refer to /usr/lib/sched.models on an HP-UX system  to  de-
	 termine the proper architecture option for your machine.  Code compiled
	 for  lower numbered architectures will run on higher numbered architec-
	 tures, but not the other way around.

     -mpa-risc-1-0
     -mpa-risc-1-1
     -mpa-risc-2-0
	 Synonyms for -march=1.0, -march=1.1, and -march=2.0 respectively.

     -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.

     -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
	 of the conditional jump.

     -mdisable-fpregs
	 Prevent  floating  point registers from being used in any manner.  This
	 is necessary for compiling kernels which perform lazy context switching
	 of floating point registers.  If you use this	option	and  attempt  to
	 perform floating point operations, the compiler will abort.

     -mdisable-indexing
	 Prevent  the  compiler  from using indexing address modes.  This avoids
	 some rather obscure problems when compiling MIG  generated  code  under
	 MACH.

     -mno-space-regs
	 Generate code that assumes the target has no space registers.	This al-
	 lows  GCC  to generate faster indirect calls and use unscaled index ad-
	 dress modes.

	 Such code is suitable for level 0 PA systems and kernels.

     -mfast-indirect-calls
	 Generate code that assumes calls never cross  space  boundaries.   This
	 allows GCC to emit code which performs faster indirect calls.

	 This option will not work in the presence of shared libraries or nested
	 functions.

     -mfixed-range=register-range
	 Generate  code treating the given register range as fixed registers.  A
	 fixed register is one that the register allocator can not use.  This is
	 useful when compiling kernel code.  A register range  is  specified  as
	 two  registers  separated  by	a dash.  Multiple register ranges can be
	 specified separated by a comma.

     -mlong-load-store
	 Generate 3-instruction load and store sequences as  sometimes	required
	 by  the HP-UX 10 linker.  This is equivalent to the +k option to the HP
	 compilers.

     -mportable-runtime
	 Use the portable calling conventions proposed by HP for ELF systems.

     -mgas
	 Enable the use of assembler directives only GAS understands.

     -mschedule=cpu-type
	 Schedule code according to the constraints for the  machine  type  cpu-
	 type.	 The  choices  for cpu-type are 700 7100, 7100LC, 7200, 7300 and
	 8000.	Refer to /usr/lib/sched.models on an HP-UX system  to  determine
	 the  proper scheduling option for your machine.  The default scheduling
	 is 8000.

     -mlinker-opt
	 Enable the optimization pass in the HP-UX linker.  Note this makes sym-
	 bolic debugging impossible.  It also triggers a bug in the HP-UX 8  and
	 HP-UX	9  linkers  in which they give bogus error messages when linking
	 some programs.

     -msoft-float
	 Generate output containing library calls for floating point.	Warning:
	 the  requisite  libraries are not available for all HPPA targets.  Nor-
	 mally the facilities of the machine's usual C compiler  are  used,  but
	 this  cannot be done directly in cross-compilation.  You must make your
	 own arrangements to provide suitable library functions for cross-compi-
	 lation.  The embedded target hppa1.1-*-pro does provide software float-
	 ing point support.

	 -msoft-float changes the calling convention in the output file;  there-
	 fore,	it  is only useful if you compile all of a program with this op-
	 tion.	In particular, you need to compile libgcc.a,  the  library  that
	 comes with GCC, with -msoft-float in order for this to work.

     -msio
	 Generate  the predefine, "_SIO", for server IO.  The default is -mwsio.
	 This generates the  predefines,  "__hp9000s700",  "__hp9000s700__"  and
	 "_WSIO",  for	workstation IO.  These options are available under HP-UX
	 and HI-UX.

     -mgnu-ld
	 Use GNU ld specific options.  This passes -shared to ld when building a
	 shared library.  It is the default when GCC is  configured,  explicitly
	 or  implicitly, with the GNU linker.  This option does not have any af-
	 fect on which ld is called, it only changes what parameters are  passed
	 to  that ld.  The ld that is called is determined by the --with-ld con-
	 figure option, GCC's program search path, and	finally  by  the  user's
	 PATH.	 The  linker  used  by	GCC  can  be  printed  using  which `gcc
	 -print-prog-name=ld`.	This option is only available on the 64 bit  HP-
	 UX GCC, i.e. configured with hppa*64*-*-hpux*.

     -mhp-ld
	 Use  HP  ld  specific	options.   This  passes -b to ld when building a
	 shared library and passes +Accept TypeMismatch to ld on all links.   It
	 is  the  default when GCC is configured, explicitly or implicitly, with
	 the HP linker.  This option does not have any affect  on  which  ld  is
	 called,  it only changes what parameters are passed to that ld.  The ld
	 that is called is determined by the --with-ld configure  option,  GCC's
	 program  search  path, and finally by the user's PATH.  The linker used
	 by GCC can be printed using which `gcc -print-prog-name=ld`.  This  op-
	 tion  is  only  available on the 64 bit HP-UX GCC, i.e. configured with
	 hppa*64*-*-hpux*.

     -mlong-calls
	 Generate code that uses long call sequences.  This ensures that a  call
	 is always able to reach linker generated stubs.  The default is to gen-
	 erate	long  calls only when the distance from the call site to the be-
	 ginning of the function or translation unit, as the case  may	be,  ex-
	 ceeds a predefined limit set by the branch type being used.  The limits
	 for  normal calls are 7,600,000 and 240,000 bytes, respectively for the
	 PA 2.0 and PA	1.X  architectures.   Sibcalls	are  always  limited  at
	 240,000 bytes.

	 Distances  are  measured from the beginning of functions when using the
	 -ffunction-sections   option,	 or   when   using   the    -mgas    and
	 -mno-portable-runtime options together under HP-UX with the SOM linker.

	 It is normally not desirable to use this option as it will degrade per-
	 formance.   However,  it  may be useful in large applications, particu-
	 larly when partial linking is used to build the application.

	 The types of long calls used depends on the capabilities of the  assem-
	 bler  and  linker, and the type of code being generated.  The impact on
	 systems that support long absolute calls, and long  pic  symbol-differ-
	 ence  or pc-relative calls should be relatively small.  However, an in-
	 direct call is used on 32-bit ELF systems in pic code and it  is  quite
	 long.

     -munix=unix-std
	 Generate  compiler  predefines and select a startfile for the specified
	 UNIX standard.  The choices for unix-std are 93, 95 and 98.  93 is sup-
	 ported on all HP-UX versions.	95  is	available  on  HP-UX  10.10  and
	 later.   98  is available on HP-UX 11.11 and later.  The default values
	 are 93 for HP-UX 10.00, 95 for HP-UX 10.10 though to 11.00, and 98  for
	 HP-UX 11.11 and later.

	 -munix=93  provides  the same predefines as GCC 3.3 and 3.4.  -munix=95
	 provides additional predefines for "XOPEN_UNIX" and  "_XOPEN_SOURCE_EX-
	 TENDED",  and	the  startfile	unix95.o.  -munix=98 provides additional
	 predefines   for   "_XOPEN_UNIX",    "_XOPEN_SOURCE_EXTENDED",    "_IN-
	 CLUDE__STDC_A1_SOURCE"  and "_INCLUDE_XOPEN_SOURCE_500", and the start-
	 file unix98.o.

	 It is important to note that this option  changes  the  interfaces  for
	 various  library routines.  It also affects the operational behavior of
	 the C library.  Thus, extreme care is needed in using this option.

	 Library code that is intended to operate with more than one UNIX  stan-
	 dard  must  test,  set and restore the variable __xpg4_extended_mask as
	 appropriate.  Most GNU software doesn't provide this capability.

     -nolibdld
	 Suppress the generation of link options to search  libdld.sl  when  the
	 -static option is specified on HP-UX 10 and later.

     -static
	 The  HP-UX implementation of setlocale in libc has a dependency on lib-
	 dld.sl.  There isn't an archive version of libdld.sl.	Thus,  when  the
	 -static option is specified, special link options are needed to resolve
	 this dependency.

	 On  HP-UX  10	and  later, the GCC driver adds the necessary options to
	 link with libdld.sl when the -static option is specified.  This  causes
	 the  resulting  binary  to be dynamic.  On the 64-bit port, the linkers
	 generate dynamic binaries by default in any case.  The -nolibdld option
	 can be used to prevent the GCC driver from adding these link options.

     -threads
	 Add support for multithreading with the dce thread library under HP-UX.
	 This option sets flags for both the preprocessor and linker.

     Intel 386 and AMD x86-64 Options

     These -m options are defined for the i386 and x86-64 family of computers:

     -mtune=cpu-type
	 Tune to cpu-type everything applicable about the generated code, except
	 for the ABI and the set of available  instructions.   The  choices  for
	 cpu-type are:

	 generic
	     Produce code optimized for the most common IA32/AMD64/EM64T proces-
	     sors.   If  you  know the CPU on which your code will run, then you
	     should   use   the   corresponding   -mtune   option   instead   of
	     -mtune=generic.   But, if you do not know exactly what CPU users of
	     your application will have, then you should use this option.

	     As new processors are deployed in the marketplace, the behavior  of
	     this option will change.  Therefore, if you upgrade to a newer ver-
	     sion  of  GCC, the code generated option will change to reflect the
	     processors that were most common when that version of GCC	was  re-
	     leased.

	     There  is no -march=generic option because -march indicates the in-
	     struction set the compiler can use, and there  is	no  generic  in-
	     struction	set  applicable  to all processors.  In contrast, -mtune
	     indicates the processor (or, in this case,  collection  of  proces-
	     sors) for which the code is optimized.

	 native
	     This selects the CPU to tune for at compilation time by determining
	     the  processor  type of the compiling machine.  Using -mtune=native
	     will produce code optimized for the local machine	under  the  con-
	     straints of the selected instruction set.	Using -march=native will
	     enable  all  instruction  subsets	supported  by  the local machine
	     (hence the result might not run on different machines).

	 i386Original Intel's i386 CPU.

	 i486Intel's i486 CPU.	(No scheduling is implemented for this chip.)

	 i586, pentium
	     Intel Pentium CPU with no MMX support.

	 pentium-mmx
	     Intel PentiumMMX CPU based on Pentium core with MMX instruction set
	     support.

	 pentiumpro
	     Intel PentiumPro CPU.

	 i686Same as "generic", but when used as "march" option, PentiumPro  in-
	     struction set will be used, so the code will run on all i686 family
	     chips.

	 pentium2
	     Intel  Pentium2  CPU  based on PentiumPro core with MMX instruction
	     set support.

	 pentium3, pentium3m
	     Intel Pentium3 CPU based on PentiumPro core with MMX  and	SSE  in-
	     struction set support.

	 pentium-m
	     Low  power version of Intel Pentium3 CPU with MMX, SSE and SSE2 in-
	     struction set support.  Used by Centrino notebooks.

	 pentium4, pentium4m
	     Intel Pentium4 CPU with MMX, SSE and SSE2 instruction set support.

	 prescott
	     Improved version of Intel Pentium4 CPU with MMX, SSE, SSE2 and SSE3
	     instruction set support.

	 nocona
	     Improved version of Intel Pentium4 CPU with 64-bit extensions, MMX,
	     SSE, SSE2 and SSE3 instruction set support.

	 core2
	     Intel Core2 CPU with 64-bit extensions, MMX, SSE,	SSE2,  SSE3  and
	     SSSE3 instruction set support.

	 k6  AMD K6 CPU with MMX instruction set support.

	 k6-2, k6-3
	     Improved versions of AMD K6 CPU with MMX and 3dNOW! instruction set
	     support.

	 athlon, athlon-tbird
	     AMD  Athlon  CPU with MMX, 3dNOW!, enhanced 3dNOW! and SSE prefetch
	     instructions support.

	 athlon-4, athlon-xp, athlon-mp
	     Improved AMD Athlon CPU with MMX, 3dNOW!, enhanced 3dNOW! and  full
	     SSE instruction set support.

	 k8, opteron, athlon64, athlon-fx
	     AMD  K8 core based CPUs with x86-64 instruction set support.  (This
	     supersets MMX, SSE, SSE2, 3dNOW!, enhanced 3dNOW!	and  64-bit  in-
	     struction set extensions.)

	 k8-sse3, opteron-sse3, athlon64-sse3
	     Improved versions of k8, opteron and athlon64 with SSE3 instruction
	     set support.

	 winchip-c6
	     IDT  Winchip  C6 CPU, dealt in same way as i486 with additional MMX
	     instruction set support.

	 winchip2
	     IDT Winchip2 CPU, dealt in same way as i486 with additional MMX and
	     3dNOW!  instruction set support.

	 c3  Via C3 CPU with MMX and 3dNOW! instruction set support.  (No sched-
	     uling is implemented for this chip.)

	 c3-2Via C3-2 CPU with MMX and SSE instruction set support.  (No  sched-
	     uling is implemented for this chip.)

	 geode
	     Embedded AMD CPU with MMX and 3dNOW! instruction set support.

	 While	picking  a  specific cpu-type will schedule things appropriately
	 for that particular chip, the compiler will not generate any code  that
	 does not run on the i386 without the -march=cpu-type option being used.

     -march=cpu-type
	 Generate  instructions  for the machine type cpu-type.  The choices for
	 cpu-type are the same as for -mtune.  Moreover, specifying  -march=cpu-
	 type implies -mtune=cpu-type.

     -mcpu=cpu-type
	 A deprecated synonym for -mtune.

     -m386
     -m486
     -mpentium
     -mpentiumpro
	 These	options  are  synonyms for -mtune=i386, -mtune=i486, -mtune=pen-
	 tium, and -mtune=pentiumpro respectively.  These  synonyms  are  depre-
	 cated.

     -mfpmath=unit
	 Generate  floating  point  arithmetics  for  selected	unit  unit.  The
	 choices for unit are:

	 387 Use the standard 387 floating point coprocessor present majority of
	     chips and emulated otherwise.  Code compiled with this option  will
	     run almost everywhere.  The temporary results are computed in 80bit
	     precision	instead  of precision specified by the type resulting in
	     slightly different results compared to most of  other  chips.   See
	     -ffloat-store for more detailed description.

	     This is the default choice for i386 compiler.

	 sse Use  scalar floating point instructions present in the SSE instruc-
	     tion set.	This instruction set is supported by Pentium3 and  newer
	     chips,  in the AMD line by Athlon-4, Athlon-xp and Athlon-mp chips.
	     The earlier version of SSE instruction  set  supports  only  single
	     precision	arithmetics,  thus  the  double  and  extended precision
	     arithmetics is still done using 387.  Later version,  present  only
	     in  Pentium4 and the future AMD x86-64 chips supports double preci-
	     sion arithmetics too.

	     For the i386 compiler, you need to use  -march=cpu-type,  -msse  or
	     -msse2  switches  to enable SSE extensions and make this option ef-
	     fective.  For the x86-64 compiler, these extensions are enabled  by
	     default.

	     The resulting code should be considerably faster in the majority of
	     cases and avoid the numerical instability problems of 387 code, but
	     may break some existing code that expects temporaries to be 80bit.

	     This is the default choice for the x86-64 compiler.

	 sse,387
	     Attempt to utilize both instruction sets at once.	This effectively
	     double the amount of available registers and on chips with separate
	     execution	units  for 387 and SSE the execution resources too.  Use
	     this option with care, as it is still experimental, because the GCC
	     register allocator does not model separate  functional  units  well
	     resulting in instable performance.

     -masm=dialect
	 Output  asm instructions using selected dialect.  Supported choices are
	 intel or att (the default one).  Darwin does not support intel.

     -mieee-fp
     -mno-ieee-fp
	 Control whether or not the compiler uses IEEE	floating  point  compar-
	 isons.   These handle correctly the case where the result of a compari-
	 son is unordered.

     -msoft-float
	 Generate output containing library calls for floating point.	Warning:
	 the  requisite  libraries are not part of GCC.  Normally the facilities
	 of the machine's usual C compiler are used, but this can't be done  di-
	 rectly  in  cross-compilation.   You must make your own arrangements to
	 provide suitable library functions for cross-compilation.

	 On machines where a function returns  floating  point	results  in  the
	 80387	register  stack, some floating point opcodes may be emitted even
	 if -msoft-float is used.

     -mno-fp-ret-in-387
	 Do not use the FPU registers for return values of functions.

	 The usual calling convention  has  functions  return  values  of  types
	 "float"  and "double" in an FPU register, even if there is no FPU.  The
	 idea is that the operating system should emulate an FPU.

	 The option -mno-fp-ret-in-387 causes such values to be returned in  or-
	 dinary CPU registers instead.

     -mno-fancy-math-387
	 Some  387 emulators do not support the "sin", "cos" and "sqrt" instruc-
	 tions for the 387.  Specify this option to avoid generating  those  in-
	 structions.  This option is the default on FreeBSD, OpenBSD and NetBSD.
	 This  option  is  overridden  when -march indicates that the target cpu
	 will always have an FPU and so the instruction will not need emulation.
	 As of revision 2.6.1, these instructions are not generated  unless  you
	 also use the -funsafe-math-optimizations switch.

     -malign-double
     -mno-align-double
	 Control  whether  GCC	aligns	"double", "long double", and "long long"
	 variables on a two word boundary or  a  one  word  boundary.	Aligning
	 "double"  variables  on a two word boundary will produce code that runs
	 somewhat faster on a Pentium at the expense of more memory.

	 On x86-64, -malign-double is enabled by default.

	 Warning: if you use the -malign-double  switch,  structures  containing
	 the above types will be aligned differently than the published applica-
	 tion binary interface specifications for the 386 and will not be binary
	 compatible with structures in code compiled without that switch.

     -m96bit-long-double
     -m128bit-long-double
	 These switches control the size of "long double" type.  The i386 appli-
	 cation   binary  interface  specifies	the  size  to  be  96  bits,  so
	 -m96bit-long-double is the default in 32 bit mode.

	 Modern architectures (Pentium and newer) would prefer "long double"  to
	 be  aligned  to an 8 or 16 byte boundary.  In arrays or structures con-
	 forming to the ABI, this  would  not  be  possible.   So  specifying  a
	 -m128bit-long-double  will align "long double" to a 16 byte boundary by
	 padding the "long double" with an additional 32 bit zero.

	 In the x86-64 compiler, -m128bit-long-double is the default  choice  as
	 its ABI specifies that "long double" is to be aligned on 16 byte bound-
	 ary.

	 Notice  that  neither	of these options enable any extra precision over
	 the x87 standard of 80 bits for a "long double".

	 Warning: if you override the default value for  your  target  ABI,  the
	 structures  and  arrays  containing "long double" variables will change
	 their size as well as function calling convention for	function  taking
	 "long double" will be modified.  Hence they will not be binary compati-
	 ble with arrays or structures in code compiled without that switch.

     -mmlarge-data-threshold=number
	 When  -mcmodel=medium is specified, the data greater than threshold are
	 placed in large data section.	This value must be the same  across  all
	 object linked into the binary and defaults to 65535.

     -msvr3-shlib
     -mno-svr3-shlib
	 Control whether GCC places uninitialized local variables into the "bss"
	 or  "data"  segments.	 -msvr3-shlib places them into "bss".  These op-
	 tions are meaningful only on System V Release 3.

     -mrtd
	 Use a different function-calling convention, in  which  functions  that
	 take a fixed number of arguments return with the "ret" num instruction,
	 which pops their arguments while returning.  This saves one instruction
	 in the caller since there is no need to pop the arguments there.

	 You can specify that an individual function is called with this calling
	 sequence  with  the  function attribute stdcall.  You can also override
	 the -mrtd option by using the function attribute cdecl.

	 Warning: this calling convention is incompatible with the one	normally
	 used  on  Unix, so you cannot use it if you need to call libraries com-
	 piled with the Unix compiler.

	 Also, you must provide function prototypes for all functions that  take
	 variable numbers of arguments (including "printf"); otherwise incorrect
	 code will be generated for calls to those functions.

	 In  addition,	seriously incorrect code will result if you call a func-
	 tion with too many arguments.	(Normally,  extra  arguments  are  harm-
	 lessly ignored.)

     -mregparm=num
	 Control  how many registers are used to pass integer arguments.  By de-
	 fault, no registers are used to pass arguments, and at most 3 registers
	 can be used.  You can control this behavior for a specific function  by
	 using the function attribute regparm.

	 Warning:  if  you  use  this  switch, and num is nonzero, then you must
	 build all modules with the same value, including any  libraries.   This
	 includes the system libraries and startup modules.

     -msseregparm
	 Use SSE register passing conventions for float and double arguments and
	 return  values.   You can control this behavior for a specific function
	 by using the function attribute sseregparm.

	 Warning: if you use this switch then you must build  all  modules  with
	 the  same value, including any libraries.  This includes the system li-
	 braries and startup modules.

     -mstackrealign
	 Realign the stack at entry.  On the Intel x86, the  -mstackrealign  op-
	 tion will generate an alternate prologue and epilogue that realigns the
	 runtime  stack.   This  supports mixing legacy codes that keep a 4-byte
	 aligned stack with modern codes that keep a 16-byte stack for SSE  com-
	 patibility.   The alternate prologue and epilogue are slower and bigger
	 than the regular ones, and the alternate  prologue  requires  an  extra
	 scratch register; this lowers the number of registers available if used
	 in conjunction with the "regparm" attribute.  The -mstackrealign option
	 is incompatible with the nested function prologue; this is considered a
	 hard error.  See also the attribute "force_align_arg_pointer", applica-
	 ble to individual functions.

     -mpreferred-stack-boundary=num
	 Attempt  to  keep  the stack boundary aligned to a 2 raised to num byte
	 boundary.  If -mpreferred-stack-boundary is not specified, the  default
	 is 4 (16 bytes or 128 bits).

	 On  Pentium and PentiumPro, "double" and "long double" values should be
	 aligned to an 8 byte boundary (see -malign-double) or	suffer	signifi-
	 cant  run  time  performance  penalties.  On Pentium III, the Streaming
	 SIMD Extension (SSE) data type "__m128" may not work properly if it  is
	 not 16 byte aligned.

	 To  ensure  proper  alignment	of  this  values on the stack, the stack
	 boundary must be as aligned as that required by any value stored on the
	 stack.  Further, every function must be generated such  that  it  keeps
	 the stack aligned.  Thus calling a function compiled with a higher pre-
	 ferred  stack	boundary from a function compiled with a lower preferred
	 stack boundary will most likely misalign the stack.  It is  recommended
	 that libraries that use callbacks always use the default setting.

	 This  extra alignment does consume extra stack space, and generally in-
	 creases code size.  Code that is sensitive to stack space  usage,  such
	 as  embedded  systems	and operating system kernels, may want to reduce
	 the preferred alignment to -mpreferred-stack-boundary=2.

     -mmmx
     -mno-mmx
     -msse
     -mno-sse
     -msse2
     -mno-sse2
     -msse3
     -mno-sse3
     -mssse3
     -mno-ssse3
     -m3dnow
     -mno-3dnow
	 These switches enable or disable the use of instructions  in  the  MMX,
	 SSE,  SSE2, SSE3, SSSE3 or 3DNow! extended instruction sets.  These ex-
	 tensions are also available as built-in  functions:  see  X86	Built-in
	 Functions,  for  details of the functions enabled and disabled by these
	 switches.

	 To have SSE/SSE2 instructions generated  automatically  from  floating-
	 point code (as opposed to 387 instructions), see -mfpmath=sse.

	 These	options  will  enable  GCC to use these extended instructions in
	 generated code, even without -mfpmath=sse.  Applications which  perform
	 runtime  CPU  detection  must compile separate files for each supported
	 architecture, using the appropriate flags.   In  particular,  the  file
	 containing  the CPU detection code should be compiled without these op-
	 tions.

     -mpush-args
     -mno-push-args
	 Use PUSH operations to  store	outgoing  parameters.	This  method  is
	 shorter and usually equally fast as method using SUB/MOV operations and
	 is  enabled by default.  In some cases disabling it may improve perfor-
	 mance because of improved scheduling and reduced dependencies.

     -maccumulate-outgoing-args
	 If enabled, the maximum amount of space required for outgoing arguments
	 will be computed in the function prologue.  This is faster on most mod-
	 ern CPUs because of reduced dependencies, improved scheduling	and  re-
	 duced stack usage when preferred stack boundary is not equal to 2.  The
	 drawback  is  a  notable  increase  in  code size.  This switch implies
	 -mno-push-args.

     -mthreads
	 Support thread-safe exception handling on Mingw32.  Code that relies on
	 thread-safe exception handling must compile and link all code with  the
	 -mthreads  option.  When compiling, -mthreads defines -D_MT; when link-
	 ing, it links in a special  thread  helper  library  -lmingwthrd  which
	 cleans up per thread exception handling data.

     -mno-align-stringops
	 Do not align destination of inlined string operations.  This switch re-
	 duces code size and improves performance in case the destination is al-
	 ready aligned, but GCC doesn't know about it.

     -minline-all-stringops
	 By default GCC inlines string operations only when destination is known
	 to be aligned at least to 4 byte boundary.  This enables more inlining,
	 increase code size, but may improve performance of code that depends on
	 fast memcpy, strlen and memset for short lengths.

     -momit-leaf-frame-pointer
	 Don't	keep  the  frame pointer in a register for leaf functions.  This
	 avoids the instructions to save, set up and restore frame pointers  and
	 makes	an  extra  register  available	in  leaf  functions.  The option
	 -fomit-frame-pointer removes the frame pointer for all functions  which
	 might make debugging harder.

     -mtls-direct-seg-refs
     -mno-tls-direct-seg-refs
	 Controls  whether  TLS  variables may be accessed with offsets from the
	 TLS segment register (%gs for 32-bit, %fs for 64-bit), or  whether  the
	 thread  base  pointer	must be added.	Whether or not this is legal de-
	 pends on the operating system, and whether it maps the segment to cover
	 the entire TLS area.

	 For systems that use GNU libc, the default is on.

     These -m switches are supported in addition to  the  above  on  AMD  x86-64
     processors in 64-bit environments.

     -m32
     -m64Generate  code for a 32-bit or 64-bit environment.  The 32-bit environ-
	 ment sets int, long and pointer to 32 bits and generates code that runs
	 on any i386 system.  The 64-bit environment sets int  to  32  bits  and
	 long  and pointer to 64 bits and generates code for AMD's x86-64 archi-
	 tecture. For darwin only the -m64 option turns  off  the  -fno-pic  and
	 -mdynamic-no-pic options.

     -mno-red-zone
	 Do  not use a so called red zone for x86-64 code.  The red zone is man-
	 dated by the x86-64 ABI, it is a 128-byte area beyond the  location  of
	 the stack pointer that will not be modified by signal or interrupt han-
	 dlers	and  therefore	can be used for temporary data without adjusting
	 the stack pointer.  The flag -mno-red-zone disables this red zone.

     -mcmodel=small
	 Generate code for the small code model: the  program  and  its  symbols
	 must be linked in the lower 2 GB of the address space.  Pointers are 64
	 bits.	 Programs  can be statically or dynamically linked.  This is the
	 default code model.

     -mcmodel=kernel
	 Generate code for the kernel code model.  The kernel runs in the  nega-
	 tive  2  GB  of the address space.  This model has to be used for Linux
	 kernel code.

     -mcmodel=medium
	 Generate code for the medium model: The program is linked in the  lower
	 2  GB	of  the address space but symbols can be located anywhere in the
	 address space.  Programs can be statically or dynamically  linked,  but
	 building of shared libraries are not supported with the medium model.

     -mcmodel=large
	 Generate  code  for  the  large  model: This model makes no assumptions
	 about addresses and sizes of sections.  Currently GCC does  not  imple-
	 ment this model.

     IA-64 Options

     These are the -m options defined for the Intel IA-64 architecture.

     -mbig-endian
	 Generate code for a big endian target.  This is the default for HP-UX.

     -mlittle-endian
	 Generate code for a little endian target.  This is the default for AIX5
	 and GNU/Linux.

     -mgnu-as
     -mno-gnu-as
	 Generate (or don't) code for the GNU assembler.  This is the default.

     -mgnu-ld
     -mno-gnu-ld
	 Generate (or don't) code for the GNU linker.  This is the default.

     -mno-pic
	 Generate  code that does not use a global pointer register.  The result
	 is not position independent code, and violates the IA-64 ABI.

     -mvolatile-asm-stop
     -mno-volatile-asm-stop
	 Generate (or don't) a stop bit immediately before  and  after	volatile
	 asm statements.

     -mregister-names
     -mno-register-names
	 Generate  (or	don't)	in,  loc, and out register names for the stacked
	 registers.  This may make assembler output more readable.

     -mno-sdata
     -msdata
	 Disable (or enable) optimizations that  use  the  small  data	section.
	 This may be useful for working around optimizer bugs.

     -mconstant-gp
	 Generate  code  that uses a single constant global pointer value.  This
	 is useful when compiling kernel code.

     -mauto-pic
	 Generate code that is self-relocatable.   This  implies  -mconstant-gp.
	 This is useful when compiling firmware code.

     -minline-float-divide-min-latency
	 Generate  code  for  inline  divides of floating point values using the
	 minimum latency algorithm.

     -minline-float-divide-max-throughput
	 Generate code for inline divides of floating  point  values  using  the
	 maximum throughput algorithm.

     -minline-int-divide-min-latency
	 Generate  code  for  inline divides of integer values using the minimum
	 latency algorithm.

     -minline-int-divide-max-throughput
	 Generate code for inline divides of integer values  using  the  maximum
	 throughput algorithm.

     -minline-sqrt-min-latency
	 Generate  code  for inline square roots using the minimum latency algo-
	 rithm.

     -minline-sqrt-max-throughput
	 Generate code for inline square roots using the maximum throughput  al-
	 gorithm.

     -mno-dwarf2-asm
     -mdwarf2-asm
	 Don't (or do) generate assembler code for the DWARF2 line number debug-
	 ging info.  This may be useful when not using the GNU assembler.

     -mearly-stop-bits
     -mno-early-stop-bits
	 Allow stop bits to be placed earlier than immediately preceding the in-
	 struction  that  triggered  the stop bit.  This can improve instruction
	 scheduling, but does not always do so.

     -mfixed-range=register-range
	 Generate code treating the given register range as fixed registers.   A
	 fixed register is one that the register allocator can not use.  This is
	 useful  when  compiling  kernel code.	A register range is specified as
	 two registers separated by a dash.  Multiple  register  ranges  can  be
	 specified separated by a comma.

     -mtls-size=tls-size
	 Specify  bit  size  of immediate TLS offsets.	Valid values are 14, 22,
	 and 64.

     -mtune=cpu-type
	 Tune the instruction scheduling for a particular CPU, Valid values  are
	 itanium, itanium1, merced, itanium2, and mckinley.

     -mt
     -pthread
	 Add  support  for multithreading using the POSIX threads library.  This
	 option sets flags for both the preprocessor and linker.   It  does  not
	 affect  the  thread  safety  of object code produced by the compiler or
	 that of libraries supplied with it.  These are HP-UX specific flags.

     -milp32
     -mlp64
	 Generate code for a 32-bit or 64-bit environment.  The 32-bit	environ-
	 ment  sets  int,  long  and pointer to 32 bits.  The 64-bit environment
	 sets int to 32 bits and long and pointer to 64 bits.  These  are  HP-UX
	 specific flags.

     -mno-sched-br-data-spec
     -msched-br-data-spec
	 (Dis/En)able  data speculative scheduling before reload.  This will re-
	 sult in generation of the ld.a instructions and the corresponding check
	 instructions (ld.c / chk.a).  The default is 'disable'.

     -msched-ar-data-spec
     -mno-sched-ar-data-spec
	 (En/Dis)able data speculative scheduling after reload.  This  will  re-
	 sult in generation of the ld.a instructions and the corresponding check
	 instructions (ld.c / chk.a).  The default is 'enable'.

     -mno-sched-control-spec
     -msched-control-spec
	 (Dis/En)able control speculative scheduling.  This feature is available
	 only  during  region scheduling (i.e. before reload).	This will result
	 in generation of the ld.s instructions and the corresponding check  in-
	 structions chk.s .  The default is 'disable'.

     -msched-br-in-data-spec
     -mno-sched-br-in-data-spec
	 (En/Dis)able speculative scheduling of the instructions that are depen-
	 dent  on  the	data speculative loads before reload.  This is effective
	 only with -msched-br-data-spec enabled.  The default is 'enable'.

     -msched-ar-in-data-spec
     -mno-sched-ar-in-data-spec
	 (En/Dis)able speculative scheduling of the instructions that are depen-
	 dent on the data speculative loads after  reload.   This  is  effective
	 only with -msched-ar-data-spec enabled.  The default is 'enable'.

     -msched-in-control-spec
     -mno-sched-in-control-spec
	 (En/Dis)able speculative scheduling of the instructions that are depen-
	 dent  on  the	control  speculative loads.  This is effective only with
	 -msched-control-spec enabled.	The default is 'enable'.

     -msched-ldc
     -mno-sched-ldc
	 (En/Dis)able use of simple data speculation checks ld.c .  If disabled,
	 only chk.a instructions will  be  emitted  to	check  data  speculative
	 loads.  The default is 'enable'.

     -mno-sched-control-ldc
     -msched-control-ldc
	 (Dis/En)able  use  of	ld.c  instructions  to check control speculative
	 loads.  If enabled, in case of control speculative load with no  specu-
	 latively  scheduled dependent instructions this load will be emitted as
	 ld.sa and ld.c will be used to check it.  The default is 'disable'.

     -mno-sched-spec-verbose
     -msched-spec-verbose
	 (Dis/En)able printing of the information about speculative motions.

     -mno-sched-prefer-non-data-spec-insns
     -msched-prefer-non-data-spec-insns
	 If enabled, data speculative instructions will be chosen  for	schedule
	 only  if  there are no other choices at the moment.  This will make the
	 use of the data speculation much more	conservative.	The  default  is
	 'disable'.

     -mno-sched-prefer-non-control-spec-insns
     -msched-prefer-non-control-spec-insns
	 If  enabled, control speculative instructions will be chosen for sched-
	 ule only if there are no other choices at the moment.	This  will  make
	 the use of the control speculation much more conservative.  The default
	 is 'disable'.

     -mno-sched-count-spec-in-critical-path
     -msched-count-spec-in-critical-path
	 If enabled, speculative dependencies will be considered during computa-
	 tion  of  the	instructions  priorities.  This will make the use of the
	 speculation a bit more conservative.  The default is 'disable'.

     M32C Options

     -mcpu=name
	 Select the CPU for which code is generated.  name may be one of r8c for
	 the R8C/Tiny series, m16c for the M16C (up to /60)  series,  m32cm  for
	 the M16C/80 series, or m32c for the M32C/80 series.

     -msim
	 Specifies  that  the program will be run on the simulator.  This causes
	 an alternate runtime library to be linked in which supports, for  exam-
	 ple,  file  I/O.  You must not use this option when generating programs
	 that will run on real hardware; you must provide your own  runtime  li-
	 brary for whatever I/O functions are needed.

     -memregs=number
	 Specifies the number of memory-based pseudo-registers GCC will use dur-
	 ing  code  generation.   These  pseudo-registers will be used like real
	 registers, so there is a tradeoff between GCC's ability to fit the code
	 into available registers, and the performance penalty of  using  memory
	 instead  of registers.  Note that all modules in a program must be com-
	 piled with the same value for this option.  Because of that,  you  must
	 not use this option with the default runtime libraries gcc builds.

     M32R/D Options

     These -m options are defined for Renesas M32R/D architectures:

     -m32r2
	 Generate code for the M32R/2.

     -m32rx
	 Generate code for the M32R/X.

     -m32r
	 Generate code for the M32R.  This is the default.

     -mmodel=small
	 Assume  all objects live in the lower 16MB of memory (so that their ad-
	 dresses can be loaded with the "ld24" instruction), and assume all sub-
	 routines are reachable with the "bl" instruction.  This is the default.

	 The addressability of a particular object can be set with  the  "model"
	 attribute.

     -mmodel=medium
	 Assume  objects  may  be anywhere in the 32-bit address space (the com-
	 piler will generate "seth/add3" instructions to load their  addresses),
	 and assume all subroutines are reachable with the "bl" instruction.

     -mmodel=large
	 Assume  objects  may  be anywhere in the 32-bit address space (the com-
	 piler will generate "seth/add3" instructions to load their  addresses),
	 and  assume  subroutines may not be reachable with the "bl" instruction
	 (the compiler will generate the much slower "seth/add3/jl"  instruction
	 sequence).

     -msdata=none
	 Disable  use of the small data area.  Variables will be put into one of
	 .data, bss, or .rodata (unless the "section" attribute has been  speci-
	 fied).  This is the default.

	 The small data area consists of sections .sdata and .sbss.  Objects may
	 be  explicitly  put in the small data area with the "section" attribute
	 using one of these sections.

     -msdata=sdata
	 Put small global and static data in the small data  area,  but  do  not
	 generate special code to reference them.

     -msdata=use
	 Put  small  global and static data in the small data area, and generate
	 special instructions to reference them.

     -G num
	 Put global and static objects less than or equal to num bytes into  the
	 small	data or bss sections instead of the normal data or bss sections.
	 The default value of num is 8.  The -msdata option must be set  to  one
	 of sdata or use for this option to have any effect.

	 All  modules  should be compiled with the same -G num value.  Compiling
	 with different values of num may or may not work;  if	it  doesn't  the
	 linker  will  give an error message---incorrect code will not be gener-
	 ated.

     -mdebug
	 Makes the M32R specific code in the compiler  display	some  statistics
	 that might help in debugging programs.

     -malign-loops
	 Align all loops to a 32-byte boundary.

     -mno-align-loops
	 Do not enforce a 32-byte alignment for loops.	This is the default.

     -missue-rate=number
	 Issue number instructions per cycle.  number can only be 1 or 2.

     -mbranch-cost=number
	 number  can only be 1 or 2.  If it is 1 then branches will be preferred
	 over conditional code, if it is 2, then the opposite will apply.

     -mflush-trap=number
	 Specifies the trap number to use to flush the cache.	The  default  is
	 12.  Valid numbers are between 0 and 15 inclusive.

     -mno-flush-trap
	 Specifies that the cache cannot be flushed by using a trap.

     -mflush-func=name
	 Specifies  the  name  of the operating system function to call to flush
	 the cache.  The default is _flush_cache, but a function call will  only
	 be used if a trap is not available.

     -mno-flush-func
	 Indicates that there is no OS function for flushing the cache.

     M680x0 Options

     These  are the -m options defined for the 68000 series.  The default values
     for these options depends on which style of 68000	was  selected  when  the
     compiler was configured; the defaults for the most common choices are given
     below.

     -m68000
     -mc68000
	 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,  in-
	 cluding the 68008, 68302, 68306, 68307, 68322, 68328 and 68356.

     -m68020
     -mc68020
	 Generate  output for a 68020.	This is the default when the compiler is
	 configured for 68020-based systems.

     -m68881
	 Generate output containing 68881 instructions for floating point.  This
	 is the default for most 68020 systems unless --nfp was  specified  when
	 the compiler was configured.

     -m68030
	 Generate  output for a 68030.	This is the default when the compiler is
	 configured for 68030-based systems.

     -m68040
	 Generate output for a 68040.  This is the default when the compiler  is
	 configured for 68040-based systems.

	 This  option  inhibits the use of 68881/68882 instructions that have to
	 be emulated by software on the 68040.	Use this option  if  your  68040
	 does not have code to emulate those instructions.

     -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.	Use this option if  your
	 68060 does not have code to emulate those instructions.

     -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,  in-
	 cluding  the  68330,  68331,  68332, 68333, 68334, 68336, 68340, 68341,
	 68349 and 68360.

     -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.

     -mcfv4e
	 Generate output for a ColdFire V4e family cpu (e.g.  547x/548x).   This
	 includes use of hardware floating point instructions.

     -m68020-40
	 Generate output for a 68040, without using any of the new instructions.
	 This  results	in code which can run relatively efficiently on either a
	 68020/68881 or a 68030 or a 68040.  The generated  code  does	use  the
	 68881 instructions that are emulated on the 68040.

     -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.

     -msoft-float
	 Generate  output containing library calls for floating point.	Warning:
	 the requisite libraries are not available for all m68k  targets.   Nor-
	 mally	the  facilities  of the machine's usual C compiler are used, but
	 this can't be done directly in cross-compilation.  You must  make  your
	 own arrangements to provide suitable library functions for cross-compi-
	 lation.   The	embedded  targets m68k-*-aout and m68k-*-coff do provide
	 software floating point support.

     -mshort
	 Consider type "int" to be 16 bits wide, like  "short  int".   Addition-
	 ally,	parameters  passed  on	the  stack  are also aligned to a 16-bit
	 boundary even on targets whose API mandates promotion to 32-bit.

     -mnobitfield
	 Do not use the bit-field instructions.  The -m68000, -mcpu32 and -m5200
	 options imply -mnobitfield.

     -mbitfield
	 Do use the bit-field instructions.  The -m68020 option  implies  -mbit-
	 field.   This	is the default if you use a configuration designed for a
	 68020.

     -mrtd
	 Use a different function-calling convention, in  which  functions  that
	 take  a  fixed  number  of arguments return with the "rtd" instruction,
	 which pops their arguments while returning.  This saves one instruction
	 in the caller since there is no need to pop the arguments there.

	 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 "printf"); otherwise incorrect
	 code will be generated for calls to those functions.

	 In  addition,	seriously incorrect code will result if you call a func-
	 tion with too many arguments.	(Normally,  extra  arguments  are  harm-
	 lessly ignored.)

	 The  "rtd"  instruction is supported by the 68010, 68020, 68030, 68040,
	 68060 and CPU32 processors, but not by the 68000 or 5200.

     -malign-int
     -mno-align-int
	 Control whether GCC aligns "int", "long", "long long",  "float",  "dou-
	 ble", and "long double" variables on a 32-bit boundary (-malign-int) or
	 a  16-bit  boundary  (-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.

	 Warning:  if  you use the -malign-int switch, GCC will align structures
	 containing the above types  differently than most published application
	 binary interface specifications for the m68k.

     -mpcrel
	 Use the pc-relative addressing mode of the 68000 directly,  instead  of
	 using	a  global  offset table.  At present, this option implies -fpic,
	 allowing at most a 16-bit offset for pc-relative addressing.  -fPIC  is
	 not  presently  supported  with -mpcrel, though this could be supported
	 for 68020 and higher processors.

     -mno-strict-align
     -mstrict-align
	 Do not (do) assume that unaligned memory references will be handled  by
	 the system.

     -msep-data
	 Generate code that allows the data segment to be located in a different
	 area of memory from the text segment.	This allows for execute in place
	 in  an  environment without virtual memory management.  This option im-
	 plies -fPIC.

     -mno-sep-data
	 Generate code that assumes that the data segment follows the text  seg-
	 ment.	This is the default.

     -mid-shared-library
	 Generate code that supports shared libraries via the library ID method.
	 This allows for execute in place and shared libraries in an environment
	 without virtual memory management.  This option implies -fPIC.

     -mno-id-shared-library
	 Generate  code  that doesn't assume ID based shared libraries are being
	 used.	This is the default.

     -mshared-library-id=n
	 Specified the identification number of the ID based shared library  be-
	 ing compiled.	Specifying a value of 0 will generate more compact code,
	 specifying other values will force the allocation of that number to the
	 current  library  but	is no more space or time efficient than omitting
	 this option.

     M68hc1x Options

     These are the -m options  defined	for  the  68hc11  and  68hc12  microcon-
     trollers.	 The  default values for these options depends on which style of
     microcontroller was selected when the compiler was configured; the defaults
     for the most common choices are given below.

     -m6811
     -m68hc11
	 Generate output for a 68HC11.	This is the default when the compiler is
	 configured for 68HC11-based systems.

     -m6812
     -m68hc12
	 Generate output for a 68HC12.	This is the default when the compiler is
	 configured for 68HC12-based systems.

     -m68S12
     -m68hcs12
	 Generate output for a 68HCS12.

     -mauto-incdec
	 Enable the use of 68HC12 pre and post auto-increment and auto-decrement
	 addressing modes.

     -minmax
     -nominmax
	 Enable the use of 68HC12 min and max instructions.

     -mlong-calls
     -mno-long-calls
	 Treat all calls as being far away (near).  If calls are assumed  to  be
	 far  away, the compiler will use the "call" instruction to call a func-
	 tion and the "rtc" instruction for returning.

     -mshort
	 Consider type "int" to be 16 bits wide, like "short int".

     -msoft-reg-count=count
	 Specify the number of pseudo-soft registers which are used for the code
	 generation.  The maximum number is 32.  Using more pseudo-soft register
	 may or may not result in better code depending on the program.  The de-
	 fault is 4 for 68HC11 and 2 for 68HC12.

     MCore Options

     These are the -m options defined for the Motorola M*Core processors.

     -mhardlit
     -mno-hardlit
	 Inline constants into the code stream if it can be done in two instruc-
	 tions or less.

     -mdiv
     -mno-div
	 Use the divide instruction.  (Enabled by default).

     -mrelax-immediate
     -mno-relax-immediate
	 Allow arbitrary sized immediates in bit operations.

     -mwide-bitfields
     -mno-wide-bitfields
	 Always treat bit-fields as int-sized.

     -m4byte-functions
     -mno-4byte-functions
	 Force all functions to be aligned to a four byte boundary.

     -mcallgraph-data
     -mno-callgraph-data
	 Emit callgraph information.

     -mslow-bytes
     -mno-slow-bytes
	 Prefer word access when reading byte quantities.

     -mlittle-endian
     -mbig-endian
	 Generate code for a little endian target.

     -m210
     -m340
	 Generate code for the 210 processor.

     MIPS Options

     -EB Generate big-endian code.

     -EL Generate little-endian code.  This is the default for mips*el-*-*  con-
	 figurations.

     -march=arch
	 Generate code that will run on arch, which can be the name of a generic
	 MIPS  ISA,  or  the name of a particular processor.  The ISA names are:
	 mips1, mips2, mips3, mips4, mips32, mips32r2, and mips64.  The  proces-
	 sor  names  are:  4kc, 4km, 4kp, 5kc, 5kf, 20kc, 24k, 24kc, 24kf, 24kx,
	 m4k, orion, r2000, r3000, r3900, r4000,  r4400,  r4600,  r4650,  r6000,
	 r8000,  rm7000,  rm9000,  sb1, sr71000, vr4100, vr4111, vr4120, vr4130,
	 vr4300, vr5000, vr5400 and vr5500.  The special value from-abi  selects
	 the  most  compatible architecture for the selected ABI (that is, mips1
	 for 32-bit ABIs and mips3 for 64-bit ABIs).

	 In processor names, a final 000 can be abbreviated as k  (for	example,
	 -march=r2k).  Prefixes are optional, and vr may be written r.

	 GCC defines two macros based on the value of this option.  The first is
	 _MIPS_ARCH,  which  gives the name of target architecture, as a string.
	 The second has the form _MIPS_ARCH_foo, where foo  is	the  capitalized
	 value	of _MIPS_ARCH.	For example, -march=r2000 will set _MIPS_ARCH to
	 "r2000" and define the macro _MIPS_ARCH_R2000.

	 Note that the _MIPS_ARCH macro uses the processor  names  given  above.
	 In  other  words,  it will have the full prefix and will not abbreviate
	 000 as k.  In the case of from-abi, the macro names the resolved archi-
	 tecture (either "mips1" or "mips3").  It names the default architecture
	 when no -march option is given.

     -mtune=arch
	 Optimize for arch.  Among other things, this option  controls	the  way
	 instructions are scheduled, and the perceived cost of arithmetic opera-
	 tions.  The list of arch values is the same as for -march.

	 When this option is not used, GCC will optimize for the processor spec-
	 ified	by  -march.  By using -march and -mtune together, it is possible
	 to generate code that will run on a family of processors, but	optimize
	 the code for one particular member of that family.

	 -mtune  defines the macros _MIPS_TUNE and _MIPS_TUNE_foo, which work in
	 the same way as the -march ones described above.

     -mips1
	 Equivalent to -march=mips1.

     -mips2
	 Equivalent to -march=mips2.

     -mips3
	 Equivalent to -march=mips3.

     -mips4
	 Equivalent to -march=mips4.

     -mips32
	 Equivalent to -march=mips32.

     -mips32r2
	 Equivalent to -march=mips32r2.

     -mips64
	 Equivalent to -march=mips64.

     -mips16
     -mno-mips16
	 Generate (do not generate) MIPS16 code.  If GCC is targetting a  MIPS32
	 or MIPS64 architecture, it will make use of the MIPS16e ASE.

     -mabi=32
     -mabi=o64
     -mabi=n32
     -mabi=64
     -mabi=eabi
	 Generate code for the given ABI.

	 Note  that  the  EABI	has a 32-bit and a 64-bit variant.  GCC normally
	 generates 64-bit code when you select a 64-bit  architecture,	but  you
	 can use -mgp32 to get 32-bit code instead.

	 For	   information	     about	 the	  O64	   ABI,      see
	 <http://gcc.gnu.org/projects/mipso64-abi.html>.

     -mabicalls
     -mno-abicalls
	 Generate (do not generate) code that is suitable for SVR4-style dynamic
	 objects.  -mabicalls is the default for SVR4-based systems.

     -mshared
     -mno-shared
	 Generate (do not generate) code that is fully position-independent, and
	 that can therefore be linked into shared libraries.  This  option  only
	 affects -mabicalls.

	 All  -mabicalls  code	has traditionally been position-independent, re-
	 gardless of options like -fPIC and -fpic.  However,  as  an  extension,
	 the  GNU  toolchain allows executables to use absolute accesses for lo-
	 cally-binding symbols.  It can also use shorter GP  initialization  se-
	 quences  and  generate direct calls to locally-defined functions.  This
	 mode is selected by -mno-shared.

	 -mno-shared depends on binutils 2.16 or higher  and  generates  objects
	 that  can  only  be linked by the GNU linker.	However, the option does
	 not affect the ABI of the final executable; it only affects the ABI  of
	 relocatable objects.  Using -mno-shared will generally make executables
	 both smaller and quicker.

	 -mshared is the default.

     -mxgot
     -mno-xgot
	 Lift  (do  not  lift)	the usual restrictions on the size of the global
	 offset table.

	 GCC normally uses a single instruction to load  values  from  the  GOT.
	 While	this  is  relatively  efficient, it will only work if the GOT is
	 smaller than about 64k.  Anything larger will cause the linker  to  re-
	 port an error such as:

		 relocation truncated to fit: R_MIPS_GOT16 foobar

	 If this happens, you should recompile your code with -mxgot.  It should
	 then  work  with  very  large GOTs, although it will also be less effi-
	 cient, since it will take three instructions to fetch the  value  of  a
	 global symbol.

	 Note  that  some  linkers can create multiple GOTs.  If you have such a
	 linker, you should only need to use -mxgot when a  single  object  file
	 accesses more than 64k's worth of GOT entries.  Very few do.

	 These options have no effect unless GCC is generating position indepen-
	 dent code.

     -mgp32
	 Assume that general-purpose registers are 32 bits wide.

     -mgp64
	 Assume that general-purpose registers are 64 bits wide.

     -mfp32
	 Assume that floating-point registers are 32 bits wide.

     -mfp64
	 Assume that floating-point registers are 64 bits wide.

     -mhard-float
	 Use floating-point coprocessor instructions.

     -msoft-float
	 Do  not  use floating-point coprocessor instructions.	Implement float-
	 ing-point calculations using library calls instead.

     -msingle-float
	 Assume that the floating-point coprocessor only supports  single-preci-
	 sion operations.

     -mdouble-float
	 Assume  that  the  floating-point coprocessor supports double-precision
	 operations.  This is the default.

     -mdsp
     -mno-dsp
	 Use (do not use) the MIPS DSP ASE.

     -mpaired-single
     -mno-paired-single
	 Use (do not use) paired-single floating-point instructions.
	   This option can only be used when generating 64-bit code and requires
	 hardware floating-point support to be enabled.

     -mips3d
     -mno-mips3d
	 Use  (do  not	use)  the  MIPS-3D  ASE.   The	option	-mips3d  implies
	 -mpaired-single.

     -mlong64
	 Force "long" types to be 64 bits wide.  See -mlong32 for an explanation
	 of the default and the way that the pointer size is determined.

     -mlong32
	 Force "long", "int", and pointer types to be 32 bits wide.

	 The  default  size  of "int"s, "long"s and pointers depends on the ABI.
	 All the supported ABIs use 32-bit "int"s.   The  n64  ABI  uses  64-bit
	 "long"s,  as  does  the  64-bit  EABI;  the  others use 32-bit "long"s.
	 Pointers are the same size as "long"s, or the same size as integer reg-
	 isters, whichever is smaller.

     -msym32
     -mno-sym32
	 Assume (do not assume) that all symbols have 32-bit values,  regardless
	 of  the  selected  ABI.   This  option  is  useful  in combination with
	 -mabi=64 and -mno-abicalls because it allows GCC  to  generate  shorter
	 and faster references to symbolic addresses.

     -G num
	 Put  global  and  static items less than or equal to num bytes into the
	 small data or bss section instead of the normal data  or  bss	section.
	 This allows the data to be accessed using a single instruction.

	 All modules should be compiled with the same -G num value.

     -membedded-data
     -mno-embedded-data
	 Allocate  variables  to  the  read-only data section first if possible,
	 then next in the small data section if  possible,  otherwise  in  data.
	 This  gives  slightly	slower	code  than  the default, but reduces the
	 amount of RAM required when executing, and thus may  be  preferred  for
	 some embedded systems.

     -muninit-const-in-rodata
     -mno-uninit-const-in-rodata
	 Put  uninitialized  "const"  variables  in  the read-only data section.
	 This option is only meaningful in conjunction with -membedded-data.

     -msplit-addresses
     -mno-split-addresses
	 Enable (disable) use of the "%hi()" and  "%lo()"  assembler  relocation
	 operators.  This option has been superseded by -mexplicit-relocs but is
	 retained for backwards compatibility.

     -mexplicit-relocs
     -mno-explicit-relocs
	 Use  (do not use) assembler relocation operators when dealing with sym-
	 bolic addresses.  The alternative, selected by -mno-explicit-relocs, is
	 to use assembler macros instead.

	 -mexplicit-relocs is the default if GCC was configured to use an assem-
	 bler that supports relocation operators.

     -mcheck-zero-division
     -mno-check-zero-division
	 Trap (do not trap)  on  integer  division  by	zero.	The  default  is
	 -mcheck-zero-division.

     -mdivide-traps
     -mdivide-breaks
	 MIPS  systems	check for division by zero by generating either a condi-
	 tional trap or a break instruction.  Using  traps  results  in  smaller
	 code,	but is only supported on MIPS II and later.  Also, some versions
	 of the Linux kernel have a bug that prevents trap from  generating  the
	 proper  signal  ("SIGFPE").   Use  -mdivide-traps  to allow conditional
	 traps on architectures that support them and -mdivide-breaks  to  force
	 the use of breaks.

	 The  default  is  usually -mdivide-traps, but this can be overridden at
	 configure time using --with-divide=breaks.  Divide-by-zero  checks  can
	 be completely disabled using -mno-check-zero-division.

     -mmemcpy
     -mno-memcpy
	 Force (do not force) the use of "memcpy()" for non-trivial block moves.
	 The  default  is -mno-memcpy, which allows GCC to inline most constant-
	 sized copies.

     -mlong-calls
     -mno-long-calls
	 Disable (do not disable) use of the "jal" instruction.   Calling  func-
	 tions	using "jal" is more efficient but requires the caller and callee
	 to be in the same 256 megabyte segment.

	 This  option  has  no	effect	on  abicalls  code.   The   default   is
	 -mno-long-calls.

     -mmad
     -mno-mad
	 Enable  (disable)  use  of the "mad", "madu" and "mul" instructions, as
	 provided by the R4650 ISA.

     -mfused-madd
     -mno-fused-madd
	 Enable (disable) use of the floating point multiply-accumulate instruc-
	 tions, when they are available.  The default is -mfused-madd.

	 When multiply-accumulate instructions are used, the intermediate  prod-
	 uct  is calculated to infinite precision and is not subject to the FCSR
	 Flush to Zero bit.  This may be undesirable in some circumstances.

     -nocpp
	 Tell the MIPS assembler to not run its preprocessor over user assembler
	 files (with a .s suffix) when assembling them.

     -mfix-r4000
     -mno-fix-r4000
	 Work around certain R4000 CPU errata:

	 -   A double-word or a variable shift may give an incorrect  result  if
	     executed immediately after starting an integer division.

	 -   A	double-word  or a variable shift may give an incorrect result if
	     executed while an integer multiplication is in progress.

	 -   An integer division may give an incorrect result if  started  in  a
	     delay slot of a taken branch or a jump.

     -mfix-r4400
     -mno-fix-r4400
	 Work around certain R4400 CPU errata:

	 -   A	double-word  or a variable shift may give an incorrect result if
	     executed immediately after starting an integer division.

     -mfix-vr4120
     -mno-fix-vr4120
	 Work around certain VR4120 errata:

	 -   "dmultu" does not always produce the correct result.

	 -   "div" and "ddiv" do not always produce the correct result if one of
	     the operands is negative.

	 The workarounds for the division errata rely on  special  functions  in
	 libgcc.a.   At  present,  these  functions  are  only	provided  by the
	 "mips64vr*-elf" configurations.

	 Other VR4120 errata require a nop to be inserted between certain  pairs
	 of instructions.  These errata are handled by the assembler, not by GCC
	 itself.

     -mfix-vr4130
	 Work  around  the VR4130 "mflo"/"mfhi" errata.  The workarounds are im-
	 plemented by the assembler rather than by GCC, although GCC will  avoid
	 using	"mflo"	and  "mfhi"  if the VR4130 "macc", "macchi", "dmacc" and
	 "dmacchi" instructions are available instead.

     -mfix-sb1
     -mno-fix-sb1
	 Work around certain SB-1 CPU core errata.  (This flag	currently  works
	 around the SB-1 revision 2 "F1" and "F2" floating point errata.)

     -mflush-func=func
     -mno-flush-func
	 Specifies  the  function to call to flush the I and D caches, or to not
	 call any such function.  If called, the function must take the same ar-
	 guments as the common "_flush_func()", that is, the address of the mem-
	 ory range for which the cache is being flushed, the size of the  memory
	 range, and the number 3 (to flush both caches).  The default depends on
	 the  target  GCC was configured for, but commonly is either _flush_func
	 or __cpu_flush.

     -mbranch-likely
     -mno-branch-likely
	 Enable or disable use of Branch Likely instructions, regardless of  the
	 default  for  the selected architecture.  By default, Branch Likely in-
	 structions may be generated if they are supported by the  selected  ar-
	 chitecture.   An  exception  is for the MIPS32 and MIPS64 architectures
	 and processors which implement those architectures; for  those,  Branch
	 Likely instructions will not be generated by default because the MIPS32
	 and MIPS64 architectures specifically deprecate their use.

     -mfp-exceptions
     -mno-fp-exceptions
	 Specifies  whether  FP  exceptions  are  enabled.   This affects how we
	 schedule FP instructions for some processors.	The default is	that  FP
	 exceptions are enabled.

	 For  instance,  on  the SB-1, if FP exceptions are disabled, and we are
	 emitting 64-bit code, then we can use both FP pipes.  Otherwise, we can
	 only use one FP pipe.

     -mvr4130-align
     -mno-vr4130-align
	 The VR4130 pipeline is two-way superscalar, but can only issue two  in-
	 structions  together if the first one is 8-byte aligned.  When this op-
	 tion is enabled, GCC will align pairs of instructions	that  it  thinks
	 should execute in parallel.

	 This option only has an effect when optimizing for the VR4130.  It nor-
	 mally makes code faster, but at the expense of making it bigger.  It is
	 enabled by default at optimization level -O3.

     MMIX Options

     These options are defined for the MMIX:

     -mlibfuncs
     -mno-libfuncs
	 Specify  that	intrinsic  library functions are being compiled, passing
	 all values in registers, no matter the size.

     -mepsilon
     -mno-epsilon
	 Generate floating-point comparison instructions that compare  with  re-
	 spect to the "rE" epsilon register.

     -mabi=mmixware
     -mabi=gnu
	 Generate  code  that  passes function parameters and return values that
	 (in the called function) are seen as registers $0 and up, as opposed to
	 the GNU ABI which uses global registers $231 and up.

     -mzero-extend
     -mno-zero-extend
	 When reading data from memory in sizes shorter than 64  bits,	use  (do
	 not use) zero-extending load instructions by default, rather than sign-
	 extending ones.

     -mknuthdiv
     -mno-knuthdiv
	 Make  the  result of a division yielding a remainder have the same sign
	 as the divisor.  With the default, -mno-knuthdiv, the sign of	the  re-
	 mainder  follows the sign of the dividend.  Both methods are arithmeti-
	 cally valid, the latter being almost exclusively used.

     -mtoplevel-symbols
     -mno-toplevel-symbols
	 Prepend (do not prepend) a : to all global  symbols,  so  the	assembly
	 code can be used with the "PREFIX" assembly directive.

     -melf
	 Generate  an  executable in the ELF format, rather than the default mmo
	 format used by the mmix simulator.

     -mbranch-predict
     -mno-branch-predict
	 Use (do not use) the probable-branch instructions, when  static  branch
	 prediction indicates a probable branch.

     -mbase-addresses
     -mno-base-addresses
	 Generate (do not generate) code that uses base addresses.  Using a base
	 address automatically generates a request (handled by the assembler and
	 the linker) for a constant to be set up in a global register.	The reg-
	 ister	is used for one or more base address requests within the range 0
	 to 255 from the value held in the register.   The  generally  leads  to
	 short and fast code, but the number of different data items that can be
	 addressed is limited.	This means that a program that uses lots of sta-
	 tic data may require -mno-base-addresses.

     -msingle-exit
     -mno-single-exit
	 Force (do not force) generated code to have a single exit point in each
	 function.

     MN10300 Options

     These -m options are defined for Matsushita MN10300 architectures:

     -mmult-bug
	 Generate  code  to  avoid  bugs  in  the  multiply instructions for the
	 MN10300 processors.  This is the default.

     -mno-mult-bug
	 Do not generate code to avoid bugs in the multiply instructions for the
	 MN10300 processors.

     -mam33
	 Generate code which uses features specific to the AM33 processor.

     -mno-am33
	 Do not generate code which uses features specific to the  AM33  proces-
	 sor.  This is the default.

     -mreturn-pointer-on-d0
	 When  generating a function which returns a pointer, return the pointer
	 in both "a0" and "d0".  Otherwise, the pointer is returned only in  a0,
	 and attempts to call such functions without a prototype would result in
	 errors.   Note  that  this  option  is  on  by  default;  use	-mno-re-
	 turn-pointer-on-d0 to disable it.

     -mno-crt0
	 Do not link in the C run-time initialization object file.

     -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.

     MT Options

     These -m options are defined for Morpho MT architectures:

     -march=cpu-type
	 Generate code that will run on cpu-type, which is the name of a  system
	 representing  a  certain  processor type.  Possible values for cpu-type
	 are ms1-64-001, ms1-16-002, ms1-16-003 and ms2.

	 When this option is not used, the default is -march=ms1-16-002.

     -mbacc
	 Use byte loads and stores when generating code.

     -mno-bacc
	 Do not use byte loads and stores when generating code.

     -msim
	 Use simulator runtime

     -mno-crt0
	 Do not link in the C run-time initialization object file crti.o.  Other
	 run-time initialization and termination files	such  as  startup.o  and
	 exit.o are still included on the linker command line.

     PDP-11 Options

     These options are defined for the PDP-11:

     -mfpu
	 Use  hardware	FPP floating point.  This is the default.  (FIS floating
	 point on the PDP-11/40 is not supported.)

     -msoft-float
	 Do not use hardware floating point.

     -mac0
	 Return floating-point results in ac0 (fr0 in Unix assembler syntax).

     -mno-ac0
	 Return floating-point results in memory.  This is the default.

     -m40Generate code for a PDP-11/40.

     -m45Generate code for a PDP-11/45.  This is the default.

     -m10Generate code for a PDP-11/10.

     -mbcopy-builtin
	 Use inline "movmemhi" patterns for copying memory.   This  is	the  de-
	 fault.

     -mbcopy
	 Do not use inline "movmemhi" patterns for copying memory.

     -mint16
     -mno-int32
	 Use 16-bit "int".  This is the default.

     -mint32
     -mno-int16
	 Use 32-bit "int".

     -mfloat64
     -mno-float32
	 Use 64-bit "float".  This is the default.

     -mfloat32
     -mno-float64
	 Use 32-bit "float".

     -mabshi
	 Use "abshi2" pattern.	This is the default.

     -mno-abshi
	 Do not use "abshi2" pattern.

     -mbranch-expensive
	 Pretend  that	branches  are expensive.  This is for experimenting with
	 code generation only.

     -mbranch-cheap
	 Do not pretend that branches are expensive.  This is the default.

     -msplit
	 Generate code for a system with split I&D.

     -mno-split
	 Generate code for a system without split I&D.	This is the default.

     -munix-asm
	 Use Unix assembler syntax.  This is the  default  when  configured  for
	 pdp11-*-bsd.

     -mdec-asm
	 Use  DEC assembler syntax.  This is the default when configured for any
	 PDP-11 target other than pdp11-*-bsd.

     PowerPC Options

     These are listed under

     IBM RS/6000 and PowerPC Options

     These -m options are defined for the IBM RS/6000 and PowerPC:

     -mpower
     -mno-power
     -mpower2
     -mno-power2
     -mpowerpc
     -mno-powerpc
     -mpowerpc-gpopt
     -mno-powerpc-gpopt
     -mpowerpc-gfxopt
     -mno-powerpc-gfxopt
     -mpowerpc64
     -mno-powerpc64
     -mmfcrf
     -mno-mfcrf
     -mpopcntb
     -mno-popcntb
     -mfprnd
     -mno-fprnd
	 GCC supports two related instruction set architectures for the  RS/6000
	 and  PowerPC.	 The  POWER  instruction set are those instructions sup-
	 ported by the rios chip set used in the original  RS/6000  systems  and
	 the  PowerPC  instruction  set  is  the  architecture	of the Freescale
	 MPC5xx, MPC6xx, MPC8xx microprocessors, and the IBM 4xx, 6xx, and  fol-
	 low-on microprocessors.

	 Neither  architecture	is  a  subset  of the other.  However there is a
	 large common subset of instructions supported by both.  An MQ	register
	 is included in processors supporting the POWER architecture.

	 You  use  these  options to specify which instructions are available on
	 the processor you are using.  The default value of these options is de-
	 termined when configuring GCC.  Specifying the -mcpu=cpu_type overrides
	 the  specification  of  these	options.   We  recommend  you  use   the
	 -mcpu=cpu_type option rather than the options listed above.

	 The  -mpower  option allows GCC to generate instructions that are found
	 only in the POWER architecture and to use the MQ register.   Specifying
	 -mpower2  implies  -power  and also allows GCC to generate instructions
	 that are present in the POWER2 architecture but not the original  POWER
	 architecture.

	 The -mpowerpc option allows GCC to generate instructions that are found
	 only  in  the	32-bit	subset	of the PowerPC architecture.  Specifying
	 -mpowerpc-gpopt implies -mpowerpc and also allows GCC to  use	the  op-
	 tional  PowerPC architecture instructions in the General Purpose group,
	 including floating-point square root.	Specifying -mpowerpc-gfxopt  im-
	 plies	-mpowerpc and also allows GCC to use the optional PowerPC archi-
	 tecture instructions in the Graphics  group,  including  floating-point
	 select.

	 The  -mmfcrf option allows GCC to generate the move from condition reg-
	 ister field instruction implemented on the POWER4 processor  and  other
	 processors  that support the PowerPC V2.01 architecture.  The -mpopcntb
	 option allows GCC to generate the popcount and double precision FP rec-
	 iprocal estimate instruction implemented on the  POWER5  processor  and
	 other processors that support the PowerPC V2.02 architecture.	The -mf-
	 prnd option allows GCC to generate the FP round to integer instructions
	 implemented  on the POWER5+ processor and other processors that support
	 the PowerPC V2.03 architecture.

	 The -mpowerpc64 option allows GCC to generate the additional 64-bit in-
	 structions that are found in the full	PowerPC64  architecture  and  to
	 treat GPRs as 64-bit, doubleword quantities.  GCC defaults to -mno-pow-
	 erpc64.

	 If  you specify both -mno-power and -mno-powerpc, GCC will use only the
	 instructions in the common subset of both architectures plus some  spe-
	 cial AIX common-mode calls, and will not use the MQ register.	Specify-
	 ing  both -mpower and -mpowerpc permits GCC to use any instruction from
	 either architecture and to allow use of the MQ register;  specify  this
	 for the Motorola MPC601.

     -mnew-mnemonics
     -mold-mnemonics
	 Select  which	mnemonics  to use in the generated assembler code.  With
	 -mnew-mnemonics, GCC uses the assembler mnemonics defined for the  Pow-
	 erPC  architecture.  With -mold-mnemonics it uses the assembler mnemon-
	 ics defined for the POWER architecture.  Instructions defined	in  only
	 one  architecture  have only one mnemonic; GCC uses that mnemonic irre-
	 spective of which of these options is specified.

	 GCC defaults to the mnemonics appropriate for the architecture in  use.
	 Specifying  -mcpu=cpu_type  sometimes	overrides the value of these op-
	 tion.	Unless you are building a cross-compiler,  you	should	normally
	 not  specify  either -mnew-mnemonics or -mold-mnemonics, but should in-
	 stead accept the default.

     -mcpu=cpu_type
	 Set architecture type, register usage, choice	of  mnemonics,	and  in-
	 struction  scheduling	parameters for machine type cpu_type.  Supported
	 values for cpu_type are 401, 403, 405, 405fp,	440,  440fp,  505,  601,
	 602,  603,  603e,  604, 604e, 620, 630, 740, 7400, 7450, 750, 801, 821,
	 823, 860, 970, 8540, ec603e, G3, G4, G5, power, power2, power3, power4,
	 power5, power5+,  power6,  common,  powerpc,  powerpc64,  rios,  rios1,
	 rios2, rsc, and rs64.

	 -mcpu=common  selects	a  completely generic processor.  Code generated
	 under this option will run on any POWER or PowerPC processor.	GCC will
	 use only the instructions in the common subset of  both  architectures,
	 and  will  not  use  the  MQ register.  GCC assumes a generic processor
	 model for scheduling purposes.

	 -mcpu=power, -mcpu=power2, -mcpu=powerpc, and	-mcpu=powerpc64  specify
	 generic  POWER,  POWER2,  pure  32-bit  PowerPC (i.e., not MPC601), and
	 64-bit PowerPC architecture machine types, with an appropriate, generic
	 processor model assumed for scheduling purposes.

	 The other options specify a specific processor.  Code	generated  under
	 those	options  will run best on that processor, and may not run at all
	 on others.

	 The -mcpu options automatically enable or  disable  the  following  op-
	 tions:   -maltivec,   -mfprnd,   -mhard-float,   -mmfcrf,   -mmultiple,
	 -mnew-mnemonics,  -mpopcntb,  -mpower,  -mpower2,  -mpowerpc64,  -mpow-
	 erpc-gpopt, -mpowerpc-gfxopt, -mstring, -mmulhw, -mdlmzb.  The particu-
	 lar  options set for any particular CPU will vary between compiler ver-
	 sions, depending on what setting seems to produce optimal code for that
	 CPU; it doesn't necessarily reflect the actual hardware's capabilities.
	 If you wish to set an individual option to a particular value, you  may
	 specify it after the -mcpu option, like -mcpu=970 -mno-altivec.

	 On  AIX,  the -maltivec and -mpowerpc64 options are not enabled or dis-
	 abled by the -mcpu option at present because AIX  does  not  have  full
	 support  for these options.  You may still enable or disable them indi-
	 vidually if you're sure it'll work in your environment.

     -mtune=cpu_type
	 Set the instruction scheduling parameters for	machine  type  cpu_type,
	 but  do  not  set  the  architecture type, register usage, or choice of
	 mnemonics, as -mcpu=cpu_type would.  The same values for  cpu_type  are
	 used  for  -mtune as for -mcpu.  If both are specified, the code gener-
	 ated will use the architecture, registers, and mnemonics set by  -mcpu,
	 but the scheduling parameters set by -mtune.

     -mswdiv
     -mno-swdiv
	 Generate  code to compute division as reciprocal estimate and iterative
	 refinement, creating opportunities for increased throughput.  This fea-
	 ture requires: optional PowerPC Graphics  instruction	set  for  single
	 precision  and  FRE  instruction for double precision, assuming divides
	 cannot generate user-visible traps, and the domain values  not  include
	 Infinities, denormals or zero denominator.

     -maltivec
     -mno-altivec
	 Generate  code  that uses (does not use) AltiVec instructions, and also
	 enable the use of built-in functions that allow more direct  access  to
	 the AltiVec instruction set.  You may also need to set -mabi=altivec to
	 adjust the current ABI with AltiVec ABI enhancements.

     -mvrsave
     -mno-vrsave
	 Generate VRSAVE instructions when generating AltiVec code.

     -msecure-plt
	 Generate  code that allows ld and ld.so to build executables and shared
	 libraries with non-exec .plt and .got	sections.   This  is  a  PowerPC
	 32-bit SYSV ABI option.

     -mbss-plt
	 Generate code that uses a BSS .plt section that ld.so fills in, and re-
	 quires  .plt  and  .got sections that are both writable and executable.
	 This is a PowerPC 32-bit SYSV ABI option.

     -misel
     -mno-isel
	 This switch enables or disables the generation of ISEL instructions.

     -misel=yes/no
	 This switch has been deprecated.  Use -misel and -mno-isel instead.

     -mspe
     -mno-spe
	 This switch enables or disables the generation  of  SPE  simd	instruc-
	 tions.

     -mspe=yes/no
	 This option has been deprecated.  Use -mspe and -mno-spe instead.

     -mfloat-gprs=yes/single/double/no
     -mfloat-gprs
	 This switch enables or disables the generation of floating point opera-
	 tions	on  the general purpose registers for architectures that support
	 it.

	 The argument yes or single enables the use of single-precision floating
	 point operations.

	 The argument double enables the  use  of  single  and	double-precision
	 floating point operations.

	 The  argument no disables floating point operations on the general pur-
	 pose registers.

	 This option is currently only available on the MPC854x.

     -m32
     -m64Generate code for 32-bit or 64-bit environments of Darwin and SVR4 tar-
	 gets (including GNU/Linux).  The 32-bit environment sets int, long  and
	 pointer to 32 bits and generates code that runs on any PowerPC variant.
	 The  64-bit  environment sets int to 32 bits and long and pointer to 64
	 bits, and generates code for PowerPC64, as for -mpowerpc64.

     -mfull-toc
     -mno-fp-in-toc
     -mno-sum-in-toc
     -mminimal-toc
	 Modify generation of the TOC (Table Of Contents), which is created  for
	 every	executable  file.  The -mfull-toc option is selected by default.
	 In that case, GCC will allocate at least one TOC entry for each  unique
	 non-automatic	variable reference in your program.  GCC will also place
	 floating-point constants in the TOC.  However, only 16,384 entries  are
	 available in the TOC.

	 If  you  receive a linker error message that saying you have overflowed
	 the available TOC space, you can reduce the amount of	TOC  space  used
	 with  the  -mno-fp-in-toc  and -mno-sum-in-toc options.  -mno-fp-in-toc
	 prevents GCC from putting  floating-point  constants  in  the	TOC  and
	 -mno-sum-in-toc  forces GCC to generate code to calculate the sum of an
	 address and a constant at run-time instead of putting that sum into the
	 TOC.  You may specify one or both of these options.  Each causes GCC to
	 produce very slightly slower and larger code at the expense of conserv-
	 ing TOC space.

	 If you still run out of space in the TOC even when you specify both  of
	 these	options,  specify -mminimal-toc instead.  This option causes GCC
	 to make only one TOC entry for every file.  When you specify  this  op-
	 tion,	GCC  will  produce code that is slower and larger but which uses
	 extremely little TOC space.  You may wish to use this	option	only  on
	 files that contain less frequently executed code.

     -maix64
     -maix32
	 Enable  64-bit  AIX ABI and calling convention: 64-bit pointers, 64-bit
	 "long" type, and the infrastructure needed to support them.  Specifying
	 -maix64 implies -mpowerpc64 and -mpowerpc, while -maix32  disables  the
	 64-bit ABI and implies -mno-powerpc64.  GCC defaults to -maix32.

     -mxl-compat
     -mno-xl-compat
	 Produce  code	that  conforms more closely to IBM XL compiler semantics
	 when using AIX-compatible ABI.  Pass floating-point arguments to proto-
	 typed functions beyond the register save area (RSA) on the stack in ad-
	 dition to argument FPRs.  Do not assume that most significant double in
	 128-bit long double value is properly rounded when comparing values and
	 converting to double.	Use XL symbol names for long double support rou-
	 tines.

	 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  ad-
	 dress of its arguments with fewer arguments than declared.  IBM XL com-
	 pilers 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 neces-
	 sary when calling subroutines compiled by IBM XL compilers without  op-
	 timization.

     -mpeSupport  IBM RS/6000 SP 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 (/usr/lpp/ppe.poe/), or the specs file must be overridden with
	 the -specs= option to specify the appropriate directory location.   The
	 Parallel  Environment	does not support threads, so the -mpe option and
	 the -pthread option are incompatible.

     -malign-natural
     -malign-power
	 On AIX, 32-bit Darwin, and 64-bit PowerPC GNU/Linux,  the  option  -ma-
	 lign-natural  overrides the ABI-defined alignment of larger types, such
	 as floating-point doubles, on their natural size-based  boundary.   The
	 option  -malign-power	instructs GCC to follow the ABI-specified align-
	 ment rules.  GCC defaults to the standard alignment defined in the ABI.

	 On 64-bit Darwin, natural alignment is the default,  and  -malign-power
	 is not supported.

     -msoft-float
     -mhard-float
	 Generate code that does not use (uses) the floating-point register set.
	 Software   floating   point  emulation  is  provided  if  you	use  the
	 -msoft-float option, and pass the option to GCC when linking.

     -mmultiple
     -mno-multiple
	 Generate code that uses (does not use) the load multiple word	instruc-
	 tions and the store multiple word instructions.  These instructions are
	 generated  by	default  on  POWER systems, and not generated on PowerPC
	 systems.  Do not use -mmultiple on little endian PowerPC systems, since
	 those instructions do not work when the processor is in  little  endian
	 mode.	 The  exceptions are PPC740 and PPC750 which permit the instruc-
	 tions usage in little endian mode.

     -mstring
     -mno-string
	 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, and not  generated  on	PowerPC  systems.   Do	not  use
	 -mstring  on little endian PowerPC systems, since those instructions do
	 not work when the processor is in little endian mode.	 The  exceptions
	 are PPC740 and PPC750 which permit the instructions usage in little en-
	 dian mode.

     -mupdate
     -mno-update
	 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
	 -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  sig-
	 nals may get corrupted data.

     -mfused-madd
     -mno-fused-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.

     -mmulhw
     -mno-mulhw
	 Generate  code that uses (does not use) the half-word multiply and mul-
	 tiply-accumulate instructions on the IBM 405 and 440 processors.  These
	 instructions are generated by default when targetting those processors.

     -mdlmzb
     -mno-dlmzb
	 Generate code that uses (does not use) the string-search dlmzb instruc-
	 tion on the IBM 405 and 440 processors.  This instruction is  generated
	 by default when targetting those processors.

     -mno-bit-align
     -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.

	 For example, by default a structure containing nothing but 8 "unsigned"
	 bit-fields of length 1 would be aligned to a 4 byte boundary and have a
	 size of 4 bytes.  By  using  -mno-bit-align,  the  structure  would  be
	 aligned to a 1 byte boundary and be one byte in size.

     -mno-strict-align
     -mstrict-align
	 On  System V.4 and embedded PowerPC systems do not (do) assume that un-
	 aligned memory references will be handled by the system.

     -mrelocatable
     -mno-relocatable
	 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 -mrelocatable on any module, all objects linked  together	must  be
	 compiled with -mrelocatable or -mrelocatable-lib.

     -mrelocatable-lib
     -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 -mrelocatable-lib can be linked with either modules  com-
	 piled	without -mrelocatable and -mrelocatable-lib or with modules com-
	 piled with the -mrelocatable options.

     -mno-toc
     -mtoc
	 On System V.4 and embedded PowerPC systems do not (do) assume that reg-
	 ister 2 contains a pointer to a global area pointing to  the  addresses
	 used in the program.

     -mlittle
     -mlittle-endian
	 On System V.4 and embedded PowerPC systems compile code for the proces-
	 sor  in  little endian mode.  The -mlittle-endian option is the same as
	 -mlittle.

     -mbig
     -mbig-endian
	 On System V.4 and embedded PowerPC systems compile code for the proces-
	 sor in big endian mode.  The -mbig-endian option is the same as -mbig.

     -mdynamic-no-pic
	 On Darwin and Mac OS X systems, compile code so that it is not relocat-
	 able, but that its external references are relocatable.  The  resulting
	 code is suitable for applications, but not shared libraries.

     -mprioritize-restricted-insns=priority
	 This option controls the priority that is assigned to dispatch-slot re-
	 stricted  instructions during the second scheduling pass.  The argument
	 priority takes the value 0/1/2 to assign no/highest/second-highest pri-
	 ority to dispatch slot restricted instructions.

     -msched-costly-dep=dependence_type
	 This option controls which dependences are  considered  costly  by  the
	 target  during  instruction  scheduling.   The argument dependence_type
	 takes one of the following values: no: no dependence  is  costly,  all:
	 all  dependences are costly, true_store_to_load: a true dependence from
	 store to load is costly, store_to_load: any dependence  from  store  to
	 load  is  costly,  number:  any  dependence  which latency >= number is
	 costly.

     -minsert-sched-nops=scheme
	 This option controls which nop insertion scheme will be used during the
	 second scheduling pass.  The argument scheme takes one of the following
	 values: no: Don't insert nops.  pad: Pad with nops any  dispatch  group
	 which	has  vacant  issue slots, according to the scheduler's grouping.
	 regroup_exact: Insert nops to force costly dependent insns  into  sepa-
	 rate groups.  Insert exactly as many nops as needed to force an insn to
	 a  new  group,  according to the estimated processor grouping.  number:
	 Insert nops to force costly dependent insns into separate groups.   In-
	 sert number nops to force an insn to a new group.

     -mcall-sysv
	 On  System  V.4 and embedded PowerPC systems compile code using calling
	 conventions that adheres to the March 1995 draft of the System V Appli-
	 cation Binary Interface, PowerPC processor supplement.  This is the de-
	 fault unless you configured GCC using powerpc-*-eabiaix.

     -mcall-sysv-eabi
	 Specify both -mcall-sysv and -meabi options.

     -mcall-sysv-noeabi
	 Specify both -mcall-sysv and -mno-eabi options.

     -mcall-solaris
	 On System V.4 and embedded PowerPC systems compile code for the Solaris
	 operating system.

     -mcall-linux
	 On System V.4 and embedded PowerPC systems compile code for the  Linux-
	 based GNU system.

     -mcall-gnu
	 On  System  V.4 and embedded PowerPC systems compile code for the Hurd-
	 based GNU system.

     -mcall-netbsd
	 On System V.4 and embedded PowerPC systems compile code for the  NetBSD
	 operating system.

     -maix-struct-return
	 Return all structures in memory (as specified by the AIX ABI).

     -msvr4-struct-return
	 Return  structures  smaller  than 8 bytes in registers (as specified by
	 the SVR4 ABI).

     -mabi=abi-type
	 Extend the current ABI with a particular extension, or remove such  ex-
	 tension.   Valid  values are altivec, no-altivec, spe, no-spe, ibmlong-
	 double, ieeelongdouble.

     -mabi=spe
	 Extend the current ABI with SPE ABI extensions.  This does  not  change
	 the  default ABI, instead it adds the SPE ABI extensions to the current
	 ABI.

     -mabi=no-spe
	 Disable Booke SPE ABI extensions for the current ABI.

     -mabi=ibmlongdouble
	 Change the current ABI to use IBM extended precision long double.  This
	 is a PowerPC 32-bit SYSV ABI option.

     -mabi=ieeelongdouble
	 Change the current ABI to use	IEEE  extended	precision  long  double.
	 This is a PowerPC 32-bit Linux ABI option.

     -mprototype
     -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
	 set  or  clear  bit  6  of the condition code register (CR) to indicate
	 whether floating point values were passed in the floating point  regis-
	 ters  in  case  the function takes a variable arguments.  With -mproto-
	 type, only calls to prototyped variable argument functions will set  or
	 clear the bit.

     -msim
	 On  embedded  PowerPC systems, assume that the startup module is called
	 sim-crt0.o and that the standard C libraries are libsim.a  and  libc.a.
	 This is the default for powerpc-*-eabisim.  configurations.

     -mmvme
	 On  embedded  PowerPC systems, assume that the startup module is called
	 crt0.o and the standard C libraries are libmvme.a and libc.a.

     -mads
	 On embedded PowerPC systems, assume that the startup module  is  called
	 crt0.o and the standard C libraries are libads.a and libc.a.

     -myellowknife
	 On  embedded  PowerPC systems, assume that the startup module is called
	 crt0.o and the standard C libraries are libyk.a and libc.a.

     -mvxworks
	 On System V.4 and embedded PowerPC systems, specify that you  are  com-
	 piling for a VxWorks system.

     -mwindiss
	 Specify that you are compiling for the WindISS simulation environment.

     -memb
	 On  embedded  PowerPC	systems,  set  the  PPC_EMB bit in the ELF flags
	 header to indicate that eabi extended relocations are used.

     -meabi
     -mno-eabi
	 On System V.4 and embedded PowerPC systems do (do not)  adhere  to  the
	 Embedded Applications Binary Interface (eabi) which is a set of modifi-
	 cations  to the System V.4 specifications.  Selecting -meabi means that
	 the stack is aligned to an 8 byte  boundary,  a  function  "__eabi"  is
	 called  to  from "main" to set up the eabi environment, and the -msdata
	 option can use both "r2" and "r13" to point to two separate small  data
	 areas.   Selecting  -mno-eabi	means  that the stack is aligned to a 16
	 byte boundary, do not call an initialization function from "main",  and
	 the  -msdata option will only use "r13" to point to a single small data
	 area.	The -meabi option is on by default if you configured  GCC  using
	 one of the powerpc*-*-eabi* options.

     -msdata=eabi
	 On  System  V.4  and  embedded  PowerPC  systems, put small initialized
	 "const" global and static data in the .sdata2 section, which is pointed
	 to by register "r2".  Put small initialized non-"const" global and sta-
	 tic data in the .sdata section, which is pointed to by register  "r13".
	 Put  small  uninitialized  global and static data in the .sbss section,
	 which is adjacent to the .sdata section.  The	-msdata=eabi  option  is
	 incompatible  with  the  -mrelocatable option.  The -msdata=eabi option
	 also sets the -memb option.

     -msdata=sysv
	 On System V.4 and embedded PowerPC systems, put small global and static
	 data in the .sdata section, which is pointed to by register "r13".  Put
	 small uninitialized global and static data in the .sbss section,  which
	 is  adjacent  to the .sdata section.  The -msdata=sysv option is incom-
	 patible with the -mrelocatable option.

     -msdata=default
     -msdata
	 On System V.4 and embedded PowerPC systems, if -meabi is used,  compile
	 code  the same as -msdata=eabi, otherwise compile code the same as -ms-
	 data=sysv.

     -msdata-data
	 On System V.4 and embedded PowerPC systems, put small	global	data  in
	 the  .sdata  section.	Put small uninitialized global data in the .sbss
	 section.  Do not use register "r13"  to  address  small  data	however.
	 This is the default behavior unless other -msdata options are used.

     -msdata=none
     -mno-sdata
	 On embedded PowerPC systems, put all initialized global and static data
	 in the .data section, and all uninitialized data in the .bss section.

     -G num
	 On  embedded  PowerPC systems, put global and static items less than or
	 equal to num bytes into the small data or bss sections instead  of  the
	 normal  data  or bss section.	By default, num is 8.  The -G num switch
	 is also passed to the linker.	All modules should be compiled with  the
	 same -G num value.

     -mregnames
     -mno-regnames
	 On  System  V.4  and embedded PowerPC systems do (do not) emit register
	 names in the assembly language output using symbolic forms.

     -mlongcall
     -mno-longcall
	 By default assume that all calls are far away so that a longer more ex-
	 pensive calling sequence is required.	This is required for calls  fur-
	 ther than 32 megabytes (33,554,432 bytes) from the current location.  A
	 short	call  will be generated if the compiler knows the call cannot be
	 that far away.  This setting can be overridden by the "shortcall" func-
	 tion attribute, or by "#pragma longcall(0)".

	 Some linkers are capable of detecting out-of-range calls and generating
	 glue code on the fly.	On these systems, long calls are unnecessary and
	 generate slower code.	As of this writing, the AIX linker can do  this,
	 as  can  the GNU linker for PowerPC/64.  It is planned to add this fea-
	 ture to the GNU linker for 32-bit PowerPC systems as well.

	 On Darwin/PPC systems, "#pragma longcall" will generate  "jbsr  callee,
	 L42",	plus  a  "branch  island" (glue code).	The two target addresses
	 represent the callee and the "branch island".	 The  Darwin/PPC  linker
	 will  prefer  the  first  address and generate a "bl callee" if the PPC
	 "bl" instruction will reach the callee directly; otherwise, the  linker
	 will  generate  "bl  L42" to call the "branch island".  The "branch is-
	 land" is appended to the body of the calling function; it computes  the
	 full 32-bit address of the callee and jumps to it.

	 On  Mach-O  (Darwin)  systems, this option directs the compiler emit to
	 the glue for every direct call, and the Darwin linker	decides  whether
	 to use or discard it.

	 In  the  future, we may cause GCC to ignore all longcall specifications
	 when the linker is known to generate glue.

     -pthread
	 Adds support for multithreading with the pthreads library.  This option
	 sets flags for both the preprocessor and linker.

     S/390 and zSeries Options

     These are the -m options defined for the S/390 and zSeries architecture.

     -mhard-float
     -msoft-float
	 Use (do not use) the hardware floating-point instructions and registers
	 for floating-point operations.  When -msoft-float is  specified,  func-
	 tions	in  libgcc.a  will be used to perform floating-point operations.
	 When -mhard-float is specified, the compiler generates  IEEE  floating-
	 point instructions.  This is the default.

     -mlong-double-64
     -mlong-double-128
	 These	switches control the size of "long double" type. A size of 64bit
	 makes the "long double" type equivalent to the "double" type.	This  is
	 the default.

     -mbackchain
     -mno-backchain
	 Store	(do  not  store)  the address of the caller's frame as backchain
	 pointer into the callee's stack frame.  A backchain may  be  needed  to
	 allow	debugging  using tools that do not understand DWARF-2 call frame
	 information.	When  -mno-packed-stack  is  in  effect,  the  backchain
	 pointer is stored at the bottom of the stack frame; when -mpacked-stack
	 is  in  effect,  the  backchain  is placed into the topmost word of the
	 96/160 byte register save area.

	 In general, code compiled with -mbackchain is call-compatible with code
	 compiled with -mmo-backchain; however, use of the backchain for  debug-
	 ging  purposes  usually  requires  that  the whole binary is built with
	 -mbackchain.  Note that the combination of -mbackchain,  -mpacked-stack
	 and  -mhard-float  is	not supported.	In order to build a linux kernel
	 use -msoft-float.

	 The default is to not maintain the backchain.

     -mpacked-stack
     -mno-packed-stack
	 Use (do not use) the packed stack layout.   When  -mno-packed-stack  is
	 specified, the compiler uses the all fields of the 96/160 byte register
	 save  area  only for their default purpose; unused fields still take up
	 stack space.  When -mpacked-stack is specified, register save slots are
	 densely packed at the top of the register save area;  unused  space  is
	 reused  for  other  purposes,	allowing  for  more efficient use of the
	 available stack space.  However, when -mbackchain is  also  in  effect,
	 the  topmost  word  of  the  save  area  is  always  used  to store the
	 backchain, and the return address register is always  saved  two  words
	 below the backchain.

	 As  long  as the stack frame backchain is not used, code generated with
	 -mpacked-stack   is   call-compatible	 with	code   generated    with
	 -mno-packed-stack.   Note  that  some	non-FSF releases of GCC 2.95 for
	 S/390 or zSeries generated code that uses the stack frame backchain  at
	 run  time, not just for debugging purposes.  Such code is not call-com-
	 patible with code compiled with -mpacked-stack.  Also,  note  that  the
	 combination of -mbackchain, -mpacked-stack and -mhard-float is not sup-
	 ported.  In order to build a linux kernel use -msoft-float.

	 The default is to not use the packed stack layout.

     -msmall-exec
     -mno-small-exec
	 Generate  (or	do not generate) code using the "bras" instruction to do
	 subroutine calls.  This only works reliably  if  the  total  executable
	 size does not exceed 64k.  The default is to use the "basr" instruction
	 instead, which does not have this limitation.

     -m64
     -m31When  -m31  is  specified, generate code compliant to the GNU/Linux for
	 S/390 ABI.  When -m64 is specified,  generate	code  compliant  to  the
	 GNU/Linux  for  zSeries ABI.  This allows GCC in particular to generate
	 64-bit instructions.  For the s390 targets, the default is -m31,  while
	 the s390x targets default to -m64.

     -mzarch
     -mesa
	 When  -mzarch is specified, generate code using the instructions avail-
	 able on z/Architecture.  When -mesa is specified, generate  code  using
	 the instructions available on ESA/390.  Note that -mesa is not possible
	 with  -m64.   When generating code compliant to the GNU/Linux for S/390
	 ABI, the default is -mesa.   When  generating	code  compliant  to  the
	 GNU/Linux for zSeries ABI, the default is -mzarch.

     -mmvcle
     -mno-mvcle
	 Generate  (or	do  not  generate) code using the "mvcle" instruction to
	 perform block moves.  When -mno-mvcle is specified, use  a  "mvc"  loop
	 instead.  This is the default unless optimizing for size.

     -mdebug
     -mno-debug
	 Print	(or  do  not print) additional debug information when compiling.
	 The default is to not print debug information.

     -march=cpu-type
	 Generate code that will run on cpu-type, which is the name of a  system
	 representing  a  certain  processor type.  Possible values for cpu-type
	 are g5, g6, z900, and z990.  When generating code  using  the	instruc-
	 tions	available on z/Architecture, the default is -march=z900.  Other-
	 wise, the default is -march=g5.

     -mtune=cpu-type
	 Tune to cpu-type everything applicable about the generated code, except
	 for the ABI and the set of available instructions.  The  list	of  cpu-
	 type  values  is the same as for -march.  The default is the value used
	 for -march.

     -mtpf-trace
     -mno-tpf-trace
	 Generate code that adds (does not add) in TPF OS specific  branches  to
	 trace routines in the operating system.  This option is off by default,
	 even when compiling for the TPF OS.

     -mfused-madd
     -mno-fused-madd
	 Generate  code that uses (does not use) the floating point multiply and
	 accumulate instructions.  These instructions are generated  by  default
	 if hardware floating point is used.

     -mwarn-framesize=framesize
	 Emit  a  warning  if the current function exceeds the given frame size.
	 Because this is a compile time check it doesn't need to be a real prob-
	 lem when the program runs.  It is intended to identify functions  which
	 most  probably  cause	a stack overflow.  It is useful to be used in an
	 environment with limited stack size e.g. the linux kernel.

     -mwarn-dynamicstack
	 Emit a warning if the function calls alloca or uses  dynamically  sized
	 arrays.  This is generally a bad idea with a limited stack size.

     -mstack-guard=stack-guard
     -mstack-size=stack-size
	 These	arguments  always  have  to be used in conjunction.  If they are
	 present the s390 back end emits additional instructions in the function
	 prologue which trigger a trap if the stack size  is  stack-guard  bytes
	 above	the stack-size (remember that the stack on s390 grows downward).
	 These options are intended to be used to help debugging stack	overflow
	 problems.   The  additionally	emitted code causes only little overhead
	 and hence can also be used in production like systems	without  greater
	 performance degradation.  The given values have to be exact powers of 2
	 and  stack-size  has  to  be greater than stack-guard without exceeding
	 64k.  In order to be efficient the extra code makes the assumption that
	 the stack starts at an address aligned to the	value  given  by  stack-
	 size.

     Score Options

     These options are defined for Score implementations:

     -mebCompile code for big endian mode.  This is the default.

     -melCompile code for little endian mode.

     -mnhwloop
	 Disable generate bcnz instruction.

     -muls
	 Enable generate unaligned load and store instruction.

     -mmac
	 Enable  the  use  of  multiply-accumulate instructions. Disabled by de-
	 fault.

     -mscore5
	 Specify the SCORE5 as the target architecture.

     -mscore5u
	 Specify the SCORE5U of the target architecture.

     -mscore7
	 Specify the SCORE7 as the target architecture. This is the default.

     -mscore7d
	 Specify the SCORE7D as the target architecture.

     SH Options

     These -m options are defined for the SH implementations:

     -m1 Generate code for the SH1.

     -m2 Generate code for the SH2.

     -m2eGenerate code for the SH2e.

     -m3 Generate code for the SH3.

     -m3eGenerate code for the SH3e.

     -m4-nofpu
	 Generate code for the SH4 without a floating-point unit.

     -m4-single-only
	 Generate code for the SH4 with a floating-point unit that only supports
	 single-precision arithmetic.

     -m4-single
	 Generate code for the SH4 assuming the floating-point unit is	in  sin-
	 gle-precision mode by default.

     -m4 Generate code for the SH4.

     -m4a-nofpu
	 Generate  code  for the SH4al-dsp, or for a SH4a in such a way that the
	 floating-point unit is not used.

     -m4a-single-only
	 Generate code for the SH4a, in such  a  way  that  no	double-precision
	 floating point operations are used.

     -m4a-single
	 Generate  code for the SH4a assuming the floating-point unit is in sin-
	 gle-precision mode by default.

     -m4aGenerate code for the SH4a.

     -m4al
	 Same as -m4a-nofpu, except that it implicitly passes -dsp to the assem-
	 bler.	GCC doesn't generate any DSP instructions at the moment.

     -mb Compile code for the processor in big endian mode.

     -ml Compile code for the processor in little endian mode.

     -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.

     -mrelax
	 Shorten  some	address references at link time, when possible; uses the
	 linker option -relax.

     -mbigtable
	 Use 32-bit offsets in "switch" tables.  The default is  to  use  16-bit
	 offsets.

     -mfmovd
	 Enable the use of the instruction "fmovd".

     -mhitachi
	 Comply with the calling conventions defined by Renesas.

     -mrenesas
	 Comply with the calling conventions defined by Renesas.

     -mno-renesas
	 Comply  with the calling conventions defined for GCC before the Renesas
	 conventions were available.  This option is the default for all targets
	 of the SH toolchain except for sh-symbianelf.

     -mnomacsave
	 Mark the "MAC" register as call-clobbered, even if -mhitachi is given.

     -mieee
	 Increase IEEE-compliance of floating-point code.  At the  moment,  this
	 is  equivalent to -fno-finite-math-only.  When generating 16 bit SH op-
	 codes, getting IEEE-conforming results for comparisons of  NANs  /  in-
	 finities  incurs  extra  overhead  in	every floating point comparison,
	 therefore the default is set to -ffinite-math-only.

     -misize
	 Dump instruction size and location in the assembly code.

     -mpadstruct
	 This option is deprecated.  It pads structures to multiple of 4  bytes,
	 which is incompatible with the SH ABI.

     -mspace
	 Optimize for space instead of speed.  Implied by -Os.

     -mprefergot
	 When  generating  position-independent  code, emit function calls using
	 the Global Offset Table instead of the Procedure Linkage Table.

     -musermode
	 Generate a library function call to invalidate  instruction  cache  en-
	 tries,  after	fixing	up  a  trampoline.   This  library function call
	 doesn't assume it can write to the whole memory address space.  This is
	 the default when the target is "sh-*-linux*".

     -multcost=number
	 Set the cost to assume for a multiply insn.

     -mdiv=strategy
	 Set the division strategy to use for SHmedia code.   strategy	must  be
	 one  of:  call,  call2,  fp, inv, inv:minlat, inv20u, inv20l, inv:call,
	 inv:call2, inv:fp .  "fp" performs the  operation  in	floating  point.
	 This  has a very high latency, but needs only a few instructions, so it
	 might be a good choice if your code has enough easily	exploitable  ILP
	 to  allow  the compiler to schedule the floating point instructions to-
	 gether with other instructions.  Division by  zero  causes  a	floating
	 point	exception.   "inv"  uses integer operations to calculate the in-
	 verse of the divisor, and then multiplies the	dividend  with	the  in-
	 verse.   This	strategy allows cse and hoisting of the inverse calcula-
	 tion.	Division by zero calculates an unspecified result, but does  not
	 trap.	 "inv:minlat"  is  a variant of "inv" where if no cse / hoisting
	 opportunities have been found, or if  the  entire  operation  has  been
	 hoisted  to  the same place, the last stages of the inverse calculation
	 are intertwined with the final multiply to reduce the overall	latency,
	 at  the  expense  of  using  a few more instructions, and thus offering
	 fewer scheduling opportunities with other code.  "call" calls a library
	 function that usually implements the inv:minlat strategy.   This  gives
	 high  code  density  for  m5-*media-nofpu compilations.  "call2" uses a
	 different entry point of the same library function,  where  it  assumes
	 that a pointer to a lookup table has already been set up, which exposes
	 the  pointer  load  to  cse / code hoisting optimizations.  "inv:call",
	 "inv:call2" and "inv:fp" all use the "inv" algorithm for  initial  code
	 generation,  but  if  the code stays unoptimized, revert to the "call",
	 "call2", or "fp" strategies, respectively.  Note that the  potentially-
	 trapping  side  effect of division by zero is carried by a separate in-
	 struction, so it is possible that  all  the  integer  instructions  are
	 hoisted  out,	but the marker for the side effect stays where it is.  A
	 recombination to fp operations or a call is not possible in that  case.
	 "inv20u"  and	"inv20l"  are variants of the "inv:minlat" strategy.  In
	 the case that the inverse calculation was nor separated from the multi-
	 ply, they speed up division where the dividend fits into 20 bits  (plus
	 sign  where applicable), by inserting a test to skip a number of opera-
	 tions in this case; this test slows down the case of larger  dividends.
	 inv20u  assumes the case of a such a small dividend to be unlikely, and
	 inv20l assumes it to be likely.

     -mdivsi3_libfunc=name
	 Set the name of the library function used for 32 bit signed division to
	 name.	This only affect the name used in the call and inv:call division
	 strategies, and the compiler will still expect the  same  sets  of  in-
	 put/output/clobbered registers as if this option was not present.

     -madjust-unroll
	 Throttle  unrolling  to  avoid thrashing target registers.  This option
	 only has an effect if the gcc code base supports the  TARGET_ADJUST_UN-
	 ROLL_MAX target hook.

     -mindexed-addressing
	 Enable  the use of the indexed addressing mode for SHmedia32/SHcompact.
	 This is only safe if the hardware and/or  OS  implement  32  bit  wrap-
	 around semantics for the indexed addressing mode.  The architecture al-
	 lows  the  implementation  of	processors with 64 bit MMU, which the OS
	 could use to get 32 bit addressing, but since no current  hardware  im-
	 plementation  supports  this  or  any other way to make the indexed ad-
	 dressing mode safe to use in the 32 bit ABI, the  default  is	-mno-in-
	 dexed-addressing.

     -mgettrcost=number
	 Set  the cost assumed for the gettr instruction to number.  The default
	 is 2 if -mpt-fixed is in effect, 100 otherwise.

     -mpt-fixed
	 Assume pt* instructions won't trap.  This will generally generate  bet-
	 ter scheduled code, but is unsafe on current hardware.  The current ar-
	 chitecture  definition  says  that ptabs and ptrel trap when the target
	 anded with 3 is 3.  This has the unintentional effect of making it  un-
	 safe  to  schedule  ptabs / ptrel before a branch, or hoist it out of a
	 loop.	For example, __do_global_ctors, a part of libgcc that runs  con-
	 structors at program startup, calls functions in a list which is delim-
	 ited  by -1.  With the -mpt-fixed option, the ptabs will be done before
	 testing against -1.  That means that all the constructors will be run a
	 bit quicker, but when the loop comes to the end of the list,  the  pro-
	 gram crashes because ptabs loads -1 into a target register.  Since this
	 option is unsafe for any hardware implementing the current architecture
	 specification, the default is -mno-pt-fixed.  Unless the user specifies
	 a  specific  cost with -mgettrcost, -mno-pt-fixed also implies -mgettr-
	 cost=100; this deters register allocation using  target  registers  for
	 storing ordinary integers.

     -minvalid-symbols
	 Assume  symbols  might be invalid.  Ordinary function symbols generated
	 by the compiler will always be valid to load with  movi/shori/ptabs  or
	 movi/shori/ptrel,  but with assembler and/or linker tricks it is possi-
	 ble to generate symbols that will cause ptabs / ptrel	to  trap.   This
	 option  is  only  meaningful  when -mno-pt-fixed is in effect.  It will
	 then prevent cross-basic-block cse, hoisting  and  most  scheduling  of
	 symbol loads.	The default is -mno-invalid-symbols.

     SPARC Options

     These -m options are supported on the SPARC:

     -mno-app-regs
     -mapp-regs
	 Specify  -mapp-regs  to  generate  output  using the global registers 2
	 through 4, which the SPARC SVR4 ABI reserves for applications.  This is
	 the default.

	 To be fully SVR4 ABI compliant at the cost of	some  performance  loss,
	 specify  -mno-app-regs.   You should compile libraries and system soft-
	 ware with this option.

     -mfpu
     -mhard-float
	 Generate output containing floating point instructions.   This  is  the
	 default.

     -mno-fpu
     -msoft-float
	 Generate  output containing library calls for floating point.	Warning:
	 the requisite libraries are not available for all SPARC targets.   Nor-
	 mally	the  facilities  of the machine's usual C compiler are used, but
	 this cannot be done directly in cross-compilation.  You must make  your
	 own arrangements to provide suitable library functions for cross-compi-
	 lation.  The embedded targets sparc-*-aout and sparclite-*-* do provide
	 software floating point support.

	 -msoft-float  changes the calling convention in the output file; there-
	 fore, it is only useful if you compile all of a program with  this  op-
	 tion.	 In  particular,  you need to compile libgcc.a, the library that
	 comes with GCC, with -msoft-float in order for this to work.

     -mhard-quad-float
	 Generate output containing quad-word (long double) floating  point  in-
	 structions.

     -msoft-quad-float
	 Generate  output  containing  library calls for quad-word (long double)
	 floating point instructions.  The functions called are those  specified
	 in the SPARC ABI.  This is the default.

	 As  of this writing, there are no SPARC implementations that have hard-
	 ware support for the quad-word floating point instructions.   They  all
	 invoke  a trap handler for one of these instructions, and then the trap
	 handler emulates the effect of the instruction.  Because  of  the  trap
	 handler overhead, this is much slower than calling the ABI library rou-
	 tines.  Thus the -msoft-quad-float option is the default.

     -mno-unaligned-doubles
     -munaligned-doubles
	 Assume that doubles have 8 byte alignment.  This is the default.

	 With  -munaligned-doubles,  GCC assumes that doubles have 8 byte align-
	 ment only if they are contained in another type, or if they have an ab-
	 solute address.  Otherwise, it assumes  they  have  4	byte  alignment.
	 Specifying  this  option  avoids  some rare compatibility problems with
	 code generated by other compilers.  It is not the  default  because  it
	 results in a performance loss, especially for floating point code.

     -mno-faster-structs
     -mfaster-structs
	 With -mfaster-structs, the compiler assumes that structures should have
	 8 byte alignment.  This enables the use of pairs of "ldd" and "std" in-
	 structions  for  copies  in  structure assignment, in place of twice as
	 many "ld" and "st" pairs.  However, the use of this  changed  alignment
	 directly  violates  the SPARC ABI.  Thus, it's intended only for use on
	 targets where the developer acknowledges that their resulting code will
	 not be directly in line with the rules of the ABI.

     -mimpure-text
	 -mimpure-text, used in addition to -shared, tells the compiler  to  not
	 pass  -z  text  to the linker when linking a shared object.  Using this
	 option, you can link position-dependent code into a shared object.

	 -mimpure-text suppresses the "relocations  remain  against  allocatable
	 but  non-writable  sections" linker error message.  However, the neces-
	 sary relocations will trigger copy-on-write, and the shared  object  is
	 not  actually shared across processes.  Instead of using -mimpure-text,
	 you should compile all source code with -fpic or -fPIC.

	 This option is only available on SunOS and Solaris.

     -mcpu=cpu_type
	 Set the instruction set, register set, and instruction scheduling para-
	 meters for machine type cpu_type.  Supported values  for  cpu_type  are
	 v7,  cypress,	v8, supersparc, sparclite, f930, f934, hypersparc, spar-
	 clite86x, sparclet, tsc701, v9, ultrasparc, ultrasparc3, and niagara.

	 Default instruction scheduling parameters are used for values that  se-
	 lect  an  architecture  and  not  an implementation.  These are v7, v8,
	 sparclite, sparclet, v9.

	 Here is a list of each supported architecture and their  supported  im-
	 plementations.

		     v7:	     cypress
		     v8:	     supersparc, hypersparc
		     sparclite:      f930, f934, sparclite86x
		     sparclet:	     tsc701
		     v9:	     ultrasparc, ultrasparc3, niagara

	 By default (unless configured otherwise), GCC generates code for the V7
	 variant  of  the  SPARC architecture.	With -mcpu=cypress, the compiler
	 additionally optimizes it for the Cypress CY7C602 chip, as used in  the
	 SPARCStation/SPARCServer  3xx series.	This is also appropriate for the
	 older SPARCStation 1, 2, IPX etc.

	 With -mcpu=v8, GCC generates code for the V8 variant of the  SPARC  ar-
	 chitecture.   The  only  difference  from  V7 code is that the compiler
	 emits the integer multiply and integer divide instructions which  exist
	 in  SPARC-V8  but not in SPARC-V7.  With -mcpu=supersparc, the compiler
	 additionally optimizes it for the  SuperSPARC	chip,  as  used  in  the
	 SPARCStation 10, 1000 and 2000 series.

	 With  -mcpu=sparclite,  GCC generates code for the SPARClite variant of
	 the SPARC architecture.  This adds the integer multiply, integer divide
	 step and scan ("ffs") instructions which exist in SPARClite but not  in
	 SPARC-V7.   With -mcpu=f930, the compiler additionally optimizes it for
	 the Fujitsu MB86930 chip, which is the original SPARClite, with no FPU.
	 With -mcpu=f934, the compiler additionally optimizes it for the Fujitsu
	 MB86934 chip, which is the more recent SPARClite with FPU.

	 With -mcpu=sparclet, GCC generates code for the SPARClet variant of the
	 SPARC architecture.  This adds the integer  multiply,	multiply/accumu-
	 late,	integer divide step and scan ("ffs") instructions which exist in
	 SPARClet but not in SPARC-V7.	With -mcpu=tsc701,  the  compiler  addi-
	 tionally optimizes it for the TEMIC SPARClet chip.

	 With  -mcpu=v9,  GCC generates code for the V9 variant of the SPARC ar-
	 chitecture.  This adds 64-bit integer and floating-point move	instruc-
	 tions,  3 additional floating-point condition code registers and condi-
	 tional move instructions.  With -mcpu=ultrasparc,  the  compiler  addi-
	 tionally  optimizes  it  for  the  Sun UltraSPARC I/II/IIi chips.  With
	 -mcpu=ultrasparc3, the compiler additionally optimizes it for	the  Sun
	 UltraSPARC  III/III+/IIIi/IIIi+/IV/IV+  chips.  With -mcpu=niagara, the
	 compiler additionally optimizes it for Sun UltraSPARC T1 chips.

     -mtune=cpu_type
	 Set the instruction scheduling parameters for	machine  type  cpu_type,
	 but  do  not  set  the  instruction set or register set that the option
	 -mcpu=cpu_type would.

	 The same values for -mcpu=cpu_type can be used for -mtune=cpu_type, but
	 the only useful values are those that select a particular cpu implemen-
	 tation.  Those are cypress, supersparc, hypersparc, f930,  f934,  spar-
	 clite86x, tsc701, ultrasparc, ultrasparc3, and niagara.

     -mv8plus
     -mno-v8plus
	 With  -mv8plus,  GCC generates code for the SPARC-V8+ ABI.  The differ-
	 ence from the V8 ABI is that the global and out registers  are  consid-
	 ered 64-bit wide.  This is enabled by default on Solaris in 32-bit mode
	 for all SPARC-V9 processors.

     -mvis
     -mno-vis
	 With  -mvis,  GCC generates code that takes advantage of the UltraSPARC
	 Visual Instruction Set extensions.  The default is -mno-vis.

     These -m options are supported in addition to the above on SPARC-V9 proces-
     sors in 64-bit environments:

     -mlittle-endian
	 Generate code for a processor running in  little-endian  mode.   It  is
	 only available for a few configurations and most notably not on Solaris
	 and Linux.

     -m32
     -m64Generate  code for a 32-bit or 64-bit environment.  The 32-bit environ-
	 ment sets int, long and pointer to 32	bits.	The  64-bit  environment
	 sets int to 32 bits and long and pointer to 64 bits.

     -mcmodel=medlow
	 Generate code for the Medium/Low code model: 64-bit addresses, programs
	 must  be  linked  in the low 32 bits of memory.  Programs can be stati-
	 cally or dynamically linked.

     -mcmodel=medmid
	 Generate code for the Medium/Middle code model: 64-bit addresses,  pro-
	 grams	must  be  linked in the low 44 bits of memory, the text and data
	 segments must be less than 2GB in size and the data segment must be lo-
	 cated within 2GB of the text segment.

     -mcmodel=medany
	 Generate code for the Medium/Anywhere	code  model:  64-bit  addresses,
	 programs  may	be linked anywhere in memory, the text and data segments
	 must be less than 2GB in size and the	data  segment  must  be  located
	 within 2GB of the text segment.

     -mcmodel=embmedany
	 Generate  code for the Medium/Anywhere code model for embedded systems:
	 64-bit addresses, the text and data segments must be less than  2GB  in
	 size,	both starting anywhere in memory (determined at link time).  The
	 global register %g4 points to the base of the data  segment.	Programs
	 are statically linked and PIC is not supported.

     -mstack-bias
     -mno-stack-bias
	 With  -mstack-bias,  GCC  assumes  that  the  stack  pointer, and frame
	 pointer if present, are offset by -2047 which must be added  back  when
	 making  stack	frame  references.   This is the default in 64-bit mode.
	 Otherwise, assume no such offset is present.

     These switches are supported in addition to the above on Solaris:

     -threads
	 Add support for multithreading using the Solaris threads library.  This
	 option sets flags for both the preprocessor and  linker.   This  option
	 does  not  affect the thread safety of object code produced by the com-
	 piler or that of libraries supplied with it.

     -pthreads
	 Add support for multithreading using the POSIX threads  library.   This
	 option  sets  flags  for both the preprocessor and linker.  This option
	 does not affect the thread safety of object code produced  by the  com-
	 piler or that of libraries supplied with it.

     -pthread
	 This is a synonym for -pthreads.

     Options for System V

     These  additional	options are available on System V Release 4 for compati-
     bility with other compilers on those systems:

     -G  Create a shared object.  It is recommended that -symbolic or -shared be
	 used instead.

     -Qy Identify the versions of each tool used by the compiler, in a	".ident"
	 assembler directive in the output.

     -Qn Refrain from adding ".ident" directives to the output file (this is the
	 default).

     -YP,dirs
	 Search  the  directories  dirs,  and no others, for libraries specified
	 with -l.

     -Ym,dir
	 Look in the directory dir to find the M4 preprocessor.   The  assembler
	 uses this option.

     TMS320C3x/C4x Options

     These -m options are defined for TMS320C3x/C4x implementations:

     -mcpu=cpu_type
	 Set the instruction set, register set, and instruction scheduling para-
	 meters  for  machine  type cpu_type.  Supported values for cpu_type are
	 c30, c31, c32, c40, and c44.  The default is c40 to generate  code  for
	 the TMS320C40.

     -mbig-memory
     -mbig
     -msmall-memory
     -msmall
	 Generates  code  for  the  big or small memory model.	The small memory
	 model assumed that all data fits into one 64K word page.   At	run-time
	 the  data  page (DP) register must be set to point to the 64K page con-
	 taining the .bss and .data program sections.  The big memory  model  is
	 the  default and requires reloading of the DP register for every direct
	 memory access.

     -mbk
     -mno-bk
	 Allow (disallow) allocation of general integer operands into the  block
	 count register BK.

     -mdb
     -mno-db
	 Enable  (disable)  generation	of  code using decrement and branch, DB-
	 cond(D), instructions.  This is enabled by default for the C4x.  To  be
	 on the safe side, this is disabled for the C3x, since the maximum iter-
	 ation	count on the C3x is 2^{23 + 1} (but who iterates loops more than
	 2^{23} times on the C3x?).  Note that GCC will try to reverse a loop so
	 that it can utilize the decrement and branch instruction, but will give
	 up if there is more than one memory reference in the loop.  Thus a loop
	 where the loop counter is decremented can generate slightly more  effi-
	 cient code, in cases where the RPTB instruction cannot be utilized.

     -mdp-isr-reload
     -mparanoid
	 Force the DP register to be saved on entry to an interrupt service rou-
	 tine (ISR), reloaded to point to the data section, and restored on exit
	 from  the ISR.  This should not be required unless someone has violated
	 the small memory model by modifying the DP register, say within an  ob-
	 ject library.

     -mmpyi
     -mno-mpyi
	 For  the C3x use the 24-bit MPYI instruction for integer multiplies in-
	 stead of a library call to guarantee 32-bit results.  Note that if  one
	 of  the  operands  is	a constant, then the multiplication will be per-
	 formed using shifts and adds.	If the -mmpyi option  is  not  specified
	 for the C3x, then squaring operations are performed inline instead of a
	 library call.

     -mfast-fix
     -mno-fast-fix
	 The C3x/C4x FIX instruction to convert a floating point value to an in-
	 teger	value  chooses	the  nearest  integer  less than or equal to the
	 floating point value rather than to the nearest integer.  Thus  if  the
	 floating point number is negative, the result will be incorrectly trun-
	 cated	an additional code is necessary to detect and correct this case.
	 This option can be used to disable generation of  the	additional  code
	 required to correct the result.

     -mrptb
     -mno-rptb
	 Enable  (disable)  generation	of repeat block sequences using the RPTB
	 instruction for zero overhead looping.  The RPTB construct is only used
	 for innermost loops that do not call functions or jump across the  loop
	 boundaries.   There is no advantage having nested RPTB loops due to the
	 overhead required to save and restore the RC,	RS,  and  RE  registers.
	 This is enabled by default with -O2.

     -mrpts=count
     -mno-rpts
	 Enable  (disable)  the use of the single instruction repeat instruction
	 RPTS.	If a repeat block contains a single instruction,  and  the  loop
	 count	can be guaranteed to be less than the value count, GCC will emit
	 a RPTS instruction instead of a RPTB.	If no value is specified, then a
	 RPTS will be emitted even if the loop count  cannot  be  determined  at
	 compile  time.   Note that the repeated instruction following RPTS does
	 not have to be reloaded from memory each iteration, thus freeing up the
	 CPU buses for operands.  However, since interrupts are blocked by  this
	 instruction, it is disabled by default.

     -mloop-unsigned
     -mno-loop-unsigned
	 The  maximum  iteration  count  when using RPTS and RPTB (and DB on the
	 C40) is 2^{31 + 1} since these instructions test if the iteration count
	 is negative to terminate the loop.  If the iteration count is	unsigned
	 there	is a possibility than the 2^{31 + 1} maximum iteration count may
	 be exceeded.  This switch allows an unsigned iteration count.

     -mtiTry to emit an assembler syntax that the TI assembler (asm30) is  happy
	 with.	This also enforces compatibility with the API employed by the TI
	 C3x  C  compiler.   For  example, long doubles are passed as structures
	 rather than in floating point registers.

     -mregparm
     -mmemparm
	 Generate code that uses registers  (stack)  for  passing  arguments  to
	 functions.   By default, arguments are passed in registers where possi-
	 ble rather than by pushing arguments on to the stack.

     -mparallel-insns
     -mno-parallel-insns
	 Allow the generation of parallel instructions.  This is enabled by  de-
	 fault with -O2.

     -mparallel-mpy
     -mno-parallel-mpy
	 Allow	the  generation  of MPY||ADD and MPY||SUB parallel instructions,
	 provided -mparallel-insns is also specified.  These  instructions  have
	 tight	register  constraints which can pessimize the code generation of
	 large functions.

     V850 Options

     These -m options are defined for V850 implementations:

     -mlong-calls
     -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.

     -mno-ep
     -mepDo  not  optimize  (do  optimize)  basic blocks that use the same index
	 pointer 4 or more times to copy pointer into the "ep" register, and use
	 the shorter "sld" and "sst" instructions.  The -mep option is on by de-
	 fault if you optimize.

     -mno-prolog-function
     -mprolog-function
	 Do not use (do use) external functions to save and restore registers at
	 the prologue and epilogue 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 -mprolog-function option is  on  by  de-
	 fault if you optimize.

     -mspace
	 Try to make the code as small as possible.  At present, this just turns
	 on the -mep and -mprolog-function options.

     -mtda=n
	 Put  static  or global variables whose size is n bytes or less into the
	 tiny data area that register "ep" points to.  The tiny  data  area  can
	 hold up to 256 bytes in total (128 bytes for byte references).

     -msda=n
	 Put  static  or global variables whose size is n bytes or less into the
	 small data area that register "gp" points to.	The small data area  can
	 hold up to 64 kilobytes.

     -mzda=n
	 Put  static  or global variables whose size is n bytes or less into the
	 first 32 kilobytes of memory.

     -mv850
	 Specify that the target processor is the V850.

     -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.

     -mapp-regs
	 This option will cause r2 and r5 to be used in the  code  generated  by
	 the compiler.	This setting is the default.

     -mno-app-regs
	 This option will cause r2 and r5 to be treated as fixed registers.

     -mv850e1
	 Specify that the target processor is the V850E1.  The preprocessor con-
	 stants __v850e1__ and __v850e__ will be defined if this option is used.

     -mv850e
	 Specify  that the target processor is the V850E.  The preprocessor con-
	 stant __v850e__ will be defined if this option is used.

	 If neither -mv850 nor -mv850e nor -mv850e1 are defined then  a  default
	 target processor will be chosen and the relevant __v850*__ preprocessor
	 constant will be defined.

	 The  preprocessor constants __v850 and __v851__ are always defined, re-
	 gardless of which processor variant is the target.

     -mdisable-callt
	 This option will suppress generation of the CALLT instruction	for  the
	 v850e	and  v850e1  flavors  of  the v850 architecture.  The default is
	 -mno-disable-callt which allows the CALLT instruction to be used.

     VAX Options

     These -m options are defined for the VAX:

     -munix
	 Do not output certain jump instructions ("aobleq" and so on)  that  the
	 Unix assembler for the VAX cannot handle across long ranges.

     -mgnu
	 Do  output those jump instructions, on the assumption that you will as-
	 semble with the GNU assembler.

     -mg Output code for g-format floating point numbers instead of d-format.

     x86-64 Options

     These are listed under

     Xstormy16 Options

     These options are defined for Xstormy16:

     -msim
	 Choose startup files and linker script suitable for the simulator.

     Xtensa Options

     These options are supported for Xtensa targets:

     -mconst16
     -mno-const16
	 Enable or disable use of "CONST16" instructions  for  loading	constant
	 values.   The	"CONST16" instruction is currently not a standard option
	 from Tensilica.  When enabled, "CONST16" instructions are  always  used
	 in  place of the standard "L32R" instructions.  The use of "CONST16" is
	 enabled by default only if the "L32R" instruction is not available.

     -mfused-madd
     -mno-fused-madd
	 Enable or disable use of fused multiply/add and  multiply/subtract  in-
	 structions  in  the  floating-point  option.  This has no effect if the
	 floating-point option is not  also  enabled.	Disabling  fused  multi-
	 ply/add  and  multiply/subtract instructions forces the compiler to use
	 separate instructions for the	multiply  and  add/subtract  operations.
	 This may be desirable in some cases where strict IEEE 754-compliant re-
	 sults are required: the fused multiply add/subtract instructions do not
	 round the intermediate result, thereby producing results with more bits
	 of precision than specified by the IEEE standard.  Disabling fused mul-
	 tiply add/subtract instructions also ensures that the program output is
	 not  sensitive  to  the  compiler's  ability  to  combine  multiply and
	 add/subtract operations.

     -mtext-section-literals
     -mno-text-section-literals
	 Control the treatment of literal pools.  The default is  -mno-text-sec-
	 tion-literals,  which places literals in a separate section in the out-
	 put file.  This allows the literal pool to be placed in a data RAM/ROM,
	 and it also allows the linker to combine literal  pools  from	separate
	 object  files to remove redundant literals and improve code size.  With
	 -mtext-section-literals, the literals are interspersed in the text sec-
	 tion in order to keep them as close as possible  to  their  references.
	 This may be necessary for large assembly files.

     -mtarget-align
     -mno-target-align
	 When  this  option is enabled, GCC instructs the assembler to automati-
	 cally align instructions to reduce branch penalties at the  expense  of
	 some  code  density.	The assembler attempts to widen density instruc-
	 tions to align branch targets and the instructions following  call  in-
	 structions.   If  there  are not enough preceding safe density instruc-
	 tions to align a target, no widening will be performed.  The default is
	 -mtarget-align.  These options do not affect  the  treatment  of  auto-
	 aligned  instructions	like  "LOOP",  which  the  assembler will always
	 align, either by widening density instructions or  by	inserting  no-op
	 instructions.

     -mlongcalls
     -mno-longcalls
	 When  this  option is enabled, GCC instructs the assembler to translate
	 direct calls to indirect calls unless it can determine that the  target
	 of a direct call is in the range allowed by the call instruction.  This
	 translation  typically  occurs  for  calls to functions in other source
	 files.  Specifically, the assembler translates a direct "CALL" instruc-
	 tion into an "L32R" followed by a "CALLX" instruction.  The default  is
	 -mno-longcalls.   This option should be used in programs where the call
	 target can potentially be out of range.  This option is implemented  in
	 the  assembler, not the compiler, so the assembly code generated by GCC
	 will still show direct call instructions---look at the disassembled ob-
	 ject code to see the actual instructions.  Note that the assembler will
	 use an indirect call for every cross-file call, not just those that re-
	 ally will be out of range.

     zSeries Options

     These are listed under

     Options for Code Generation Conventions

     These machine-independent options control the interface conventions used in
     code generation.

     Most of them have both positive and negative forms; the  negative	form  of
     -ffoo  would  be  -fno-foo.   In  the table below, only one of the forms is
     listed---the one which is not the default.  You can figure  out  the  other
     form by either removing no- or adding it.

     -fbounds-check
	 For  front-ends that support it, generate additional code to check that
	 indices used to access arrays are within the declared range.	This  is
	 currently only supported by the Java and Fortran front-ends, where this
	 option defaults to true and false respectively.

     -ftrapv
	 This  option  generates traps for signed overflow on addition, subtrac-
	 tion, multiplication operations.

     -fwrapv
	 This option instructs the compiler to	assume	that  signed  arithmetic
	 overflow of addition, subtraction and multiplication wraps around using
	 twos-complement  representation.   This flag enables some optimizations
	 and disables others.  This option is enabled by default  for  the  Java
	 front-end, as required by the Java language specification.

     -fexceptions
	 Enable  exception  handling.	Generates extra code needed to propagate
	 exceptions.  For some targets, this implies GCC will generate frame un-
	 wind information for all functions, which can produce significant  data
	 size  overhead,  although  it does not affect execution.  If you do not
	 specify this option, GCC will enable it by default for  languages  like
	 C++  which normally require exception handling, and disable it for lan-
	 guages like C that do not normally require it.  However, you  may  need
	 to  enable this option when compiling C code that needs to interoperate
	 properly with exception handlers written in C++.  You may also wish  to
	 disable  this option if you are compiling older C++ programs that don't
	 use exception handling.

     -fnon-call-exceptions
	 Generate code that allows trapping instructions  to  throw  exceptions.
	 Note that this requires platform-specific runtime support that does not
	 exist	everywhere.   Moreover,  it only allows trapping instructions to
	 throw exceptions, i.e. memory references  or  floating  point	instruc-
	 tions.  It does not allow exceptions to be thrown from arbitrary signal
	 handlers such as "SIGALRM".

     -funwind-tables
	 Similar  to  -fexceptions, except that it will just generate any needed
	 static data, but will not affect the generated code in any  other  way.
	 You will normally not enable this option; instead, a language processor
	 that needs this handling would enable it on your behalf.

     -fasynchronous-unwind-tables
	 Generate unwind table in dwarf2 format, if supported by target machine.
	 The  table is exact at each instruction boundary, so it can be used for
	 stack unwinding from asynchronous events (such as debugger  or  garbage
	 collector).

     -fpcc-struct-return
	 Return  "short" "struct" and "union" values in memory like longer ones,
	 rather than in registers.  This convention is less  efficient,  but  it
	 has  the  advantage  of  allowing intercallability between GCC-compiled
	 files	and  files  compiled  with  other  compilers,  particularly  the
	 Portable C Compiler (pcc).

	 The  precise  convention  for returning structures in memory depends on
	 the target configuration macros.

	 Short structures and unions are those whose size  and	alignment  match
	 that of some integer type.

	 Warning:  code  compiled with the -fpcc-struct-return switch is not bi-
	 nary compatible with code compiled with the -freg-struct-return switch.
	 Use it to conform to a non-default application binary interface.

     -freg-struct-return
	 Return "struct" and "union" values in registers when possible.  This is
	 more efficient for small structures than -fpcc-struct-return.

	 If you specify neither -fpcc-struct-return nor -freg-struct-return, GCC
	 defaults to whichever convention is standard for the target.  If  there
	 is  no standard convention, GCC defaults to -fpcc-struct-return, except
	 on targets where GCC is the principal compiler.  In those cases, we can
	 choose the standard, and we chose the more  efficient	register  return
	 alternative.

	 Warning:  code  compiled with the -freg-struct-return switch is not bi-
	 nary compatible with code compiled with the -fpcc-struct-return switch.
	 Use it to conform to a non-default application binary interface.

     -fshort-enums
	 Allocate to an "enum" type only as many bytes as it needs for	the  de-
	 clared range of possible values.  Specifically, the "enum" type will be
	 equivalent to the smallest integer type which has enough room.

	 Warning:  the	-fshort-enums switch causes GCC to generate code that is
	 not binary compatible with code generated without that switch.  Use  it
	 to conform to a non-default application binary interface.

     -fshort-double
	 Use the same size for "double" as for "float".

	 Warning:  the -fshort-double switch causes GCC to generate code that is
	 not binary compatible with code generated without that switch.  Use  it
	 to conform to a non-default application binary interface.

     -fshort-wchar
	 Override  the	underlying type for wchar_t to be short unsigned int in-
	 stead of the default for the target.  This option is useful for  build-
	 ing programs to run under WINE.

	 Warning:  the	-fshort-wchar switch causes GCC to generate code that is
	 not binary compatible with code generated without that switch.  Use  it
	 to conform to a non-default application binary interface.

     -fno-common
	 In  C, allocate even uninitialized global variables in the data section
	 of the object file, rather than generating them as common blocks.  This
	 has the effect that if the same variable is declared (without "extern")
	 in two different compilations, you will get  an  error  when  you  link
	 them.	 The  only  reason this might be useful is if you wish to verify
	 that the program will work on other systems which always work this way.

     -fno-ident
	 Ignore the #ident directive.

     -finhibit-size-directive
	 Don't output a ".size" assembler directive, or anything else that would
	 cause trouble if the function is split  in  the  middle,  and	the  two
	 halves  are  placed  at  locations far apart in memory.  This option is
	 used when compiling crtstuff.c; you should not need to use it for  any-
	 thing else.

     -fverbose-asm
	 Put extra commentary information in the generated assembly code to make
	 it  more  readable.   This option is generally only of use to those who
	 actually need to read the generated assembly code (perhaps while debug-
	 ging the compiler itself).

	 -fno-verbose-asm, the default, causes the extra information to be omit-
	 ted and is useful when comparing two assembler files.

     -fpic
	 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).   The  dynamic
	 loader  resolves  the	GOT entries when the program starts (the dynamic
	 loader is not part of GCC; 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 -fpic
	 does not work; in that case, recompile with -fPIC instead.  (These max-
	 imums are 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, GCC supports PIC for  System  V
	 but not for the Sun 386i.  Code generated for the IBM RS/6000 is always
	 position-independent.

	 When  this  flag is set, the macros "__pic__" and "__PIC__" are defined
	 to 1.

     -fPIC
	 If supported for the target machine,  emit  position-independent  code,
	 suitable  for dynamic linking and avoiding any limit on the size of the
	 global offset table.  This option makes a difference on the m68k,  Pow-
	 erPC and SPARC.

	 Position-independent code requires special support, and therefore works
	 only on certain machines.

	 When  this  flag is set, the macros "__pic__" and "__PIC__" are defined
	 to 2.

     -fpie
     -fPIE
	 These options are similar to -fpic and -fPIC,	but  generated	position
	 independent  code  can  be only linked into executables.  Usually these
	 options are used when -pie GCC option will be used during linking.

     -fno-jump-tables
	 Do not use jump tables for switch statements even  where  it  would  be
	 more  efficient  than other code generation strategies.  This option is
	 of use in conjunction with -fpic or -fPIC for building code which forms
	 part of a dynamic linker and cannot reference the address of a jump ta-
	 ble.  On some targets, jump tables do not require a GOT and this option
	 is not needed.

     -ffixed-reg
	 Treat the register named reg as a fixed register; generated code should
	 never refer to it (except perhaps as a stack pointer, frame pointer  or
	 in some other fixed role).

	 reg  must  be	the name of a register.  The register names accepted are
	 machine-specific and are defined in the "REGISTER_NAMES" macro  in  the
	 machine description macro file.

	 This  flag does not have a negative form, because it specifies a three-
	 way choice.

     -fcall-used-reg
	 Treat the register named 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 reg.

	 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 perva-
	 sive roles in the machine's execution model will produce disastrous re-
	 sults.

	 This flag does not have a negative form, because it specifies a  three-
	 way choice.

     -fcall-saved-reg
	 Treat	the  register  named reg as an allocable register saved by func-
	 tions.  It may be allocated even for temporaries or variables that live
	 across a call.  Functions compiled this way will save and  restore  the
	 register reg if they use it.

	 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  perva-
	 sive roles in the machine's execution model will produce disastrous re-
	 sults.

	 A  different sort of disaster will result from the use of this flag for
	 a register in which function values may be returned.

	 This flag does not have a negative form, because it specifies a  three-
	 way choice.

     -fpack-struct[=n]
	 Without  a value specified, pack all structure members together without
	 holes.  When a value is specified (which must be a small power of two),
	 pack structure members according to this value, representing the  maxi-
	 mum  alignment  (that	is,  objects with default alignment requirements
	 larger than this will be output potentially unaligned at the next  fit-
	 ting location.

	 Warning:  the	-fpack-struct switch causes GCC to generate code that is
	 not binary compatible with code generated without that  switch.   Addi-
	 tionally, it makes the code suboptimal.  Use it to conform to a non-de-
	 fault application binary interface.

     -finstrument-functions
	 Generate  instrumentation  calls for entry and exit to functions.  Just
	 after function entry and just before function exit, the following  pro-
	 filing  functions  will be called with the address of the current func-
	 tion and its call site.  (On some platforms, "__builtin_return_address"
	 does not work beyond the current function, so the call site information
	 may not be available to the profiling functions otherwise.)

		 void __cyg_profile_func_enter (void *this_fn,
						void *call_site);
		 void __cyg_profile_func_exit  (void *this_fn,
						void *call_site);

	 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, conceptu-
	 ally, the inline function is entered and exited.  This means  that  ad-
	 dressable  versions  of  such functions must be available.  If all your
	 uses of a function are expanded inline, this may mean an additional ex-
	 pansion of code size.	If you use extern inline in your C code, an  ad-
	 dressable  version  of  such functions must be provided.  (This is nor-
	 mally the case anyways, but if you get lucky and the  optimizer  always
	 expands  the  functions inline, you might have gotten away without pro-
	 viding static copies.)

	 A function may be  given  the	attribute  "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 func-
	 tions cannot safely be called (perhaps signal handlers, if the  profil-
	 ing routines generate output or allocate memory).

     -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	environ-
	 ment  with  multiple  threads,  but only rarely need to specify it in a
	 single-threaded environment since stack overflow is  automatically  de-
	 tected on nearly all systems if there is only one stack.

	 Note  that this switch does not actually cause checking to be done; the
	 operating system must do that.  The switch causes generation of code to
	 ensure that the operating system sees the stack being extended.

     -fstack-limit-register=reg
     -fstack-limit-symbol=sym
     -fno-stack-limit
	 Generate code to ensure that the stack does not grow beyond  a  certain
	 value,  either  the value of a register or the address of a symbol.  If
	 the stack would grow beyond the value, a signal is  raised.   For  most
	 targets,  the	signal is raised before the stack overruns the boundary,
	 so it is possible to catch the signal without	taking	special  precau-
	 tions.

	 For  instance,  if  the stack starts at absolute address 0x80000000 and
	 grows	 downwards,   you   can   use	the   flags   -fstack-limit-sym-
	 bol=__stack_limit  and -Wl,--defsym,__stack_limit=0x7ffe0000 to enforce
	 a stack limit of 128KB.  Note that this may  only  work  with	the  GNU
	 linker.

     -fargument-alias
     -fargument-noalias
     -fargument-noalias-global
     -fargument-noalias-anything
	 Specify the possible relationships among parameters and between parame-
	 ters and global data.

	 -fargument-alias  specifies  that arguments (parameters) may alias each
	 other and may alias global  storage.-fargument-noalias  specifies  that
	 arguments do not alias each other, but may alias global storage.-fargu-
	 ment-noalias-global  specifies  that  arguments do not alias each other
	 and do not alias global storage.  -fargument-noalias-anything specifies
	 that arguments do not alias any other storage.

	 Each language will automatically use whatever option is required by the
	 language standard.  You should not need to use these options yourself.

     -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.

	 Warning: the -fleading-underscore switch causes GCC  to  generate  code
	 that  is not binary compatible with code generated without that switch.
	 Use it to conform to a non-default application binary	interface.   Not
	 all targets provide complete support for this switch.

     -ftls-model=model
	 Alter	the  thread-local  storage model to be used.  The model argument
	 should be one of "global-dynamic", "local-dynamic",  "initial-exec"  or
	 "local-exec".

	 The  default without -fpic is "initial-exec"; with -fpic the default is
	 "global-dynamic".

     -fvisibility=default|internal|hidden|protected
	 Set the default ELF  image  symbol  visibility  to  the  specified  op-
	 tion---all  symbols  will  be marked with this unless overridden within
	 the code.  Using this feature can very  substantially	improve  linking
	 and load times of shared object libraries, produce more optimized code,
	 provide  near-perfect	API  export  and  prevent symbol clashes.  It is
	 strongly recommended that you use this in any shared objects  you  dis-
	 tribute.

	 Despite  the  nomenclature, "default" always means public ie; available
	 to be linked against from outside the shared object.	"protected"  and
	 "internal"  are  pretty  useless  in real-world usage so the only other
	 commonly used option will be "hidden".   The  default	if  -fvisibility
	 isn't	specified  is  "default",  i.e., make every symbol public---this
	 causes the same behavior as previous versions of GCC.

	 A good explanation of the benefits offered by ensuring ELF symbols have
	 the correct visibility is given by "How To Write Shared  Libraries"  by
	 Ulrich  Drepper (which can be found at <http://people.redhat.com/~drep-
	 per/>)---however a superior solution made possible by	this  option  to
	 marking things hidden when the default is public is to make the default
	 hidden  and mark things public.  This is the norm with DLL's on Windows
	 and  with  -fvisibility=hidden  and  "__attribute__   ((visibility("de-
	 fault")))"  instead of "__declspec(dllexport)" you get almost identical
	 semantics with identical syntax.  This is a great boon to those working
	 with cross-platform projects.

	 For those adding visibility support to  existing  code,  you  may  find
	 #pragma  GCC visibility of use.  This works by you enclosing the decla-
	 rations you wish to set visibility for with (for example)  #pragma  GCC
	 visibility  push(hidden)  and #pragma GCC visibility pop.  Bear in mind
	 that symbol visibility should be viewed as part of  the  API  interface
	 contract and thus all new code should always specify visibility when it
	 is  not  the default ie; declarations only for use within the local DSO
	 should always be marked explicitly as hidden as so to avoid  PLT  indi-
	 rection  overheads---making this abundantly clear also aids readability
	 and self-documentation of the code.  Note that due to ISO C++	specifi-
	 cation requirements, operator new and operator delete must always be of
	 default visibility.

	 Be  aware  that headers from outside your project, in particular system
	 headers and headers from any other library you use, may not be  expect-
	 ing  to  be  compiled	with visibility other than the default.  You may
	 need to explicitly say #pragma GCC visibility push(default) before  in-
	 cluding any such headers.

	 extern  declarations are not affected by -fvisibility, so a lot of code
	 can be recompiled with -fvisibility=hidden with no modifications.  How-
	 ever, this means that calls to extern functions with no explicit  visi-
	 bility  will  use  the  PLT, so it is more effective to use __attribute
	 ((visibility)) and/or #pragma GCC visibility to tell the compiler which
	 extern declarations should be treated as hidden.

	 Note that -fvisibility does affect C++  vague	linkage  entities.  This
	 means	that,  for  instance, an exception class that will be thrown be-
	 tween DSOs must be explicitly marked with default  visibility	so  that
	 the type_info nodes will be unified between the DSOs.

	 An  overview of these techniques, their benefits and how to use them is
	 at <http://gcc.gnu.org/wiki/Visibility>.

ENVIRONMENT
     This section describes several environment variables that	affect	how  GCC
     operates.	 Some  of them work by specifying directories or prefixes to use
     when searching for various kinds of files.  Some are used to specify  other
     aspects of the compilation environment.

     Note  that  you can also specify places to search using options such as -B,
     -I and -L.  These take precedence over places specified  using  environment
     variables,  which	in turn take precedence over those specified by the con-
     figuration of GCC.

     LANG
     LC_CTYPE
     LC_MESSAGES
     LC_ALL
	 These environment variables control the way that GCC uses  localization
	 information that allow GCC to work with different national conventions.
	 GCC  inspects	the locale categories LC_CTYPE and LC_MESSAGES if it has
	 been configured to do so.  These locale categories can be  set  to  any
	 value	supported  by your installation.  A typical value is en_GB.UTF-8
	 for English in the United Kingdom encoded in UTF-8.

	 The LC_CTYPE environment variable specifies  character  classification.
	 GCC  uses it to determine the character boundaries in a string; this is
	 needed for some multibyte encodings that contain quote and escape char-
	 acters that would otherwise be interpreted as a string end or escape.

	 The LC_MESSAGES environment variable specifies the language to  use  in
	 diagnostic messages.

	 If  the  LC_ALL  environment variable is set, it overrides the value of
	 LC_CTYPE and LC_MESSAGES; otherwise, LC_CTYPE and  LC_MESSAGES  default
	 to  the value of the LANG environment variable.  If none of these vari-
	 ables are set, GCC defaults to traditional C English behavior.

     TMPDIR
	 If TMPDIR is set, it specifies  the  directory  to  use  for  temporary
	 files.   GCC  uses  temporary	files to hold the output of one stage of
	 compilation which is to be used as input to the next stage:  for  exam-
	 ple, the output of the preprocessor, which is the input to the compiler
	 proper.

     GCC_EXEC_PREFIX
	 If GCC_EXEC_PREFIX is set, it specifies a prefix to use in the names of
	 the  subprograms executed by the compiler.  No slash is added when this
	 prefix is combined with the name of a subprogram, but you can specify a
	 prefix that ends with a slash if you wish.

	 If GCC_EXEC_PREFIX is not set, GCC will attempt to figure out an appro-
	 priate prefix to use based on the pathname it was invoked with.

	 If GCC cannot find the subprogram using the specified prefix, it  tries
	 looking in the usual places for the subprogram.

	 The default value of GCC_EXEC_PREFIX is prefix/lib/gcc/ where prefix is
	 the value of "prefix" when you ran the configure script.

	 Other prefixes specified with -B take precedence over this prefix.

	 This prefix is also used for finding files such as crt0.o that are used
	 for linking.

	 In addition, the prefix is used in an unusual way in finding the direc-
	 tories  to  search for header files.  For each of the standard directo-
	 ries whose name normally  begins  with  /usr/local/lib/gcc  (more  pre-
	 cisely,  with	the  value of GCC_INCLUDE_DIR), GCC tries replacing that
	 beginning with the specified prefix to produce an  alternate  directory
	 name.	 Thus,	with -Bfoo/, GCC will search foo/bar where it would nor-
	 mally	search	/usr/local/lib/bar.   These  alternate	directories  are
	 searched first; the standard directories come next.

     COMPILER_PATH
	 The  value  of  COMPILER_PATH is a colon-separated list of directories,
	 much like PATH.  GCC tries the directories thus specified when  search-
	 ing   for   subprograms,   if	it  can't  find  the  subprograms  using
	 GCC_EXEC_PREFIX.

     LIBRARY_PATH
	 The value of LIBRARY_PATH is a  colon-separated  list	of  directories,
	 much  like  PATH.   When configured as a native compiler, GCC tries the
	 directories thus specified when searching for special linker files,  if
	 it  can't find them using GCC_EXEC_PREFIX.  Linking using GCC also uses
	 these directories when searching for ordinary libraries for the -l  op-
	 tion (but directories specified with -L come first).

     LANGThis  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 multi-
	 byte characters, the following values for LANG are recognized:

	 C-JIS
	     Recognize JIS characters.

	 C-SJIS
	     Recognize SJIS characters.

	 C-EUCJP
	     Recognize EUCJP characters.

	 If LANG is not defined, or if it has some other value,  then  the  com-
	 piler	will  use  mblen  and mbtowc as defined by the default locale to
	 recognize and translate multibyte characters.

     Some additional environments variables affect  the  behavior  of  the  pre-
     processor.

     CPATH
     C_INCLUDE_PATH
     CPLUS_INCLUDE_PATH
	 Each  variable's  value is a list of directories separated by a special
	 character, much like PATH, in which to look for header files.	The spe-
	 cial character, "PATH_SEPARATOR", is target-dependent and determined at
	 GCC build time.  For Microsoft Windows-based targets it is a semicolon,
	 and for almost all other targets it is a colon.

	 CPATH specifies a list of directories to be searched  as  if  specified
	 with -I, but after any paths given with -I options on the command line.
	 This environment variable is used regardless of which language is being
	 preprocessed.

	 The  remaining  environment variables apply only when preprocessing the
	 particular language indicated.  Each specifies a list of directories to
	 be searched as if specified with -isystem, but after  any  paths  given
	 with -isystem options on the command line.

	 In  all  these  variables,  an  empty element instructs the compiler to
	 search its current working directory.	Empty elements can appear at the
	 beginning or end of a path.  For instance, if the  value  of  CPATH  is
	 ":/special/include",  that  has  the  same effect as -I. -I/special/in-
	 clude.

     DEPENDENCIES_OUTPUT
	 If this variable is set, its value specifies how to output dependencies
	 for Make based on the non-system header files	processed  by  the  com-
	 piler.  System header files are ignored in the dependency output.

	 The value of DEPENDENCIES_OUTPUT can be just a file name, in which case
	 the  Make rules are written to that file, guessing the target name from
	 the source file name.	Or the value can have the form file  target,  in
	 which	case the rules are written to file file using target as the tar-
	 get name.

	 In other words, this environment variable is  equivalent  to  combining
	 the options -MM and -MF, with an optional -MT switch too.

     SUNPRO_DEPENDENCIES
	 This  variable  is  the same as DEPENDENCIES_OUTPUT (see above), except
	 that system header files are not ignored, so it implies -M rather  than
	 -MM.  However, the dependence on the main input file is omitted.

BUGS
     For instructions on reporting bugs, see <http://gcc.gnu.org/bugs.html>.

FOOTNOTES
     1.  On some systems, gcc -shared needs to build supplementary stub code for
	 constructors to work.	On multi-libbed systems, gcc -shared must select
	 the  correct  support libraries to link against.  Failing to supply the
	 correct flags may lead to subtle  defects.   Supplying  them  in  cases
	 where they are not necessary is innocuous.

SEE ALSO
     gpl(7),  gfdl(7),	fsf-funding(7),  cpp(1),  gcov(1), as(1), ld(1), gdb(1),
     adb(1), dbx(1), sdb(1) and the Info entries for gcc, cpp, as, ld,	binutils
     and gdb.

AUTHOR
     See the Info entry for gcc, or <http://gcc.gnu.org/onlinedocs/gcc/Contribu-
     tors.html>, for contributors to GCC.

COPYRIGHT
     Copyright	(c)  1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
     2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

     Permission is granted to copy, distribute and/or modify this document under
     the terms of the GNU Free Documentation License, Version 1.2 or  any  later
     version  published by the Free Software Foundation; with the Invariant Sec-
     tions being "GNU General Public License" and "Funding Free  Software",  the
     Front-Cover  texts being (a) (see below), and with the Back-Cover Texts be-
     ing (b) (see below).  A copy of the license is included in the gfdl(7)  man
     page.

     (a) The FSF's Front-Cover Text is:

	  A GNU Manual

     (b) The FSF's Back-Cover Text is:

	  You have freedom to copy and modify this GNU Manual, like GNU
	  software.  Copies published by the Free Software Foundation raise
	  funds for GNU development.

gcc-4.2.1			   2011-03-07				  GCC(1)

home | help