GCC linux command manual

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 docu-
       mented 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 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 exam-
       ple, -fforce-mem, -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  -pipe  -pass-exit-codes -x language  -v  -###
           --help  --target-help  --version

       C Language Options
           -ansi  -std=standard  -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  -funsigned-char

       C++ Language Options
           -fabi-version=n  -fno-access-control  -fcheck-new -fconserve-space
           -fno-const-strings  -fdollars-in-identifiers -fno-elide-construc-
           tors -fno-enforce-eh-specs  -fexternal-templates -falt-exter-
           nal-templates -ffor-scope  -fno-for-scope  -fno-gnu-keywords
           -fno-implicit-templates -fno-implicit-inline-templates -fno-imple-
           ment-inlines  -fms-extensions -fno-nonansi-builtins  -fno-opera-
           tor-names -fno-optional-diags  -fpermissive -frepo  -fno-rtti
           -fstats  -ftemplate-depth-n -fuse-cxa-atexit  -fvtable-gc
           -fno-weak  -nostdinc++ -fno-default-inline  -Wabi
           -Wctor-dtor-privacy -Wnon-virtual-dtor  -Wreorder -Weffc++
           -Wno-deprecated -Wno-non-template-friend  -Wold-style-cast -Wover-
           loaded-virtual  -Wno-pmf-conversions -Wsign-promo  -Wsynth

       Objective-C Language Options
           -fconstant-string-class=class-name -fgnu-runtime  -fnext-runtime
           -gen-decls -Wno-protocol  -Wselector  -Wundeclared-selector

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

       Warning Options
           -fsyntax-only  -pedantic  -pedantic-errors -w  -W  -Wall  -Waggre-
           gate-return -Wcast-align  -Wcast-qual  -Wchar-subscripts  -Wcom-
           ment -Wconversion  -Wno-deprecated-declarations -Wdisabled-opti-
           mization  -Wno-div-by-zero  -Werror -Wfloat-equal  -Wformat
           -Wformat=2 -Wformat-nonliteral  -Wformat-security -Wimplicit
           -Wimplicit-int -Wimplicit-function-declaration -Wer-
           ror-implicit-function-declaration -Wimport  -Winline
           -Wno-endif-labels -Wlarger-than-len  -Wlong-long -Wmain  -Wmiss-
           ing-braces -Wmissing-format-attribute  -Wmissing-noreturn
           -Wno-multichar  -Wno-format-extra-args  -Wno-format-y2k
           -Wno-import  -Wnonnull  -Wpacked  -Wpadded -Wparentheses
           -Wpointer-arith  -Wredundant-decls -Wreturn-type  -Wsequence-point
           -Wshadow -Wsign-compare  -Wstrict-aliasing -Wswitch
           -Wswitch-default  -Wswitch-enum -Wsystem-headers  -Wtrigraphs
           -Wundef  -Wuninitialized -Wunknown-pragmas  -Wunreachable-code
           -Wunused  -Wunused-function  -Wunused-label  -Wunused-parameter
           -Wunused-value  -Wunused-variable  -Wwrite-strings

       C-only Warning Options
           -Wbad-function-cast  -Wmissing-declarations -Wmissing-prototypes
           -Wnested-externs -Wstrict-prototypes  -Wtraditional -Wdeclara-

       Debugging Options
           -dletters  -dumpspecs  -dumpmachine  -dumpversion -fdump-unnum-
           bered  -fdump-translation-unit[-n] -fdump-class-hierarchy[-n]
           -fdump-tree-original[-n] -fdump-tree-optimized[-n]
           -fdump-tree-inlined[-n] -feliminate-dwarf2-dups  -fmem-report
           -fprofile-arcs  -frandom-seed=n -fsched-verbose=n -ftest-coverage
           -ftime-report -g  -glevel  -gcoff  -gdwarf  -gdwarf-1  -gdwarf-1+
           -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 -fbranch-probabilities  -fcaller-saves
           -fcprop-registers -fcse-follow-jumps  -fcse-skip-blocks
           -fdata-sections -fdelayed-branch  -fdelete-null-pointer-checks
           -fexpensive-optimizations  -ffast-math  -ffloat-store -fforce-addr
           -fforce-mem  -ffunction-sections -fgcse  -fgcse-lm  -fgcse-sm
           -floop-optimize  -fcrossjumping -fif-conversion  -fif-conversion2
           -finline-functions  -finline-limit=n  -fkeep-inline-functions
           -fkeep-static-consts  -fmerge-constants  -fmerge-all-constants
           -fmove-all-movables  -fnew-ra  -fno-branch-count-reg
           -fno-default-inline  -fno-defer-pop -fno-function-cse
           -fno-guess-branch-probability -fno-inline  -fno-math-errno
           -fno-peephole  -fno-peephole2 -funsafe-math-optimizations  -ffi-
           nite-math-only -fno-trapping-math  -fno-zero-initialized-in-bss
           -fomit-frame-pointer  -foptimize-register-move -foptimize-sib-
           ling-calls  -fprefetch-loop-arrays -freduce-all-givs  -fregmove
           -frename-registers -freorder-blocks  -freorder-functions -fre-
           run-cse-after-loop  -frerun-loop-opt -fschedule-insns  -fsched-
           ule-insns2 -fno-sched-interblock  -fno-sched-spec
           -fsched-spec-load -fsched-spec-load-dangerous  -fsignaling-nans
           -fsingle-precision-constant  -fssa  -fssa-ccp  -fssa-dce
           -fstrength-reduce  -fstrict-aliasing  -ftracer  -fthread-jumps
           -funroll-all-loops  -funroll-loops --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 -M  -MM  -MF  -MG  -MP  -MQ  -MT  -nostdinc  -P  -remap -tri-
           graphs  -undef  -Umacro  -Wp,option

       Assembler Option

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

       Directory Options
           -Bprefix  -Idir  -I-  -Ldir  -specs=file

       Target Options
           -V version  -b machine

       Machine Dependent Options
           M680x0 Options -m68000  -m68020  -m68020-40  -m68020-60  -m68030
           -m68040 -m68060  -mcpu32  -m5200  -m68881  -mbitfield  -mc68000
           -mc68020 -mfpa  -mnobitfield  -mrtd  -mshort  -msoft-float
           -mpcrel -malign-int  -mstrict-align

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

           VAX Options -mg  -mgnu  -munix

           SPARC Options -mcpu=cpu-type -mtune=cpu-type -mcmodel=code-model
           -m32  -m64 -mapp-regs  -mbroken-saverestore  -mcypress
           -mfaster-structs  -mflat -mfpu  -mhard-float  -mhard-quad-float
           -mimpure-text  -mlittle-endian  -mlive-g0  -mno-app-regs
           -mno-faster-structs  -mno-flat  -mno-fpu -mno-impure-text
           -mno-stack-bias  -mno-unaligned-doubles -msoft-float
           -msoft-quad-float  -msparclite  -mstack-bias -msupersparc
           -munaligned-doubles  -mv8

           ARM Options -mapcs-frame  -mno-apcs-frame -mapcs-26  -mapcs-32
           -mapcs-stack-check  -mno-apcs-stack-check -mapcs-float
           -mno-apcs-float -mapcs-reentrant  -mno-apcs-reentrant
           -msched-prolog  -mno-sched-prolog -mlittle-endian  -mbig-endian
           -mwords-little-endian -malignment-traps  -mno-alignment-traps
           -msoft-float  -mhard-float  -mfpe -mthumb-interwork
           -mno-thumb-interwork -mcpu=name  -march=name  -mfpe=name -mstruc-
           ture-size-boundary=n -mabort-on-noreturn -mlong-calls
           -mno-long-calls -msingle-pic-base  -mno-single-pic-base -mpic-reg-
           ister=reg -mnop-fun-dllimport -mpoke-function-name -mthumb  -marm
           -mtpcs-frame  -mtpcs-leaf-frame -mcaller-super-interworking

           MN10200 Options -mrelax

           MN10300 Options -mmult-bug  -mno-mult-bug -mam33  -mno-am33
           -mno-crt0  -mrelax

           M32R/D Options -m32rx  -m32r  -mcode-model=model-type
           -msdata=sdata-type  -G num

           M88K Options -m88000  -m88100  -m88110  -mbig-pic
           -mcheck-zero-division  -mhandle-large-shift -midentify-revision
           -mno-check-zero-division -mno-ocs-debug-info  -mno-ocs-frame-posi-
           tion -mno-optimize-arg-area  -mno-serialize-volatile -mno-under-
           scores  -mocs-debug-info -mocs-frame-position  -moptimize-arg-area
           -mserialize-volatile  -mshort-data-num  -msvr3 -msvr4
           -mtrap-large-shift  -muse-div-instruction -mversion-03.00

           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-pow-
           erpc-gpopt -mpowerpc-gfxopt  -mno-powerpc-gfxopt -mnew-mnemonics
           -mold-mnemonics -mfull-toc   -mminimal-toc  -mno-fp-in-toc
           -mno-sum-in-toc -m64  -m32  -mxl-call  -mno-xl-call  -mpe
           -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-relocat-
           able-lib -mtoc  -mno-toc  -mlittle  -mlittle-endian  -mbig
           -mbig-endian -mcall-aix  -mcall-sysv  -mcall-netbsd
           -maix-struct-return  -msvr4-struct-return -mabi=altivec
           -mabi=no-altivec -mabi=spe  -mabi=no-spe -misel=yes  -misel=no
           -mprototype  -mno-prototype -msim  -mmvme  -mads  -myellowknife
           -memb  -msdata -msdata=opt  -mvxworks  -mwindiss  -G num  -pthread

           Darwin Options

           -all_load -allowable_client -arch -arch_errors_fatal -arch_only
           -bind_at_load -bundle -bundle_loader -client_name -compatibil-
           ity_version -current_version -dependency-file -dylib_file
           -dylinker_install_name -dynamic -dynamiclib -exported_symbols_list
           -filelist -flat_namespace -force_cpusubtype_ALL -force_flat_names-
           pace -headerpad_max_install_names -image_base -init -install_name
           -keep_private_externs -multi_module -multiply_defined -multi-
           ply_defined_unused -noall_load -nomultidefs -noprebind
           -noseglinkedit -pagezero_size -prebind -prebind_all_twolevel_mod-
           ules -private_bundle -read_only_relocs -sectalign -sectobjectsym-
           bols -whyload -seg1addr -sectcreate -sectobjectsymbols -sectorder
           -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 -unde-
           fined -unexported_symbols_list -weak_reference_mismatches -what-

           RT Options -mcall-lib-mul  -mfp-arg-in-fpregs  -mfp-arg-in-gregs
           -mfull-fp-blocks  -mhc-struct-return  -min-line-mul -mmini-
           mum-fp-blocks  -mnohc-struct-return

           MIPS Options -mabicalls  -march=cpu-type  -mtune=cpu=type
           -mcpu=cpu-type  -membedded-data  -muninit-const-in-rodata -membed-
           ded-pic  -mfp32  -mfp64  -mfused-madd  -mno-fused-madd -mgas
           -mgp32  -mgp64 -mgpopt  -mhalf-pic  -mhard-float  -mint64  -mips1
           -mips2  -mips3  -mips4  -mlong64  -mlong32  -mlong-calls  -mmemcpy
           -mmips-as  -mmips-tfile  -mno-abicalls -mno-embedded-data
           -mno-uninit-const-in-rodata -mno-embedded-pic  -mno-gpopt
           -mno-long-calls -mno-memcpy  -mno-mips-tfile  -mno-rnames
           -mno-stats -mrnames  -msoft-float -m4650  -msingle-float  -mmad
           -mstats  -EL  -EB  -G num  -nocpp -mabi=32  -mabi=n32  -mabi=64
           -mabi=eabi -mfix7000  -mno-crt0  -mflush-func=func
           -mno-flush-func -mbranch-likely  -mno-branch-likely

           i386 and x86-64 Options -mcpu=cpu-type  -march=cpu-type -mfp-
           math=unit  -masm=dialect  -mno-fancy-math-387 -mno-fp-ret-in-387
           -msoft-float  -msvr3-shlib -mno-wide-multiply  -mrtd  -malign-dou-
           ble -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  -momit-leaf-frame-pointer
           -mno-red-zone -mcmodel=code-model -m32  -m64

           HPPA Options -march=architecture-type -mbig-switch  -mdis-
           able-fpregs  -mdisable-indexing -mfast-indirect-calls  -mgas
           -mgnu-ld  -mhp-ld -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 -nolibdld  -static  -threads

           Intel 960 Options -mcpu-type  -masm-compat  -mclean-linkage
           -mcode-align  -mcomplex-addr  -mleaf-procedures -mic-compat
           -mic2.0-compat  -mic3.0-compat -mintel-asm  -mno-clean-linkage
           -mno-code-align -mno-complex-addr  -mno-leaf-procedures
           -mno-old-align  -mno-strict-align  -mno-tail-call -mnumerics
           -mold-align  -msoft-float  -mstrict-align -mtail-call

           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 -mmemory-latency=time

           DEC Alpha/VMS Options -mvms-return-codes

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

           SH Options -m1  -m2  -m3  -m3e -m4-nofpu  -m4-single-only
           -m4-single  -m4 -m5-64media  -m5-64media-nofpu -m5-32media
           -m5-32media-nofpu -m5-compact  -m5-compact-nofpu -mb  -ml
           -mdalign  -mrelax -mbigtable  -mfmovd  -mhitachi  -mnomacsave
           -mieee  -misize  -mpadstruct  -mspace -mprefergot  -musermode

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

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

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

           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-dis-
           able-callt -mv850e -mv850  -mbig-switch

           NS32K Options -m32032  -m32332  -m32532  -m32081  -m32381
           -mmult-add  -mnomult-add  -msoft-float  -mrtd  -mnortd -mregparam
           -mnoregparam  -msb  -mnosb -mbitfield  -mnobitfield  -mhimem

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

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

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

           IA-64 Options -mbig-endian  -mlittle-endian  -mgnu-as  -mgnu-ld
           -mno-pic -mvolatile-asm-stop  -mb-step  -mregister-names
           -mno-sdata -mconstant-gp  -mauto-pic  -min-
           line-float-divide-min-latency -minline-float-divide-max-throughput
           -minline-int-divide-min-latency -minline-int-divide-max-throughput
           -mno-dwarf2-asm -mfixed-range=register-range

           D30V Options -mextmem  -mextmemory  -monchip  -mno-asm-optimize
           -masm-optimize  -mbranch-cost=n  -mcond-exec=n

           S/390 and zSeries Options -mhard-float  -msoft-float  -mbackchain
           -mno-backchain -msmall-exec  -mno-small-exec  -mmvcle  -mno-mvcle
           -m64  -m31  -mdebug  -mno-debug

           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

           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  -mab-
           shi  -mno-abshi -mbranch-expensive  -mbranch-cheap -msplit
           -mno-split  -munix-asm  -mdec-asm

           Xstormy16 Options -msim

           Xtensa Options -mbig-endian  -mlittle-endian -mdensity  -mno-den-
           sity -mmac16  -mno-mac16 -mmul16  -mno-mul16 -mmul32  -mno-mul32
           -mnsa  -mno-nsa -mminmax  -mno-minmax -msext  -mno-sext -mbooleans
           -mno-booleans -mhard-float  -msoft-float -mfused-madd
           -mno-fused-madd -mserialize-volatile  -mno-serialize-volatile
           -mtext-section-literals  -mno-text-section-literals -mtarget-align
           -mno-target-align -mlongcalls  -mno-longcalls

           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  -mli-
           brary-pic -macc-4  -macc-8  -mpack  -mno-pack  -mno-eflags
           -mcond-move  -mno-cond-move -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 -mcpu=cpu

       Code Generation Options
           -fcall-saved-reg  -fcall-used-reg -ffixed-reg  -fexceptions
           -fnon-call-exceptions  -funwind-tables -fasyn-
           chronous-unwind-tables -finhibit-size-directive  -finstru-
           ment-functions -fno-common  -fno-ident  -fno-gnu-linker
           -fpcc-struct-return  -fpic  -fPIC -fpie -fPIE -freg-struct-return
           -fshared-data  -fshort-enums -fshort-double  -fshort-wchar
           -fvolatile -fvolatile-global  -fvolatile-static -fverbose-asm
           -fpack-struct  -fstack-check -fstack-limit-register=reg
           -fstack-limit-symbol=sym -fargument-alias  -fargument-noalias
           -fargument-noalias-global  -fleading-underscore -ftls-model=model
           -ftrapv  -fbounds-check

       Options Controlling the Kind of Output

       Compilation can involve up to four stages: preprocessing, compilation
       proper, assembly and linking, always in that order.  The first three
       stages apply to an individual source file, and end by producing an
       object file; linking combines all the object files (those newly com-
       piled, 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 library
           libobjc.a to make an Objective-C program work.

           Objective-C source code which should not be preprocessed.

           C header file (not to be compiled or linked).

           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.

           Fortran source code which should not be preprocessed.

           Fortran source code which must be preprocessed (with the tradi-
           tional preprocessor).

           Fortran source code which must be preprocessed with a RATFOR pre-
           processor (not included with GCC).

           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  cpp-output
                   c++  c++-cpp-output
                   objective-c  objc-cpp-output
                   assembler  assembler-with-cpp
                   f77  f77-cpp-input  ratfor

       -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 numeri-
           cally highest error produced by any phase that returned an error

       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 combina-
       tions (for example, -x cpp-output -E) instruct gcc to do nothing at

       -c  Compile or assemble the source files, but do not link.  The link-
           ing 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 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.

           Since only one output file can be specified, it does not make
           sense to use -o when compiling more than one input file, unless
           you are producing an executable file as output.

           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, and all preprocessed C source on stan-
           dard output.

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

           Like -v except the commands are not executed and all command argu-
           ments 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.

           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 -W option is also specified then command line
           options which have no documentation associated with them will also
           be displayed.

           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,
       .c++, .cp, or .cxx; 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 com-
       piler that understands the C++ language---and under some circum-
       stances, you might want to compile programs from standard input, or
       otherwise without a suffix that flags them as C++ programs.  g++ is a
       program that calls GCC with the default language set to C++, and auto-
       matically 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 com-
       mand-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++ and Objective-C) that the compiler accepts:

           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 compil-
           ing C++ code), such as the "asm" and "typeof" keywords, and prede-
           fined 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 recog-
           nition 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 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 seman-
           tics 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 fea-

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

               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.

       -aux-info filename
           Output to the given filename prototyped declarations for all func-
           tions 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 declara-
           tion was implicit, prototyped or unprototyped (I, N for new or O
           for old, respectively, in the first character after the line num-
           ber 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 declaration.

           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

           Don't 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.

           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 func-
           tions 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

           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 (inter-
           nal 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 consis-
           tent: the basic integer types such as "int" are signed types.

           Store string constants in the writable data segment and don't
           uniquize them.  This is for compatibility with old programs which
           assume they can write into string constants.

           Writing into string constants is a very bad idea; ''constants''
           should be constant.

       Options Controlling C++ Dialect

       This section describes the command-line options that are only meaning-
       ful 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 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 1.

           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 sig-
           nalled 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

           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, unless you also use

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

           Accept $ in identifiers.  You can also explicitly prohibit use of
           $ with the option -fno-dollars-in-identifiers.  (GNU C allows $ by
           default on most target systems, but there are a few exceptions.)
           Traditional C allowed the character $ to form part of identifiers.
           However, ISO C and C++ forbid $ in identifiers.

           The C++ standard allows an implementation to omit creating a tem-
           porary 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.

           Don't check for violation of exception specifications at runtime.
           This option violates the C++ standard, but may be useful for
           reducing code size in production builds, much like defining NDE-
           BUG.  The compiler will still optimize based on the exception

           Cause #pragma interface and implementation to apply to template
           instantiation; template instances are emitted or not according to
           the location of the template definition.

           This option is deprecated.

           Similar to -fexternal-templates, but template instances are emit-
           ted or not according to the place where they are first instanti-

           This option is deprecated.

           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 other-
           wise 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 instantia-

           Don't emit code for implicit instantiations of inline templates,
           either.  The default is to handle inlines differently so that com-
           piles 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 don't 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 com-
           pilation.  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 end-
           less recursions during template class instantiation.  ANSI/ISO C++
           conforming programs must not rely on a maximum depth greater than

           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

           Emit special relocations for vtables and virtual function refer-
           ences so that the linker can identify unused virtual functions and
           zero out vtable slots that refer to them.  This is most useful
           with -ffunction-sections and -Wl,--gc-sections, in order to also
           discard the functions themselves.

           This optimization requires GNU as and GNU ld.  Not all systems
           support this option.  -Wl,--gc-sections is ignored without

           Do not use weak symbol support, even if it is provided by the
           linker.  By default, G++ will use weak symbols if they are avail-
           able.  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 spe-
           cific 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 func-
           tions; 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 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 prob-
               lem 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 exam-

                       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) {}