Quick ?s
Cheat Sheets
Man Pages
The Lynx
GCC(1)				      GNU				GCC(1)

       gcc - GNU project C and C++ compiler

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

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

       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
       control 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 particular 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 doesnt 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,
       -fstrength-reduce, -Wformat and so on.  Most of these have both
       positive 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.

       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

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

       C++ Language Options
	   -fabi-version=n  -fno-access-control  -fcheck-new -fconserve-space
	   -ffriend-injection  -fno-const-strings -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	-fpermissive -frepo  -fno-rtti	-fstats
	   -ftemplate-depth-n -fno-threadsafe-statics -fuse-cxa-atexit
	   -fno-weak  -nostdinc++ -fno-default-inline
	   -fvisibility-inlines-hidden -Wabi  -Wctor-dtor-privacy
	   -Wnon-virtual-dtor  -Wreorder -Weffc++  -Wno-deprecated
	   -Wstrict-null-sentinel -Wno-non-template-friend  -Wold-style-cast
	   -Woverloaded-virtual  -Wno-pmf-conversions -Wsign-promo

       Objective-C and Objective-C++ Language Options
	   -fconstant-string-class=class-name -fgnu-runtime  -fnext-runtime
	   -fno-nil-receivers -fobjc-call-cxx-cdtors -fobjc-direct-dispatch
	   -fobjc-exceptions -fobjc-gc -freplace-objc-classes -fzero-link
	   -gen-decls -Wassign-intercept -Wno-protocol	-Wselector
	   -Wstrict-selector-match -Wundeclared-selector

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

       Warning Options
	   -fsyntax-only  -pedantic  -pedantic-errors -w  -Wextra  -Wall
	   -Waggregate-return -Wno-attributes -Wc++-compat -Wcast-align
	   -Wcast-qual	-Wchar-subscripts  -Wcomment -Wconversion
	   -Wno-deprecated-declarations -Wdisabled-optimization
	   -Wno-div-by-zero  -Wno-endif-labels -Werror
	   -Werror-implicit-function-declaration -Wfatal-errors  -Wfloat-equal
	   -Wformat  -Wformat=2 -Wno-format-extra-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
	   -Wpacked  -Wpadded -Wparentheses  -Wpointer-arith
	   -Wno-pointer-to-int-cast -Wredundant-decls -Wreturn-type
	   -Wsequence-point  -Wshadow -Wsign-compare  -Wstack-protector
	   -Wstrict-aliasing -Wstrict-aliasing=2 -Wswitch  -Wswitch-default
	   -Wswitch-enum -Wsystem-headers  -Wtrigraphs	-Wundef
	   -Wuninitialized -Wunknown-pragmas  -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
	   -Wtraditional -Wdeclaration-after-statement -Wpointer-sign

       Debugging Options
	   -dletters  -dumpspecs  -dumpmachine	-dumpversion -fdump-unnumbered
	   -fdump-translation-unit[-n] -fdump-class-hierarchy[-n]
	   -fdump-ipa-all -fdump-ipa-cgraph -fdump-tree-all
	   -fdump-tree-original[-n] -fdump-tree-optimized[-n]
	   -fdump-tree-inlined[-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-copyrename[-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-debug-types
	   -feliminate-unused-debug-symbols -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-directory  -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] -fmudflap -fmudflapth -fmudflapir
	   -fbranch-probabilities -fprofile-values -fvpt
	   -fbranch-target-load-optimize -fbranch-target-load-optimize2
	   -fbtr-bb-exclusive -fcaller-saves  -fcprop-registers
	   -fcse-follow-jumps -fcse-skip-blocks  -fcx-limited-range
	   -fdata-sections -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 -floop-optimize
	   -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-default-inline	-fno-defer-pop -floop-optimize2
	   -fmove-loop-invariants -fno-function-cse
	   -fno-guess-branch-probability -fno-inline  -fno-math-errno
	   -fno-peephole  -fno-peephole2 -funsafe-math-optimizations
	   -funsafe-loop-optimizations	-ffinite-math-only -fno-trapping-math
	   -fno-zero-initialized-in-bss -fomit-frame-pointer
	   -foptimize-register-move -foptimize-sibling-calls
	   -fprefetch-loop-arrays -fprofile-generate -fprofile-use -fregmove
	   -frename-registers -freorder-blocks	-freorder-blocks-and-partition
	   -freorder-functions -frerun-cse-after-loop  -frerun-loop-opt
	   -frounding-math -fschedule-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 -freschedule-modulo-scheduled-loops
	   -fsignaling-nans -fsingle-precision-constant -fstack-protector
	   -fstack-protector-all -fstrength-reduce  -fstrict-aliasing
	   -ftracer  -fthread-jumps -funroll-all-loops	-funroll-loops
	   -fpeel-loops -fsplit-ivs-in-unroller -funswitch-loops
	   -fvariable-expansion-in-unroller -ftree-pre	-ftree-ccp  -ftree-dce
	   -ftree-loop-optimize -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 -fweb -ftree-copy-prop -ftree-store-ccp
	   -ftree-store-copy-prop -ftree-vrp -funit-at-a-time -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
	   -nostdinc -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 -mtpcs-frame  -mtpcs-leaf-frame
	   -mcaller-super-interworking	-mcallee-super-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

	   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	-compatibility_version
	   -current_version -dead_strip -dependency-file  -dylib_file
	   -dylinker_install_name -dynamic  -dynamiclib
	   -exported_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_umbrella
	   -twolevel_namespace	-umbrella  -undefined -unexported_symbols_list
	   -weak_reference_mismatches -whatsloaded -F -gused -gfull
	   -mmacosx-version-min=version -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-rounding-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
	   -minline-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-optimize-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

	   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-disable-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 -mpreferred-stack-boundary=num -mmmx	-msse  -msse2
	   -msse3 -m3dnow -mthreads  -mno-align-stringops
	   -minline-all-stringops -mpush-args  -maccumulate-outgoing-args
	   -m128bit-long-double -m96bit-long-double  -mregparm=num
	   -msseregparm -momit-leaf-frame-pointer  -mno-red-zone
	   -mno-tls-direct-seg-refs -mcmodel=code-model -m32  -m64

	   IA-64 Options -mbig-endian  -mlittle-endian	-mgnu-as  -mgnu-ld
	   -mno-pic -mvolatile-asm-stop  -mregister-names  -mno-sdata
	   -mconstant-gp  -mauto-pic  -minline-float-divide-min-latency
	   -minline-int-divide-min-latency -minline-int-divide-max-throughput
	   -minline-sqrt-min-latency -minline-sqrt-max-throughput
	   -mno-dwarf2-asm -mearly-stop-bits -mfixed-range=register-range
	   -mtls-size=tls-size -mtune=cpu-type -mt -pthread -milp32 -mlp64

	   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  -m68881  -mbitfield  -mc68000
	   -mc68020 -mnobitfield  -mrtd  -mshort  -msoft-float	-mpcrel
	   -malign-int	-mstrict-align	-msep-data  -mno-sep-data
	   -mshared-library-id=n  -mid-shared-library  -mno-id-shared-library

	   M68hc1x Options -m6811  -m6812  -m68hc11  -m68hc12	-m68hcs12
	   -mauto-incdec  -minmax  -mlong-calls  -mshort

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

	   MIPS Options -EL  -EB  -march=arch  -mtune=arch -mips1  -mips2
	   -mips3  -mips4  -mips32  -mips32r2  -mips64 -mips16	-mno-mips16
	   -mabi=abi  -mabicalls  -mno-abicalls -mxgot	-mno-xgot  -mgp32
	   -mgp64  -mfp32  -mfp64 -mhard-float	-msoft-float  -msingle-float
	   -mdouble-float -mdsp  -mpaired-single  -mips3d -mlong64  -mlong32
	   -msym32  -mno-sym32 -Gnum  -membedded-data  -mno-embedded-data
	   -muninit-const-in-rodata  -mno-uninit-const-in-rodata
	   -msplit-addresses  -mno-split-addresses -mexplicit-relocs
	   -mno-explicit-relocs -mcheck-zero-division
	   -mno-check-zero-division -mdivide-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

	   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 -mpowerpc-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  -mrelocatable
	   -mno-relocatable  -mrelocatable-lib	-mno-relocatable-lib -mtoc
	   -mno-toc  -mlittle  -mlittle-endian	-mbig  -mbig-endian
	   -mdynamic-no-pic  -maltivec	-mswdiv
	   -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 -mfloat-gprs=yes  -mfloat-gprs=no
	   -mfloat-gprs=single -mfloat-gprs=double -mprototype	-mno-prototype
	   -msim  -mmvme  -mads  -myellowknife	-memb  -msdata -msdata=opt
	   -mvxworks  -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

	   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-compact	-m5-compact-nofpu -mb  -ml  -mdalign  -mrelax
	   -mbigtable  -mfmovd	-mhitachi -mrenesas -mno-renesas -mnomacsave
	   -mieee  -misize  -mpadstruct  -mspace -mprefergot  -musermode
	   -multcost=number -mdiv=strategy -mdivsi3_libfunc=name
	   -madjust-unroll -mindexed-addressing -mgettrcost=number -mpt-fixed

	   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-doubles -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  -mpreserve-float

	   V850 Options -mlong-calls  -mno-long-calls  -mep  -mno-ep
	   -mprolog-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-tables -freg-struct-return  -fshared-data	-fshort-enums
	   -fshort-double  -fshort-wchar -fverbose-asm	-fpack-struct[=n]
	   -fstack-check -fstack-limit-register=reg  -fstack-limit-symbol=sym
	   -fno-stack-limit  -fargument-alias  -fargument-noalias
	   -fargument-noalias-global  -fleading-underscore -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
       preprocessing 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
       compilation is done:

	   C source code which must be preprocessed.

	   C source code which should not be preprocessed.

	   C++ source code which should not be preprocessed.

	   Objective-C source code.  Note that you must link with the libobjc
	   library to make an Objective-C program work.

	   Objective-C source code which should not be preprocessed.

	   Objective-C++ source code.  Note that you must link with the
	   libobjc library to make an Objective-C++ program work.  Note that
	   .M refers to a literal capital M.

	   Objective-C++ source code which should not be preprocessed.

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

	   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.

	   Objective-C++ source code which must be preprocessed.

	   Objective-C++ source code which should not be preprocessed.

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

	   Fixed form Fortran source code which should not be preprocessed.

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

	   Free form Fortran source code which should not be preprocessed.

	   Free form Fortran source code which must be preprocessed (with the
	   traditional preprocessor).

	   Ada source code file which contains a library unit declaration (a
	   declaration of a package, subprogram, or generic, or a generic
	   instantiation), or a library unit renaming declaration (a package,
	   generic, or subprogram renaming declaration).  Such files are also
	   called specs.

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

	   Assembler code.

	   Assembler code which must be preprocessed.

	   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 suffix).  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
		   objective-c	objective-c-header  objective-c-cpp-output
		   objective-c++ objective-c++-header objective-c++-cpp-output
		   assembler  assembler-with-cpp
		   f95	f95-cpp-input

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

	   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.

       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
	   object 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
	   output is in the form of an assembler code file for each non-
	   assembler input file specified.

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

	   Input files that dont 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 dont 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

	   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.

	   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
	   assembler has no trouble.

	   If you are compiling multiple source files, this option tells the
	   driver to pass all the source files to the compiler at once (for
	   those languages for which the compiler can handle this).  This will
	   allow intermodule 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 driver will invoke the compiler(s) that support
	   IMA once each, passing each compiler all the source files
	   appropriate for it.	For those languages 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.

	   Print (on the standard output) a description of the command line
	   options 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

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

	   Display the version number and copyrights of the invoked GCC.

       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
       preprocessed 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, C++ programs often require class libraries as well as a
       compiler that understands the C++ language---and under some
       circumstances, you might want to compile programs or header files from
       standard input, or otherwise without a suffix that flags them as C++
       programs.  You might also like to precompile a C header file with a .h
       extension to be used in C++ compilations.  g++ is a program that calls
       GCC with the default language set to C++, and automatically specifies
       linking against the C++ library.  On many systems, 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 command-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++, Objective-C and Objective-C++) that the compiler

	   In C mode, support all ISO C90 programs.  In C++ mode, remove GNU
	   extensions 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 using.  It also enables the undesirable and rarely used ISO
	   trigraph feature.  For the C compiler, it disables recognition of
	   C++ style // comments 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
	   gratuitously.  For that, -pedantic is required in addition to

	   The macro "__STRICT_ANSI__" is predefined when the -ansi option is
	   used.  Some header files may notice this macro and refrain from
	   declaring certain functions or defining certain macros that the ISO
	   standard doesnt 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 functions with -ansi is used.

	   Determine the language standard.  This option is currently only
	   supported when compiling C or C++.  A value for this option must be
	   provided; possible values are

	       ISO C90 (same as -ansi).

	       ISO C90 as modified in amendment 1.

	       ISO C99.  Note that this standard is not yet fully supported;
	       see  for more
	       information.  The names c9x and iso9899:199x are deprecated.

	       Default, ISO C90 plus GNU extensions (including some C99

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

	       The 1998 ISO C++ standard plus amendments.

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

	   The option -fgnu89-inline tells GCC to use the traditional GNU
	   semantics 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 option is effectively assumed to be present regardless of
	   whether or not it is specified; the only effect of specifying it
	   explicitly is to disable 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" functions.

	   The option -fgnu89-inline tells GCC to use the traditional GNU
	   semantics 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 option is effectively assumed to be present regardless of
	   whether or not it is specified; the only effect of specifying it
	   explicitly is to disable 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" functions.

       -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, respectively, 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 definitions, a K&R-style list of arguments followed by
	   their declarations is also provided, inside comments, after the

	   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

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

	   Dont recognize built-in functions that do not begin with
	   __builtin_ as prefix.

	   GCC normally generates special code to handle certain built-in
	   functions more efficiently; for instance, calls to "alloca" may
	   become single 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 information 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
	   function is disabled.  function must not begin with __builtin_.  If
	   a function 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))

	   Assert that compilation takes place in a hosted environment.  This
	   implies -fbuiltin.  A hosted environment is one in which the entire
	   standard library is available, and in which "main" has a return
	   type of "int".  Examples are nearly everything except a kernel.
	   This is equivalent to -fno-freestanding.

	   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 necessarily be at "main".  The most obvious example is an OS
	   kernel.  This is equivalent to -fno-hosted.

	   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.

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

	   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.

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

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

	   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

	   Ideally, a portable program should always use "signed char" or
	   "unsigned 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.

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

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

	   These options control whether a bit-field is signed or unsigned,
	   when the declaration does not use either "signed" or "unsigned".
	   By default, such a bit-field is signed, because this is consistent:
	   the basic 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 regardless of what language your program is in.  For
       example, you might compile 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:

	   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 version that conforms most closely to the C++ ABI
	   specification.  Therefore, the ABI obtained using version 0 will
	   change as ABI bugs are fixed.

	   The default is version 2.

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

	   Check that the pointer returned by "operator new" is non-null
	   before attempting to modify the storage allocated.  This check is
	   normally unnecessary 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 specification, memory exhaustion is signalled
	   by throwing "std::bad_alloc".  See also new (nothrow).

	   Put uninitialized or runtime-initialized global variables into the
	   common 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 definitions were merged.

	   This option is no longer useful on most targets, now that support
	   has been added for putting variables into BSS without making them

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

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

	   Give string constants type "char *" instead of type "const char *".
	   By default, G++ uses type "const char *" as required by the
	   standard.  Even if you use -fno-const-strings, you cannot actually
	   modify the value of a string constant.

	   This option might be removed in a future release of G++.  For
	   maximum portability, you should structure your code so that it
	   works with string constants that have type "const char *".

	   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.

	   Dont 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 violation of the exception specifications; the
	   compiler will still optimize based on the specifications, so
	   throwing an unexpected exception will result in undefined behavior.

	   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
	   allow and give a warning for old-style code that would otherwise be
	   invalid, or have different behavior.

	   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.

	   Never emit code for non-inline templates which are instantiated
	   implicitly (i.e. by use); only emit code for explicit

	   Dont emit code for implicit instantiations of inline templates,
	   either.  The default is to handle inlines differently so that
	   compiles with and without optimization will need the same set of
	   explicit instantiations.

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

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

	   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.

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

	   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.

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

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

	   Disable generation of information about every class with virtual
	   functions for use by the C++ runtime type identification features
	   (dynamic_cast and typeid).  If you dont use those parts of the
	   language, you can save some space by using this flag.  Note that
	   exception handling uses the same information, but it will generate
	   it as needed.

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

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

	   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 option to reduce code size slightly in code that doesnt need
	   to be thread-safe.

	   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 destructors, but will only work if your C library supports

	   Causes all inlined methods to be marked with "__attribute__
	   ((visibility ("hidden")))" so that they do not appear 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 effect 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

	   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, or the
	   method has local static data, you might mark it as having default

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

	   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:

	   Do not assume inline for functions defined inside a class scope.
	     Note that these functions will have linkage like inline
	   functions; they just wont 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 generated will be compatible.

	   You should rewrite your code to avoid these warnings if you are
	   concerned about the fact that code generated by G++ may not be
	   binary compatible 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

		       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

		       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 (ignoring 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
	       template template parameters can be mangled incorrectly.

		       void f(typename Q::X) {}