GCC

Section: GNU (1)
Updated: 03/09/2002
Index Retour au Menu Principal

 

NOM

gcc - compilateur C et C++ du projet GNU  

SYNOPSIS

gcc [-c|-S|-E] [-std=standard]
    [-g] [-pg] [-Oniveau]
    [-Wavertissement...] [-pedantic]
    [-Irép...] [-Lrép...]
    [-Dmacro[=déf]...] [-Umacro]
    [-foption...] [-moption-machine...]
    [-o fichier-sortie] fichier-entrée...

Seules les options les plus utiles sont listées ici ; voyez plus bas pour le reste. g++ accepte la plupart des options de gcc.  

DESCRIPTION

Quand vous invoquez GCC, il effectue normalement le prétraitement, la compilation, l'assemblage et l'édition des liens. Les « options globales » vous permettent d'arrêter ce processus à une étape intermédiaire. Par exemple, l'option -c indique de ne pas lancer l'éditeur de liens. La sortie est alors constituée des fichiers objets produits par l'assembleur.

D'autres options peuvent être passées à l'une des étapes du traitement. Certaines options contrôlent le préprocesseur et d'autres le compilateur lui-même. D'autres options encore contrôlent l'assembleur et l'éditeur de liens ; la plupart d'entre elles ne sont pas documentées ici, puisque vous ne devez que rarement les utiliser.

La plupart des options de ligne de commandes que vous pouvez utiliser avec GCC sont utiles pour les programmes C ; quand une option n'est utile que pour un autre langage (habituellement C++), l'explication le précise explicitement. Si la description d'une option particulière ne mentionne pas de langage source, vous pouvez utiliser cette option avec tous les langages supportés.

Le programme gcc accepte des options et des noms de fichiers comme opérandes. Beaucoup d'options ont un nom composé de plusieurs lettres ; de multiples options composées d'une seule lettre ne peuvent dès lors pas être regroupées : -dr est très différent de -d -r.

Vous pouvez mélanger les options avec d'autres arguments. Pour la plupart, l'ordre utilisé n'est pas important. L'ordre est significatif quand vous utilisez plusieurs options du même type ; par exemple, si vous spécifiez -L plus d'une fois, les répertoires seront parcourus dans l'ordre spécifié.

Beaucoup d'options possèdent des noms longs débutant par -f ou par -W -- par exemple, -fforce-mem, -fstrength-reduce, -Wformat etc. La plupart d'entre elles possèdent à la fois les formes positive et négative ; la forme négative de -ffoo serait -fno-foo. Ce manuel ne documente que l'une de ces deux formes, en l'occurrence celle qui n'est pas utilisée par défaut.  

OPTIONS

 

Résumé des options

Voici un résumé de toutes les options, groupées par type. Les explications suivent dans les prochaines sections.
Options globales
-c -S -E -o fichier -pipe -pass-exit-codes -x langage -v -### --target-help --help
Options du langage C
-ansi -std=standard -aux-info nom-fichier -fno-asm -fno-builtin -fno-builtin-fonction -fhosted -ffreestanding -trigraphs -no-integrated-cpp -traditional -traditional-cpp -fallow-single-precision -fcond-mismatch -fsigned-bitfields -fsigned-char -funsigned-bitfields -funsigned-char -fwritable-strings -fshort-wchar
Options du langage C++
-fno-access-control -fcheck-new -fconserve-space -fno-const-strings -fdollars-in-identifiers -fno-elide-constructors -fno-enforce-eh-specs -fexternal-templates -falt-external-templates -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 -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 -Woverloaded-virtual -Wno-pmf-conversions -Wsign-promo -Wsynth
Options du langage Objective-C
-fconstant-string-class=nom-classe -fgnu-runtime -fnext-runtime -gen-decls -Wno-protocol -Wselector
Options indépendantes du langage
-fmessage-length=n -fdiagnostics-show-location=[once|every-line]
Options d'avertissement
-fsyntax-only -pedantic -pedantic-errors -w -W -Wall -Waggregate-return -Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment -Wconversion -Wno-deprecated-declarations -Wdisabled-optimization -Wdiv-by-zero -Werror -Wfloat-equal -Wformat -Wformat=2 -Wformat-nonliteral -Wformat-security -Wimplicit -Wimplicit-int -Wimplicit-function-declaration -Werror-implicit-function-declaration -Wimport -Winline -Wlarger-than-longueur -Wlong-long -Wmain -Wmissing-braces -Wmissing-declarations -Wmissing-format-attribute -Wmissing-noreturn -Wmultichar -Wno-format-extra-args -Wno-format-y2k -Wno-import -Wpacked -Wpadded -Wparentheses -Wpointer-arith -Wredundant-decls -Wreturn-type -Wsequence-point -Wshadow -Wsign-compare -Wswitch -Wsystem-headers -Wtrigraphs -Wundef -Wuninitialized -Wunknown-pragmas -Wunreachable-code -Wunused -Wunused-function -Wunused-label -Wunused-parameter -Wunused-value -Wunused-variable -Wwrite-strings
Options d'avertissement spécifiques au C
-Wbad-function-cast -Wmissing-prototypes -Wnested-externs -Wstrict-prototypes -Wtraditional
Options de débogage
-dlettres -dumpspecs -dumpmachine -dumpversion -fdump-unnumbered -fdump-translation-unit[-n] -fdump-class-hierarchy[-n] -fdump-tree-original[-n] -fdump-tree-optimized[-n] -fdump-tree-inlined[-n] -fmem-report -fpretend-float -fprofile-arcs -ftest-coverage -ftime-report -g -gniveau -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2 -ggdb -gstabs -gstabs+ -gvms -gxcoff -gxcoff+ -p -pg -print-file-name=bibliothèque -print-libgcc-file-name -print-multi-directory -print-multi-lib -print-prog-name=programme -print-search-dirs -Q -save-temps -time
Options d'optimisation
-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 -finline-functions -finline-limit=n -fkeep-inline-functions -fkeep-static-consts -fmerge-constants -fmerge-all-constants -fmove-all-movables -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 -fno-trapping-math -fomit-frame-pointer -foptimize-register-move -foptimize-sibling-calls -fprefetch-loop-arrays -freduce-all-givs -fregmove -frename-registers -frerun-cse-after-loop -frerun-loop-opt -fschedule-insns -fschedule-insns2 -fsingle-precision-constant -fssa -fssa-ccp -fssa-dce -fstrength-reduce -fstrict-aliasing -fthread-jumps -ftrapv -funroll-all-loops -funroll-loops --param nom=valeur -O -O0 -O1 -O2 -O3 -Os
Options du préprocesseur
-$ -Aquestion=réponse -A-question[=réponse] -C -dD -dI -dM -dN -Dmacro[=déf] -E -H -idirafter rép -include fichier -imacros fichier -iprefix fichier -iwithprefix rép -iwithprefixbefore rép -isystem rép -M -MM -MF -MG -MP -MQ -MT -nostdinc -P -remap -trigraphs -undef -Umacro -Wp,option
Option de l'assembleur
-Wa,option
Options de l'éditeur de liens
nom-fichier-objet -lbibliothèque -nostartfiles -nodefaultlibs -nostdlib -s -static -static-libgcc -shared -shared-libgcc -symbolic -Wl,option -Xlinker option -u symbole
Options de répertoires
-Bpréfixe -Irép -I- -Lrép -specs=fichier
Options de cible
-b machine -V version
Options dépendantes de la machine
Options M680x0

-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

Options IM68hc1x

-m6811 -m6812 -m68hc11 -m68hc12 -mauto-incdec -mshort -msoft-reg-count=nombre

Options VAX

-mg -mgnu -munix

Options SPARC

-mcpu=type-cpu -mtune=type-cpu -mcmodel=modèle-code -m32 -m64 -mapp-regs -mbroken-saverestore -mcypress -mfaster-structs -mflat -mfpu -mhard-float -mhard-quad-float -mimpure-text -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

Options Convex

-mc1 -mc2 -mc32 -mc34 -mc38 -margcount -mnoargcount -mlong32 -mlong64 -mvolatile-cache -mvolatile-nocache

Options AMD29K

-m29000 -m29050 -mbw -mnbw -mdw -mndw -mlarge -mnormal -msmall -mkernel-registers -mno-reuse-arg-regs -mno-stack-check -mno-storem-bug -mreuse-arg-regs -msoft-float -mstack-check -mstorem-bug -muser-registers

Options ARM

-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=nom -march=nom -mfpe=nom -mstructure-size-boundary=n -mbsd -mxopen -mno-symrename -mabort-on-noreturn -mlong-calls -mno-long-calls -msingle-pic-base -mno-single-pic-base -mpic-register=reg -mnop-fun-dllimport -mpoke-function-name -mthumb -marm -mtpcs-frame -mtpcs-leaf-frame -mcaller-super-interworking -mcallee-super-interworking

Options MN10200

-mrelax

Options MN10300

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

Options M32R/D

-m32rx -m32r -mcode-model=type-modèle -msdata=type-sdata -G nombre

Options M88K

-m88000 -m88100 -m88110 -mbig-pic -mcheck-zero-division -mhandle-large-shift -midentify-revision -mno-check-zero-division -mno-ocs-debug-info -mno-ocs-frame-position -mno-optimize-arg-area -mno-serialize-volatile -mno-underscores -mocs-debug-info -mocs-frame-position -moptimize-arg-area -mserialize-volatile -mshort-data-nombre -msvr3 -msvr4 -mtrap-large-shift -muse-div-instruction -mversion-03.00 -mwarn-passed-structs

Options RS/6000 et PowerPC

-mcpu=type-cpu -mtune=type-cpu -mpower -mno-power -mpower2 -mno-power2 -mpowerpc -mpowerpc64 -mno-powerpc -maltivec -mno-altivec -mpowerpc-gpopt -mno-powerpc-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-relocatable-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 -mprototype -mno-prototype -msim -mmvme -mads -myellowknife -memb -msdata -msdata=opt -mvxworks -G nombre -pthread

Options RT

-mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs -mfull-fp-blocks -mhc-struct-return -min-line-mul -mminimum-fp-blocks -mnohc-struct-return

Options MIPS

-mabicalls -march=type-cpu -mtune=type-cpu -mcpu=type-cpu -membedded-data -muninit-const-in-rodata -membedded-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 nombre -nocpp -mabi=32 -mabi=n32 -mabi=64 -mabi=eabi -mfix7000 -mno-crt0 -mflush-func=fonc -mno-flush-func

Options i386 et x86-64

-mcpu=type-cpu -march=type-cpu -mfpmath=unité -masm=dialecte -mno-fancy-math-387 -mno-fp-ret-in-387 -msoft-float -msvr3-shlib -mno-wide-multiply -mrtd -malign-double -mpreferred-stack-boundary=nombre -mmmx -msse -msse2 -msse-math -m3dnow -mthreads -mno-align-stringops -minline-all-stringops -mpush-args -maccumulate-outgoing-args -m128bit-long-double -m96bit-long-double -mregparm=nombre -momit-leaf-frame-pointer -mno-red-zone -mcmodel=modèle-code -m32 -m64

Options HPPA

-march=type-architecture -mbig-switch -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls -mgas -mjump-in-delay -mlong-load-store -mno-big-switch -mno-disable-fpregs -mno-disable-indexing -mno-fast-indirect-calls -mno-gas -mno-jump-in-delay -mno-long-load-store -mno-portable-runtime -mno-soft-float -mno-space-regs -msoft-float -mpa-risc-1-0 -mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime -mschedule=type-cpu -mspace-regs

Options Intel 960

-mtype-cpu -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

Options DEC Alpha

-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=type-cpu -mtune=type-cpu -mbwx -mmax -mfix -mcix -mfloat-vax -mfloat-ieee -mexplicit-relocs -msmall-data -mlarge-data -mmemory-latency=temps

Options DEC Alpha/VMS

-mvms-return-codes

Options Clipper

-mc300 -mc400

Options H8/300

-mrelax -mh -ms -mint32 -malign-300

Options SH

-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

Options System V

-Qy -Qn -YP,chemins -Ym,rép

Options ARC

-EB -EL -mmangle-cpu -mcpu=cpu -mtext=section-texte -mdata=section-données -mrodata=section-données-lecture-seule

Options TMS320C3x/C4x

-mcpu=cpu -mbig -msmall -mregparm -mmemparm -mfast-fix -mmpyi -mbk -mti -mdp-isr-reload -mrpts=nombre -mrptb -mdb -mloop-unsigned -mparallel-insns -mparallel-mpy -mpreserve-float

Options V850

-mlong-calls -mno-long-calls -mep -mno-ep -mprolog-function -mno-prolog-function -mspace -mtda=n -msda=n -mzda=n -mv850 -mbig-switch

Options NS32K

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

Options AVR

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

Options MCore

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

Options MMIX

-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

Options IA-64

-mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic -mvolatile-asm-stop -mb-step -mregister-names -mno-sdata -mconstant-gp -mauto-pic -minline-divide-min-latency -minline-divide-max-throughput -mno-dwarf2-asm -mfixed-range=intervalle-registres

Options ID30V

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

Options IS/390 et zSeries

-mhard-float -msoft-float -mbackchain -mno-backchain -msmall-exec -mno-small-exec -mmvcle -mno-mvcle -m64 -m31 -mdebug -mno-debug

Options CRIS

-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

Options PDP-11

-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

Options Xstormy16

-msim

Options Xtensa

-mbig-endian -mlittle-endian -mdensity -mno-density -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

Options de génération de code
-fcall-saved-reg -fcall-used-reg -ffixed-registre -fexceptions -fnon-call-exceptions -funwind-tables -fasynchronous-unwind-tables -finhibit-size-directive -finstrument-functions -fno-common -fno-ident -fno-gnu-linker -fpcc-struct-return -fpic -fPIC -freg-struct-return -fshared-data -fshort-enums -fshort-double -fvolatile -fvolatile-global -fvolatile-static -fverbose-asm -fpack-struct -fstack-check -fstack-limit-register=reg -fstack-limit-symbol=sym -fargument-alias -fargument-noalias -fargument-noalias-global -fleading-underscore -ftls-model=modèle
 

Options contrôlant le type de sortie

La compilation peut impliquer jusqu'à quatre étapes : prétraitement, compilation proprement dite, assemblage et édition des liens, toujours dans cet ordre. Les trois premières étapes s'appliquent à un fichier source individuel, et se terminent en produisant un fichier objet ; l'édition des liens combine tous les fichiers objets (ceux nouvellement compilés, et ceux spécifiés en entrée) en un fichier exécutable.

Pour tout fichier d'entrée, le suffixe du nom de fichier détermine le type de compilation qui est effectuée :

fichier.c
Code source C qui doit être prétraité.
fichier.i
Code source C qui ne devrait pas être prétraité.
fichier.ii
Code source C++ qui ne devrait pas être prétraité.
fichier.m
Code source Objective-C. Notez que vous devez lier un programme Objective-C avec la bibliothèque libobjc.a pour le faire fonctionner.
fichier.mi
Code source Objective-C qui ne devrait pas être prétraité.
fichier.h
Fichier d'en-tête C (ne doit être ni compilé, ni lié).
fichier.cc
fichier.cp
fichier.cxx
fichier.cpp
fichier.c++
fichier.C
Code source C++ qui ne devrait pas être prétraité. Notez que pour .cxx, les deux dernières lettres doivent être littéralement x. De la même façon, .C se réfère à un C littéral en majuscule.
fichier.f
fichier.for
fichier.FOR
Code source Fortran qui ne devrait pas être prétraité.
fichier.F
fichier.fpp
fichier.FPP
Code source Fortran qui doit être prétraité (avec le préprocesseur traditionnel).
fichier.r
Code source Fortran qui doit être prétraité avec un préprocesseur RATFOR (non inclus avec GCC).
fichier.ads
Fichier de code source Ada qui contient une déclaration d'unité de bibliothèque (la déclaration d'un paquet, d'un sous-programme, ou d'un générique, ou d'une instanciation générique), ou une déclaration de renommage d'unité de bibliothèque (un paquet, un générique, ou une déclaration de renommage d'un sous-programme). De tels fichiers sont également appelés specs.
fichier.adb
Fichier de code source Ada qui contient le corps d'une unité de bibliothèque (le corps d'un sous-programme ou d'un paquetage). De tels fichiers sont également appelés corps (bodies).
fichier.s
Code assembleur.
fichier.S
Code assembleur qui doit être prétraité.
autre
Un fichier objet à envoyer directement à l'éditeur de liens. Tout nom de fichier de suffixe non reconnu est traité de cette manière.

Vous pouvez spécifier explicitement le langage d'entrée avec l'option -x :

-x langage
Spécifier explicitement le langage pour les fichiers d'entrée suivants (plutôt que de laisser choisir par le compilateur un langage par défaut basé sur le suffixe du nom de fichier). Cette option s'applique à tous les fichiers d'entrée subséquents jusqu'à l'option -x suivante. Les valeurs possibles pour langage sont : 

        c  c-header  cpp-output 
        c++  c++-cpp-output
        objective-c  objc-cpp-output
        assembler  assembler-with-cpp
        ada
        f77  f77-cpp-input  ratfor
        java
-x none
Désactiver toute spécification de langage, afin que les fichiers ultérieurs soient traités en fonction de leur suffixe de nom de fichier (comme si -x n'avait jamais été utilisé).
-pass-exit-codes
Normalement, le programme gcc se terminera avec un code de retour de 1 si une phase de compilation quelconque renvoie un code de retour d'erreur. Si vous spécifiez -pass-exit-codes, le programme gcc renverra à la place le code d'erreur numériquement le plus grand produit par une phase se terminant sur une indication d'erreur.

Si vous ne désirez que certaines étapes de la compilation, vous pouvez utiliser -x (ou des suffixes de noms de fichiers) pour indiquer à gcc où il doit démarrer, et une des options -c, -S ou -E pour lui dire où il doit s'arrêter. Notez que certaines combinaisons (par exemple -x cpp-output -E) disent à gcc de ne rien faire du tout.

-c
Compiler ou assembler les fichiers sources, mais ne pas éditer les liens. L'étape d'édition des liens n'est tout simplement pas effectuée. La sortie finale du compilateur correspond à un fichier objet pour chaque fichier source.

Par défaut, le nom du fichier objet pour un fichier source donné est formé en remplaçant les suffixes .c, .i, .s, etc., par .o.

Les fichiers d'entrée non reconnus, ne requérant ni compilation ni assemblage, sont ignorés.

-S
S'arrêter après l'étape de la compilation proprement dite ; ne pas assembler. La sortie est un fichier de code assembleur pour chaque fichier d'entrée non assembleur spécifié.

Par défaut, GCC crée le nom du fichier assembleur à partir du fichier source en remplaçant les suffixes .c, .i, etc., par .s.

Les fichiers d'entrée ne requérant pas de compilation sont ignorés.

-E
S'arrêter après l'étape du prétraitement ; ne pas véritablement lancer le compilateur. La sortie est un code source prétraité, qui est envoyé vers la sortie standard.

Les fichiers d'entrée ne requérant pas de compilation sont ignorés.

-o fichier
Placer la sortie dans fichier. Cela s'applique quel que soit le type de sortie produite, que ce soit un fichier exécutable, un fichier objet, un fichier assembleur ou du code C prétraité.

Puisqu'un seul fichier de sortie peut être spécifié, cela n'a aucun sens d'utiliser -o quand on compile plus d'un fichier d'entrée, à moins que l'on ne veuille produire un fichier exécutable en sortie.

Si -o n'est pas spécifié, le comportement par défaut est de produire un fichier exécutable nommé a.out, un fichier objet pour source.suffixe nommé source.o, son fichier assembleur dans source.s, et tout le code source C prétraité sur la sortie standard.

-v
Afficher (sur la sortie d'erreur standard) les commandes exécutées pour lancer les étapes de la compilation. Afficher également le numéro de version du programme pilote du compilateur, du préprocesseur et du compilateur proprement dit.
-###
Comme -v sauf que les commandes ne sont pas exécutées et que tous les arguments de commande sont protégés. C'est utile pour que les scripts shell puissent capturer les lignes de commandes générées par le pilote.
-pipe
Utiliser des tubes plutôt que des fichiers temporaires pour la communication entre les différentes phases de la compilation. Ceci ne marche pas sur certains systèmes où l'assembleur ne peut lire à partir d'un tube, mais cela ne pose aucun problème dans le cas de l'assembleur GNU.
--help
Afficher (sur la sortie standard) une description des options de ligne de commandes comprises par gcc. Si l'option -v est également spécifiée, alors --help sera également passé aux différents processus invoqués par gcc, afin qu'ils puissent afficher les options de ligne de commandes qu'ils acceptent. Si l'option -W est également spécifiée, alors les options de ligne de commandes qui ne possèdent pas de documentation associée seront également affichées.
--target-help
Afficher (sur la sortie standard) une description des options de ligne de commandes spécifiques à une cible pour chaque outil.
 

Compiler des programmes C++

Les fichiers sources C++ utilisent par convention l'un des suffixes .C, .cc, .cpp, .c++, .cp ou .cxx ; les fichiers C++ prétraités utilisent le suffixe .ii. GCC reconnaît les fichiers portant ces noms et les compile en tant que programmes C++ même si vous appelez le compilateur de la même manière que pour compiler des programmes C (d'habitude avec le nom gcc).

Néanmoins, les programmes C++ requièrent souvent des bibliothèques de classes de même qu'un compilateur comprenant le langage C++ (et dans certaines circonstances, vous pourriez compiler des programmes à partir de l'entrée standard, ou bien sans un suffixe qui les désigne comme étant des programmes C++). g++ est un programme qui appelle GCC avec le langage par défaut fixé à C++, et il spécifie automatiquement une édition des liens utilisant la bibliothèque C++. Sur de nombreux systèmes, g++ est également installé sous le nom c++.

Quand vous compilez des programmes C++, vous pouvez spécifier la plupart des options de ligne de commandes que vous utiliseriez pour compiler des programmes dans n'importe quel langage, ou bien des options de ligne de commandes possédant une signification pour le C et les langages associés, ou encore des options qui ne sont significatives que pour les programmes C++.  

Options contrôlant le dialecte C

Les options suivantes contrôlent le dialecte de C (ou des langages dérivés de C, comme C++ et Objective-C) que le compilateur accepte :
-ansi
Dans le mode C, supporter tous les programmes ISO C89. Dans le mode C++, supprimer les extensions GNU en conflit avec le C++ ISO.

Cela désactive certaines fonctionnalités de GCC qui sont incompatibles avec le C89 ISO (pendant la compilation de code C), ou du C++ standard (pendant la compilation de code C++), comme les mots-clés « asm » et « typeof », et les macros prédéfinies comme « unix » et « vax » qui identifient le type de système que vous utilisez. Cela active également la fonctionnalité rarement utilisée et non souhaitable des trigraphes ISO. Pour le compilateur C, cette option désactive la reconnaissance des commentaires // de style C++, ainsi que le mot-clé « inline ».

Les mots-clés alternatifs « __asm__ », « __extension__ », « __inline__ » et « __typeof__ » continuent à fonctionner malgré -ansi. Vous ne les utilisez naturellement pas dans un programme C ISO, mais il est utile de les trouver dans des fichiers d'en-tête pouvant être inclus lors de compilations effectuées avec -ansi. Des macros prédéfinies alternatives comme « __unix__ » et « __vax__ » sont aussi disponibles, avec ou sans -ansi.

L'option -ansi ne provoque pas le rejet arbitraire des programmes non ISO. Pour cela, -pedantic est requis en plus de -ansi.

La macro « __STRICT_ANSI__ » est prédéfinie quand l'option -ansi est utilisée. Certains fichiers d'en-tête peuvent remarquer cette macro, et s'empêcher de déclarer certaines fonctions ou de définir certaines macros que ne demande pas le standard ISO, afin d'éviter d'interférer avec un programme quelconque qui utiliserait ces noms pour d'autres choses.

Les fonctions qui devraient normalement être intégrées mais qui ne possèdent pas la sémantique définie par le C ISO (comme « alloca » et « ffs ») ne sont pas des fonctions intégrées quand -ansi est utilisé.

-std=
Déterminer le standard du langage. Cette option n'est actuellement supportée que lors de la compilation de C. Il faut fournir une valeur pour cette option ; les valeurs possibles sont
c89
iso9899:1990
C89 ISO (même chose que -ansi).
iso9899:199409
C89 ISO comme modifié par l'amendement 1.
c99
c9x
iso9899:1999
iso9899:199x
C99 ISO. Notez que ce standard n'est pas encore entièrement supporté ; voyez <http://gcc.gnu.org/gcc-3.1/c99status.html> pour plus d'informations. Les noms c9x et iso9899:199x sont dépréciés.
gnu89
Par défaut, C89 ISO + extensions GNU (incluant certaines fonctionnalités du C99).
gnu99
gnu9x
C99 ISO + extensions GNU. Quand le C99 ISO sera complètement implémenté dans GCC, il deviendra le standard par défaut. Le nom gnu9x est déprécié.

Même si cette option n'est pas spécifiée, vous pouvez toujours utiliser certaines fonctionnalités de standards plus récents, pour autant qu'elles n'entrent pas en conflit avec les standards C précédents. Par exemple, vous pouvez utiliser « __restrict__ » même si -std=c99 n'est pas spécifié.

Les options -std spécifiant une version du C ISO ont les mêmes effets que -ansi, sauf que les fonctionnalités ne faisant pas partie du C89 ISO, mais qui appartiennent à la version spécifiée (par exemple, les commentaires // et le mot-clé « inline » du C99 ISO) ne sont pas désactivées.

-aux-info nom-fichier
Sortir dans le nom de fichier donné les déclarations prototypées pour toutes les fonctions déclarées et/ou définies dans une unité de traduction, ce qui inclut celles présentes dans les fichiers d'en-tête. Cette option est silencieusement ignorée pour tout langage autre que C.

En plus des déclarations, le fichier indique, en commentaire, l'origine de chaque déclaration (fichier source et numéro de ligne), si la déclaration était implicite, prototypée ou non (I, N pour new (nouveau) ou O pour old (ancien), respectivement, dans le premier caractère suivant le numéro de ligne et le signe deux-points), et si elle provenait d'une déclaration ou d'une définition (C ou F, respectivement, dans le caractère suivant). Dans le cas des définitions de fonctions, une liste d'arguments du style K&R suivis de leur déclaration est également fournie, à l'intérieur des commentaires, après la déclaration.

-fno-asm
Ne pas reconnaître « asm », « inline » ou « typeof » comme des mots-clés, afin que le code puisse utiliser ces mots comme identificateurs. Vous pouvez utiliser les mots-clés « __asm__ », « __inline__ » et « __typeof__ » à la place. -ansi implique -fno-asm.

En C++, cet interrupteur n'affecte que le mot-clé « typeof », puisque « asm » et « inline » sont des mots-clés standard. Vous pourriez utiliser l'indicateur -fno-gnu-keywords à la place, qui a le même effet. Dans le mode C99 (-std=c99 ou -std=gnu99), cet interrupteur n'affecte que les mots-clés « asm » et « typeof », puisque « inline » est un mot-clé standard du C99 ISO.

-fno-builtin
-fno-builtin-fonction (C et Objective-C uniquement)
Ne pas reconnaître les fonctions intégrées qui ne commencent pas par le préfixe __builtin_.

GCC génère normalement du code spécial pour manipuler certaines fonctions intégrées plus efficacement ; par exemple, les appels à « alloca » peuvent devenir des instructions uniques qui ajustent la pile directement, et les appels à « memcpy » peuvent devenir des boucles de copie en ligne. Le code résultant est souvent plus concis et rapide mais, puisque les appels de fonction n'apparaissent plus en tant que tels, vous ne pouvez pas placer de point d'arrêt sur ces appels, ni ne pouvez modifier le comportement des fonctions en les liant à une bibliothèque différente.

En C++, -fno-builtin est toujours utilisé. L'option -fbuiltin n'a aucun effet. Donc, en C++, la seule façon d'obtenir les bénéfices d'optimisation des fonctions intégrées est d'appeler la fonction en utilisant le préfixe __builtin_. La Bibliothèque Standard GNU C++ utilise des fonctions intégrées pour implémenter de nombreuses fonctions (comme « std::strchr »), pour que vous obteniez automatiquement un code efficace.

Avec l'option -fno-builtin-fonction, non disponible lors de la compilation de C++, seule la fonction intégrée fonction est désactivée. fonction ne doit pas commencer par __builtin_. Si une fonction désignée n'est pas intégrée dans cette version de GCC, cette option est ignorée. Il n'y a pas d'option -fbuiltin-function correspondante ; si vous voulez activer des fonctions intégrées de façon sélective quand vous utilisez -fno-builtin ou -ffreestanding, vous pouvez définir des macros comme : 

        #define abs(n)          __builtin_abs ((n))
        #define strcpy(d, s)    __builtin_strcpy ((d), (s))
-fhosted
Supposer que la compilation a lieu dans un environnement hôte. Cela implique -fbuiltin. Un environnement hôte est un environnement dans lequel la bibliothèque standard entière est disponible, et dans lequel « main » a un type de retour « int ». Les exemples se rencontrent pratiquement partout sauf dans un noyau. C'est équivalent à -fno-freestanding.
-ffreestanding
Supposer que la compilation a lieu dans un environnement autonome. Cela implique -fno-builtin. Un environnement autonome est un environnement dans lequel la bibliothèque standard peut ne pas exister, et où le démarrage du programme n'est pas nécessairement placé dans « main ». L'exemple le plus évident est un noyau de système d'exploitation. C'est équivalent à -fno-hosted.
-trigraphs
Supporter les trigraphes C ISO C. L'option -ansi (et les options -std pour une conformité stricte au C ISO) implique -trigraphs.
-no-integrated-cpp
Invoquer le cpp externe durant la compilation. Le comportement par défaut est d'utiliser le cpp intégré (cpp interne). Cette option permet également l'utilisation d'un cpp fourni par l'utilisateur via l'option -B. Cet indicateur est applicable dans les modes C et C++.

Nous ne garantissons pas le maintien de cette option dans le futur, et nous pourrions modifier sa sémantique.

-traditional
Essayer de supporter certains aspects des compilateurs C traditionnels. Spécifiquement :
*
Toutes les déclarations « extern » prennent effet globalement même si elles sont écrites à l'intérieur d'une définition de fonction. Cela inclut les déclarations implicites de fonctions.
*
Les mots-clés plus récents « typeof », « inline », « signed », « const » et « volatile » ne sont pas reconnus. (Vous pouvez toujours utiliser les mots-clés alternatifs comme « __typeof__ », « __inline__ », etc.)
*
Les comparaisons entre pointeurs et entiers sont toujours autorisées.
*
Les types entiers « unsigned short » et « unsigned char » sont promus en « unsigned int ».
*
Les littéraux à virgule flottante (flottants) hors intervalle ne constituent pas une erreur.
*
Certaines constructions que ISO considère comme un unique numéro de prétraitement invalide, comme 0xe-0xd, sont traités à la manière des expressions.
*
Les « constantes » de type chaîne de caractères ne sont pas nécessairement constantes ; elles sont stockées dans un espace accessible en écriture, et les emplacements des constantes visiblement identiques sont alloués séparément. (Cela a le même effet que -fwritable-strings.)
*
Toutes les variables automatiques non déclarées « register » sont préservées lors d'un appel à « longjmp ». Habituellement, le C GNU suit le C ISO : les variables automatiques non déclarées « volatile » peuvent être corrompues.
*
Les séquences d'échappement de caractère \x et \a s'évaluent comme les caractères littéraux x et a respectivement. Sans -traditional, \x est un préfixe de la représentation hexadécimale d'un caractère, et \a produit une sonnerie.

Cette option est dépréciée et pourrait être supprimée.

Vous pourriez utiliser -fno-builtin aussi bien que -traditional si votre programme utilise des noms qui sont normalement ceux des fonctions intégrées du C GNU à d'autres fins.

Vous ne pouvez pas utiliser -traditional si vous incluez des fichiers d'en-tête qui se basent sur des fonctionnalités du C ISO. Certains vendeurs commencent à délivrer des systèmes avec des fichiers d'en-tête C ISO, et vous ne pouvez pas utiliser -traditional sur de tels systèmes pour compiler des fichiers qui incluent des fichiers d'en-tête système.

L'option -traditional active également -traditional-cpp.

-traditional-cpp
Essayer de supporter certains aspects des préprocesseurs C traditionnels. Voyez le manuel de GNU CPP pour les détails.
-fcond-mismatch
Autoriser des expressions conditionnelles avec des types non concordants dans les deuxième et troisième arguments. La valeur d'une telle expression est void. Cette option n'est pas supportée pour le C++.
-funsigned-char
Permettre au type « char » d'être non signé, comme « unsigned char ».

Chaque type de machine a son propre avis concernant ce que doit représenter le type « char ». C'est soit « unsigned char » par défaut, soit « signed char » par défaut.

Idéalement, un programme portable devrait toujours utiliser « signed char » ou « unsigned char » quand il dépend du signe d'un objet. Mais beaucoup de programmes ont été écrits pour utiliser des « char » simples et s'attendent à ce qu'ils soient signés, ou à ce qu'il soient non signés, en fonction des machines pour lesquelles le programme a été écrit. Cette option, et son inverse, vous permettent de créer un programme qui fonctionne avec le comportement opposé par défaut.

Le type « char » est toujours un type distinct de « signed char » et « unsigned char », même si son comportement est toujours celui d'un de ces deux là.

-fsigned-char
Permettre au type « char » d'être signé, comme « signed char ».

Notez que c'est équivalent à -fno-unsigned-char, qui est la forme négative de -funsigned-char. De même, l'option -fno-signed-char est équivalente à -funsigned-char.

-fsigned-bitfields
-funsigned-bitfields
-fno-signed-bitfields
-fno-unsigned-bitfields
Ces options contrôlent si un champ-bit est signé ou non signé, quand la déclaration n'utilise ni « signed » ni « unsigned ». Par défaut, un tel champ-bit d'un bit est signé, parce que c'est logique : les types entiers de bases tels que « int » sont des types signés.

Néanmoins, lorsque -traditional est utilisé, les champs-bits sont tous considérés comme étant non signés.

-fwritable-strings
Conserve les constantes de type chaîne de caractères dans le segment de données accessible en écriture et ne les rend pas uniques, dans un but de compatibilité avec d'anciens programmes qui supposent qu'ils peuvent écrire dans des constantes de type chaîne de caractères. L'option -traditional a également cet effet.

Écrire dans des constantes de type chaîne de caractères est une très mauvaise idée ; les « constantes » devraient réellement l'être.

-fallow-single-precision
Ne pas promouvoir des opérations mathématiques simple précision en double précision, même lors d'une compilation avec -traditional.

Le C traditionnel K&R C promeut toutes les opérations flottantes en double précision, quelle que soit la taille des opérandes. Sur l'architecture pour laquelle vous compilez, la simple précision peut être plus rapide que la double précision. Si vous devez utiliser -traditional, mais que vous voulez utiliser des opérations en simple précision quand les opérandes sont en simple précision, utilisez cette option. Cette option n'a aucun effet lors d'une compilation utilisant les conventions C ISO ou GNU (comportement par défaut).

-fshort-wchar
Surcharger le type sous-jacent de wchar_t pour qu'il soit short unsigned int au lieu du comportement par défaut pour la cible. Cette option est utile pour la construction de programmes devant tourner sous WINE.
 

Options contrôlant le dialecte C++

Cette section décrit les options de ligne de commandes qui ne sont significatives que pour les programmes C++, mais vous pouvez également utiliser la plupart des options du compilateur GNU quel que soit le langage dans lequel votre programme est écrit. Par exemple, vous pouvez compiler un fichier « premièreClasse.C » comme ceci : 

        g++ -g -frepo -O -c premièreClasse.C

Dans cet exemple, seule -frepo est une option destinée exclusivement aux programmes C++ ; vous pouvez utiliser les autres options avec n'importe quel langage supporté par GCC.

Voici une liste des options qui sont disponibles uniquement lors de la compilation de programmes C++ :

-fno-access-control
Désactiver tout contrôle d'accès. Cet interrupteur est principalement utile pour contourner des bogues dans le code de contrôle d'accès.
-fcheck-new
Vérifier que le pointeur renvoyé par « operator new » est non-null avant de tenter de modifier la mémoire allouée. Le document de travail actuel requiert que « operator new » ne renvoie jamais un pointeur null, de sorte que cette vérification n'est normalement pas nécessaire.

Une alternative à l'utilisation de cette option est de spécifier que votre « operator new » ne lance aucune exception ; si vous le déclarez throw(), G++ vérifiera la valeur de retour. Voyez également new (nothrow).

-fconserve-space
Placer les variables globales non initialisées ou initialisées à l'exécution dans le segment commun, comme en C. Cela économise de l'espace dans l'exécutable au prix d'un non diagnostic des définitions dupliquées. Si vous compilez avec ce drapeau et que votre programme se plante mystérieusement après que « main() » se soit terminé, il se peut qu'un objet est détruit deux fois du fait de la fusion de deux définitions.

Cette option n'est plus utile sur la plupart des cibles, maintenant que le support a été ajouté pour placer des variables dans le BSS sans les rendre communes.

-fno-const-strings
Donner aux chaînes de caractères constantes le type « char * » au lieu du type « const char * ». Par défaut, G++ utilise le type « const char * » comme requis par le standard. Même si vous utilisez -fno-const-strings, vous ne pouvez pas réellement modifier la valeur d'une chaîne de caractères constantes, à moins que vous n'utilisiez également -fwritable-strings.

Cette option pourrait être supprimée dans une prochaine version de G++. Pour une portabilité maximale, vous devriez structurer votre code de sorte qu'il fonctionne avec des chaînes de caractères constantes qui ont le type « const char * ».

-fdollars-in-identifiers
Accepter les $ dans les identificateurs. Vous pouvez également interdire explicitement l'utilisation du $ avec l'option -fno-dollars-in-identifiers. (GNU C autorise les $ par défaut sur la plupart des systèmes cibles, mais il y a quelques exceptions.) Le C traditionnel permettait au caractère $ de faire partie des identificateurs. Néanmoins, le C et le C++ ISO interdisent le $ dans les identificateurs.
-fno-elide-constructors
Le standard C++ permet à une implémentation d'omettre de créer un objet temporaire qui n'est utilisé que pour initialiser un autre objet du même type. Spécifier cette option désactive cette optimisation, et force G++ à toujours appeler le constructeur de copie.
-fno-enforce-eh-specs
Ne pas rechercher de violation des spécifications d'exceptions au moment de l'exécution. Cette option viole le standard C++, mais peut être utile pour réduire la taille du code dans du code de production, un peu comme quand on définit NDEBUG. Le compilateur optimisera toujours en fonction des spécifications d'exceptions.
-fexternal-templates
Forcer les #pragma interface et implementation à s'appliquer aux instanciations de modèles ; les instances de modèle sont émises ou pas en fonction de l'emplacement de la définition de modèle.

Cette option est dépréciée.

-falt-external-templates
Similaire à -fexternal-templates, mais les instances de modèle sont émises ou pas en fonction de l'emplacement où elles sont instanciées pour la première fois.

Cette option est dépréciée.

-ffor-scope
-fno-for-scope
Si -ffor-scope est spécifié, la portée des variables déclarées dans une instruction-for-init est limitée à la boucle for elle-même, comme spécifié par le standard C++ standard. Si -fno-for-scope est spécifié, la portée des variables déclarées dans une instruction-for-init s'étend jusqu'à la fin de la portée entourante, comme c'était le cas dans d'anciennes versions de G++, et dans d'autres implémentations (traditionnelles) de C++.

Le comportement par défaut si aucune option n'est fournie est de suivre le standard, mais également d'autoriser (et d'émettre un avertissement pour) un code écrit dans l'ancien style qui serait autrement invalide, ou qui aurait un comportement différent.

-fno-gnu-keywords
Ne pas reconnaître « typeof » comme un mot-clé, afin que le code puisse utiliser ce mot comme identificateur. Vous pouvez utiliser le mot-clé « __typeof__ » à la place. -ansi implique -fno-gnu-keywords.
-fno-implicit-templates
Ne jamais émettre de code pour des modèles non en ligne (inline) qui sont instanciés implicitement (c.-à-d. par leur usage) ; n'émettre de code que pour les instanciations explicites.
-fno-implicit-inline-templates
Ne pas émettre de code pour des instanciations implicites de modèles en ligne. Le comportement par défaut est de traiter les inlines différemment de sorte que des compilations avec ou sans optimisation auront besoin du même ensemble d'instanciations implicites.
-fno-implement-inlines
Pour économiser de l'espace, ne pas émettre de copies hors ligne de fonctions inline contrôlées par #pragma implementation. Cela provoquera des erreurs lors de l'édition de liens si ces fonctions ne sont pas mises en ligne partout où elles sont appelées.
-fms-extensions
Désactiver les avertissements pédants sur les constructions utilisées dans les MFC (NdT : Microsoft Foundation Classes ?), comme le int implicite ou l'obtention d'un pointeur vers une fonction membre via une syntaxe non standard.
-fno-nonansi-builtins
Désactiver les déclarations intégrées de fonctions qui ne sont pas prévues par le C ANSI/ISO. Celles-ci incluent « ffs », « alloca », « _exit », « index », « bzero », « conjf », et d'autres fonctions associées.
-fno-operator-names
Ne pas traiter les mots-clés nom d'opérateur « and », « bitand », « bitor », « compl », « not », « or » et « xor » comme des synonymes pour les mots-clés.
-fno-optional-diags
Désactiver les messages de diagnostic pour lesquels le standard ne prévoit pas d'obligation d'émission de la part du compilateur. Actuellement, le seul diagnostic de ce type émis par G++ est celui d'un nom possédant de multiples significations à l'intérieur d'une classe.
-fpermissive
Rabaisser les messages sur du code non conforme d'erreurs en avertissements. Par défaut, G++ utilise effectivement -pedantic-errors sans -pedantic ; cette option renverse ce fait. Ce comportement et cette option sont surchargés par -pedantic, qui fonctionne de la même manière que dans le C GNU.
-frepo
Activer l'instanciation automatique de modèles. Cette option implique également -fno-implicit-templates.
-fno-rtti
Désactiver la génération d'informations sur chaque classe comprenant des fonctions virtuelles pour utilisation par les fonctionnalités d'identification de type à l'exécution de C++ (dynamic_cast et typeid). Si vous n'utilisez pas ces parties du langage, vous pouvez économiser de l'espace en utilisant cette option. Notez que le mécanisme de traitement des exceptions utilise les mêmes informations, mais il les générera en cas de besoin.
-fstats
Émettre des statistiques sur le traitement des frontaux à la fin de la compilation. Cette information n'est généralement utile qu'à l'équipe de développement de G++.
-ftemplate-depth-n
Fixer la profondeur d'instanciation maximale des classes modèles à n. Une limite sur la profondeur d'instanciation des modèles est nécessaire pour détecter des récursions infinies lors de l'instanciation de classes modèles. Les programmes conformes au C++ ANSI/ISO ne doivent pas compter sur une taille maximale supérieure à 17.
-fuse-cxa-atexit
Enregistrer les destructeurs d'objets ayant une durée de stockage statique avec la fonction « __cxa_atexit » plutôt qu'avec la fonction « atexit ». Cette option est requise pour avoir un comportement totalement conforme aux standards des destructeurs statiques, mais ne fonctionnera que si votre bibliothèque C supporte « __cxa_atexit ».
-fvtable-gc
Émettre des relogements spéciaux pour les références à des vtables ou à des fonctions virtuelles afin que l'éditeur de liens puisse identifier les fonctions virtuelles inutilisées et zéro-ifier les entrées de vtable qui s'y réfèrent. C'est utile principalement avec -ffunction-sections et -Wl,--gc-sections, pour également éliminer les fonctions elles-mêmes.

Cette optimisation requiert GNU as et GNU ld. Tous les systèmes ne supportent pas cette option. -Wl,--gc-sections est ignoré sans -static.

-fno-weak
Ne pas utiliser le support des symboles faibles, même s'il est fourni par l'éditeur de liens. Par défaut, G++ utilisera les symboles faibles s'ils sont disponibles. Cette option n'existe qu'à des fins de tests, et ne devrait pas être utilisée par les utilisateurs finaux ; elle résulte en un code moins bon et n'offre aucun avantage. Cette option pourrait être supprimée dans une future version de G++.
-nostdinc++
Ne pas rechercher de fichiers d'en-tête dans les répertoires standard spécifiques à C++, mais toujours effectuer une recherche dans les autres répertoires standard. (Cette option est utilisée pour compiler la bibliothèque C++.)

De plus, les options suivantes d'optimisation, d'avertissement et de génération de code n'ont de sens que pour les programmes C++:

-fno-default-inline
Ne pas supposer que les fonctions définies à l'intérieur de la portée d'une classe sont inline. Notez que ces fonctions auront une édition des liens similaire à celle des fonctions en ligne ; elles ne seront simplement pas mises en ligne par défaut.
-Wabi (C++ uniquement)
Avertir quand G++ génère du code probablement non compatible avec l'ABI C++ neutre vis-à-vis du vendeur. Bien qu'un effort ait été consenti pour alerter l'utilisateur dans de tels cas, il en subsiste probablement quelques uns qui ne sont pas détectés, et ce même si G++ génère du code incompatible. Il peut également y avoir des situations où des avertissements sont émis même si le code généré sera compatible.

Vous devriez réécrire votre code de sorte à éviter ces avertissements si vous vous inquiétez du fait que le code généré par G++ puisse ne pas être compatible au niveau binaire avec du code généré par d'autres compilateurs.

Les incompatibilités connues à ce jour incluent :

*
Traitement incorrect du bourrage de queue (de fin) pour les champs-bits. G++ peut essayer de regrouper les données dans le même multiplet (byte) comme une classe de base. Par exemple : 

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

Dans ce cas, G++ placera « B::f2 » dans le même multiplet que « A::f1 » ; d'autres compilateurs ne le feront pas. Vous pouvez éviter ce problème en complétant explicitement « A » afin que sa taille soit un multiple de la taille d'un multiplet sur votre plate-forme ; cela conduira à ce que G++ et d'autres compilateurs conçoivent « B » de la même façon.

*
Traitement incorrect du bourrage de queue pour les bases virtuelles. G++ n'utilise pas le bourrage de queue lors de la conception des bases virtuelles. Par exemple : 

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

Dans ce cas, G++ ne placera pas « B » dans le bourrage de queue de « A » ; d'autres compilateurs le feront. Vous pouvez éviter ce problème en complétant explicitement « A » afin que sa taille soit un multiple de son alignement (en ignorant les classes de base virtuelles) ; cela conduira à ce que G++ et d'autres compilateurs conçoivent « C » de la même façon.

-Wctor-dtor-privacy (C++ uniquement)
Avertir quand une classe semble inutilisable, parce que tous les constructeurs ou destructeurs d'une classe sont privés, et que la classe n'a pas d'amies ou de fonctions membres publiques statiques.
-Wnon-virtual-dtor (C++ uniquement)
Avertir quand une classe déclare un destructeur non-virtuel qui devrait probablement être virtuel, car il semble que la classe sera utilisée de façon polymorphique.
-Wreorder (C++ uniquement)
Avertir quand l'ordre des initialiseurs de membres fournis dans le code ne correspond pas à l'ordre dans lequel ils doivent être exécutés. Par exemple : 

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

Ici, le compilateur avertira que les initialiseurs de membres pour i et j seront réarrangés pour qu'ils correspondent à l'ordre de déclaration des membres.

Les options -W... suivantes ne sont pas entraînées par -Wall.

-Weffc++ (C++ uniquement)
Avertir des violations de directives de style suivantes provenant du livre Effective C++ de Scott Meyers :
*
Règle 11 : Définissez un constructeur de copie et un opérateur d'affectation pour les classes utilisant l'allocation dynamique de mémoire.
*
Règle 12  : Préférez l'initialisation à l'affectation dans les constructeurs.
*
Règle 14 : Créez des destructeurs virtuels dans les classes de base.
*
Règle 15 : Faites retourner par « operator= » une référence vers « *this ».
*
Règle 23 : N'essayez pas de retourner une référence quand vous devez retourner un objet.

et des violations de directives de style suivantes provenant du livre More Effective C++ de Scott Meyers :

*
Règle 6 : Faites la distinction entre les formes préfixe et postfixe des opérateurs d'incrémentation et de décrémentation.
*
Règle 7 : Ne surchargez jamais « && », « || » ou « , ».

Si vous utilisez cette option, vous devriez être conscient que les en-têtes de la bibliothèque standard n'obéissent pas à l'entièreté de ces directives ; vous pouvez utiliser grep -v pour filtrer les avertissements résultants.

-Wno-deprecated (C++ uniquement)
Ne pas avertir de l'utilisation de fonctionnalités dépréciées.
-Wno-non-template-friend (C++ uniquement)
Désactiver les avertissements quand des fonctions amies non transformées en modèle sont déclarées à l'intérieur d'un modèle. Avec l'apparition du support des spécifications de modèles explicites dans G++, si le nom de l'amie est un ID non qualifié (p.ex. friend foo(int)), la spécification du langage C++ demande que l'amie déclare ou définisse une fonction ordinaire, non modèle. (Section 14.5.3). Avant que G++ n'implémente les spécifications explicites, les IDs non qualifiés pouvaient être interprétés comme une spécialisation particulière d'une fonction transformée en modèle. Puisque ce comportement non conforme n'est à présent plus le comportement par défaut de G++, -Wnon-template-friend permet au compilateur de vérifier le code existant pour voir s'il ne recèle pas d'endroit à problème potentiel, et est activé par défaut. Ce nouveau comportement du compilateur peut être désactivé avec -Wno-non-template-friend qui garde un code de compilateur conforme, mais qui désactive l'avertissement utile.
-Wold-style-cast (C++ uniquement)
Avertir si un transtypage dans l'ancien style (style C) vers un type non-void est utilisé dans un programme C++. Les transtypages du nouveau style (static_cast, reinterpret_cast et const_cast) sont moins vulnérables à des effets inattendus, et beaucoup plus faciles à détecter.
-Woverloaded-virtual (C++ uniquement)
Avertir quand une déclaration de fonction masque les fonctions virtuelles d'une classe de base. Exemple : 

        struct A {
          virtual void f();
        };



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

Ici, la version de « f » de la classe « A » est cachée par celle de « B », et la compilation d'un code comme 

        B* b;
        b->f();

échouera.

-Wno-pmf-conversions (C++ uniquement)
Désactiver le diagnostic généré lors de la conversion d'un pointeur borné vers une fonction membre en un pointeur simple.
-Wsign-promo (C++ uniquement)
Avertir quand une résolution de surcharge choisit une promotion d'un type non signé ou énuméré vers un type signé au lieu d'une conversion vers un type non signé de la même taille. Les versions précédentes de G++ essayaient de préserver le caractère non signé, mais le standard impose le comportement actuel.
-Wsynth (C++ uniquement)
Avertir quand le comportement de synthèse de G++ ne correspond pas à celui de cfront. Par nexemple : 

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



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

Dans cet exemple, G++ synthétisera un A& operator = (const A&); par défaut, alors que cfront utilisera l'operator = défini par l'utilisateur.

 

Options contrôlant le dialecte Objective-C

Cette section décrit les options de ligne de commandes qui ne sont significatives que pour les programmes Objective-C ; mais vous pouvez également utiliser la plupart des des options du compilateur GNU quel que soit le langage dans lequel votre programme est écrit. Par exemple, vous pourriez compiler un fichier « une_classe.m » comme ceci : 

        gcc -g -fgnu-runtime -O -c une_classe.m
Dans cet exemple, seule -fgnu-runtime est une option significative uniquement pour les programmes Objective-C ; vous pouvez utiliser les autres options avec n'importe quel langage supporté par GCC.

Voici une liste des options qui sont disponibles uniquement lors de la compilation de programmes Objective-C :

-fconstant-string-class=nom-classe
Utiliser nom-classe en tant que nom de classe à instancier pour chaque chaîne de caractères littérale spécifiée avec la syntaxe « @"..." ». Le nom de classe par défaut est « NXConstantString ».
-fgnu-runtime
Générer un code objet compatible avec l'environnement d'exécution standard GNU d'Objective-C. C'est le comportement par défaut sur la plupart des types de systèmes.
-fnext-runtime
Générer une sortie compatible avec l'environnement d'exécution NeXT. C'est le comportement par défaut sur les systèmes basés sur NeXT, ce qui inclut Darwin et Mac OS X.
-gen-decls
Décharger (dump) les déclarations d'interface pour toutes les classes rencontrées dans le fichier source dans un fichier nommé nom-source.decl.
-Wno-protocol
Ne pas avertir si des méthodes requises par un protocole ne sont pas implémentées dans la classe l'adoptant.
-Wselector
Avertir si un sélecteur possède des définitions de multiples méthodes de différents types.
 

Options pour contrôler le formatage des messages de diagnostic

Traditionnellement, les messages de diagnostic ont été formatés sans se soucier de l'aspect du périphérique de sortie (p.ex. sa largeur, ...). Les options décrites plus bas peuvent être utilisées pour contrôler l'algorithme de formatage des messages de diagnostic, p.ex. le nombre de caractères pas ligne, ou à quelle fréquence les informations de localisation doivent être rapportées. Actuellement, seul le frontal C++ peut respecter ces options. Néanmoins, il est prévu que les autres frontaux supportent ces options dans un futur proche.
-fmessage-length=n
Essayer de formater les messages d'erreur de sorte qu'ils conviennent à des lignes d'environ n caractères. La valeur par défaut est de 72 caractères pour g++, et 0 pour les autres frontaux supportés par GCC. Si n vaut zéro, aucun découpage en lignes ne sera effectué ; chaque message d'erreur apparaîtra sur une seule ligne.
-fdiagnostics-show-location=once
Significatif uniquement dans le mode de césure de lignes. Indique au rapporteur de messages de diagnostic d'émettre une seule fois les informations de localisation de la source ; c.-à-d. que si le message est trop long pour convenir sur une seule ligne physique et doit être découpé, la localisation de la source ne sera pas réémise (comme préfixe) dans toutes les lignes de prolongement consécutives. C'est le comportement par défaut.
-fdiagnostics-show-location=every-line
Significatif uniquement dans le mode de césure de lignes. Indique au rapporteur de messages de diagnostic d'émettre les mêmes informations de localisation de la source (comme préfixe) pour les lignes physiques qui résultent du processus de découpage d'un message trop long pour tenir sur une seule ligne.
 

Options pour requérir ou supprimer des avertissements

Les avertissements sont des messages de diagnostic qui rapportent des constructions qui ne sont pas intrinsèquement erronés, mais qui sont risquées ou qui suggèrent qu'il y ait pu avoir une erreur.

Vous pouvez requérir de nombreux avertissements spécifiques grâce aux options commençant par -W, comme par exemple -Wimplicit pour requérir des avertissements sur les déclarations implicites. Chacune de ces options d'avertissement spécifiques a également une forme négative commençant par -Wno- pour désactiver les avertissements ; par exemple, -Wno-implicit. Ce manuel ne liste que l'une de ces deux formes, en l'occurrence celle qui n'est pas activée par défaut.

Les options suivantes contrôlent la quantité et le type d'avertissements produits par GCC ; pour plus d'options spécifiques au langage, référez-vous également à @ref{C++ Dialect Options} et @ref{Objective-C Dialect Options}.

-fsyntax-only
Vérifier le code pour détecter des erreurs de syntaxe, mais ne rien faire d'autre.
-pedantic
Émettre tous les avertissement demandés par le standard C ISO et C++ ISO ; rejeter tous les programmes qui utilisent des extensions interdites, et d'autres programmes qui ne suivent pas le C ISO ou le C++ ISO. Pour le C ISO, suivre la version du standard C ISO spécifiée par une option -std.

Les programmes C ISO et C++ ISO valides devraient être compilés correctement avec ou sans cette option (bien qu'un petit nombre d'entre eux requerront -ansi ou une option -std spécifiant la version du C ISO requise). Néanmoins, sans cette option, certaines extensions GNU et fonctionnalités du C et du C++ sont tout de même supportées. Sans cette option, elles sont rejetées.

-pedantic ne génère pas de message d'avertissement lors de l'utilisation de mots-clés alternatifs dont le nom commence et se termine par __. Les avertissements pédants sont également désactivés dans l'expression qui suit « __extension__ ». Néanmoins, seuls les fichiers d'en-tête système devraient utiliser ces chemins détournés ; les programmes applicatifs devraient les éviter.

Certains utilisateurs essaient d'utiliser -pedantic pour vérifier la conformité stricte de programmes au C ISO. Ils se rendront compte tôt ou tard que cette option ne fait pas exactement ce qu'ils veulent : elle détecte certaines pratiques non-ISO, mais pas toutes -- uniquement celles pour lesquelles le C ISO requiert un diagnostic, et certaines autres pour lesquels des diagnostics ont été ajoutés.

Une fonctionnalité de rapport de toute violation au C ISO pourrait parfois être utile, mais requerrait un travail additionnel considérable, et serait très différente de -pedantic. Nous n'avons pas l'intention de supporter une telle fonctionnalité dans l'immédiat.

Là où le standard spécifié par -std représente un dialecte C étendu par GNU, comme gnu89 ou gnu99, il y a un standard de base correspondant, la version de C ISO C sur laquelle est basée le dialecte étendu par GNU. Les avertissements de -pedantic sont fournis là où ils sont requis par le standard de base. (Il serait illogique que de tels avertissements ne soient fournis que pour des fonctionnalités non présentes dans le dialecte C GNU, puisque la définition des dialectes GNU du C inclut toutes les fonctionnalités que le compilateur supporte avec l'option fournie, et il ne serait pas nécessaire de l'indiquer.)

-pedantic-errors
Comme -pedantic, sauf que des erreurs sont produites plutôt que des avertissements.
-w
Inhiber tous les messages d'avertissement.
-Wno-import
Inhiber tous les messages d'avertissement concernant l'utilisation de #import.
-Wchar-subscripts
Avertir si un indice de tableau est du type « char ». C'est une cause fréquente d'erreur puisque les programmeurs oublient souvent que ce type est signé sur certaines machines.
-Wcomment
Avertir quand une séquence de début de commentaire /* apparaît dans un commentaire /*, ou chaque fois qu'un backslash suivi d'un saut de ligne apparaît dans un commentaire //.
-Wformat
Contrôler les appels à « printf » et « scanf », etc., pour s'assurer que les arguments fournis ont des types appropriés à la chaîne de format spécifiée, et que les conversions spécifiées dans la chaîne de format ont du sens. Cela inclut les fonctions standard, et d'autres spécifiées par les attributs de format dans les familles « printf », « scanf », « strftime » et « strfmon » (une extension X/Open, non présente dans le C standard).

Les formats sont comparés avec les fonctionnalités de format supportées par la libc GNU version 2.2. Celles-ci incluent toutes les fonctionnalités de C89 et C99 ISO, en plus des fonctionnalités de la Single Unix Specification et de certaines extensions BSD et GNU. D'autres implémentations de bibliothèque peuvent ne pas supporter toutes ces fonctionnalités ; GCC ne supporte pas les avertissements pour des fonctionnalités dépassant les limitations d'une bibliothèque particulière. Néanmoins, si -pedantic est utilisé avec -Wformat, des avertissements seront fournis pour des fonctionnalités de format non présentes dans la version du standard sélectionnée (mais pas pour les formats « strfmon », puisque ceux-ci ne font partie d'aucune version du C standard).

-Wformat est inclus dans -Wall. Pour obtenir plus de contrôle sur certains aspects de la vérification de format, les options -Wno-format-y2k, -Wno-format-extra-args, -Wformat-nonliteral, -Wformat-security et -Wformat=2 sont disponibles, mais ne sont pas incluses dans -Wall.

-Wno-format-y2k
Si -Wformat est spécifié, ne pas avertir de l'utilisation de formats « strftime » qui peuvent produire une année à deux chiffres.
-Wno-format-extra-args
Si -Wformat est spécifié, ne pas avertir de la présence d'arguments en excès lors d'un appel à une fonction de formatage « printf » ou « scanf ». Le standard C spécifie que de tels arguments sont ignorés.

Là où les arguments inutilisés résident entre les arguments utilisés qui sont spécifiés avec des spécifications de numéro d'opérande $, des avertissements sont normalement toujours fournis, puisque l'implémentation ne pouvait savoir quel type passer à « va_arg » pour sauter les arguments inutilisés. Néanmoins, dans le cas des formats de « scanf », cette option supprimera l'avertissement si les arguments inutilisés sont tous des pointeurs, car la Single Unix Specification dit que de tels arguments non utilisés sont autorisés.

-Wformat-nonliteral
Si -Wformat est spécifié, avertir également si la chaîne de caractères de format n'est pas une chaîne littérale et ne peut être vérifiée, à moins que la fonction de format ne prenne ses arguments de format dans une « va_list ».
-Wformat-security
Si -Wformat est spécifié, avertir également de l'utilisation de fonctions de format qui représentent des problèmes de sécurité potentiels. À l'heure actuelle, cela avertit des appels aux fonctions « printf » et « scanf » où la chaîne de caractères de format n'est pas une chaîne littérale et où il n'y a pas d'arguments de format, comme dans « printf (foo); ». Cela pourrait être un trou de sécurité si la chaîne de caractères de format provient d'une entrée non de confiance et contient %n. (C'est actuellement un sur-ensemble de ce qu'avertit -Wformat-nonliteral mais, dans le futur, des avertissements pourraient être ajoutés à -Wformat-security qui ne sont pas inclus dans -Wformat-nonliteral.)
-Wformat=2
Activer -Wformat plus des vérifications de format non incluses dans -Wformat. Actuellement équivalent à -Wformat -Wformat-nonliteral -Wformat-security.
-Wimplicit-int
Avertir chaque fois qu'une déclaration ne spécifie pas de type.
-Wimplicit-function-declaration
-Werror-implicit-function-declaration
Fournir un avertissement (une erreur) chaque fois qu'une fonction est utilisée avant d'être déclarée.
-Wimplicit
Similaire à -Wimplicit-int et -Wimplicit-function-declaration.
-Wmain
Avertir si le type de main est suspicieux. main devrait être une fonction avec une liaison externe, renvoyant un int, prenant zéro, deux ou trois arguments de types appropriés.
-Wmissing-braces
Avertir si un initialiseur d'agrégat ou d'union n'est pas entièrement parenthésé. Dans l'exemple suivant, l'initialiseur de a n'est pas entièrement parenthésé, mais celui de b l'est. 

        int a[2][2] = { 0, 1, 2, 3 };
        int b[2][2] = { { 0, 1 }, { 2, 3 } };
-Wparentheses
Avertir si des parenthèses sont omises dans certains contextes, comme par exemple quand il y a une affectation dans un contexte où l'on s'attend à une valeur de vérité, ou quand les opérateurs sont imbriqués (ou lorsque des opérateurs dont la priorité provoque souvent le trouble dans l'esprit des gens sont imbriqués).

Avertir également des constructions où il pourrait y avoir une ambiguïté pour savoir à quelle instruction « if » correspond une branche « else ». Voici un exemple d'un tel cas : 

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

En C, chaque branche « else » appartient à l'instruction « if » la plus interne ce qui, dans cet exemple, est « if (b) ». Ce n'est souvent pas ce à quoi s'attendait le programmeur, comme illustré dans l'exemple ci-dessus par l'indentation qu'a choisi le programmeur. Quand il y a un risque d'une telle ambiguïté, GCC émettra un avertissement quand ce drapeau est spécifié. Pour éliminer cet avertissement, ajoutez des accolades explicites autour de l'instruction « if » la plus interne de sorte qu'il n'y ait aucune possibilité que le « else » appartienne au « if » entourant. Le code résultant ressemblerait à ceci : 

        {
          if (a)
            {
              if (b)
                foo ();
              else
                bar ();
            }
        }
-Wsequence-point
Avertir de code pouvant posséder une sémantique indéfinie à cause de violations des règles de points de séquence du C standard.

Le standard C définit l'ordre dans lequel les expressions d'un programme C sont évaluées en terme de points de séquence, qui représentent un ordre partiel entre l'exécution de parties du programme : celles exécutées avant le point de séquence, et celles exécutées après. Celles-ci se produisent après l'évaluation d'une expression complète (c.-à-d. ne faisant pas partie d'une autre expression), après l'évaluation du premier opérande d'un opérateur « && », « || », « ? : » ou « , » (virgule), avant qu'une fonction ne soit appelée (mais après l'évaluation de ses arguments et de l'expression dénotant la fonction appelée), et à certains autres endroits. Mis à part via les règles de points de séquence, l'ordre d'évaluation des sous-expressions d'une expression n'est pas spécifié. Toutes ces règles ne décrivent qu'un ordre partiel plutôt qu'un ordre total puisque, par exemple, si deux fonctions sont appelées dans une expression sans le moindre point de séquence entre elles, l'ordre dans lequel les fonctions sont appelées n'est pas spécifié. Néanmoins, le comité du standard a formulé la règle selon laquelle les appels de fonctions ne se superposent pas.

Il n'est pas spécifié quand les modifications apportées aux valeurs des objets ont lieu entre les points de séquence. Les programmes dont le comportement dépend de ceci ont un comportement indéfini ; le standard C spécifie que « Entre le point de séquence précédent et le suivant, un objet verra sa valeur stockée modifiée au plus une fois lors de l'évaluation d'une expression. De plus, la valeur précédente ne sera lue que pour déterminer la valeur à stocker. Si un programme ne respecte pas ces règles, les résultats sur une implémentation particulière sont entièrement imprévisibles.

Des exemple de code au comportement non défini sont « a = a++; », « a[n] = b[n++] » et « a[i++] = i; ». Certains cas plus compliqués ne sont pas diagnostiqués par cette option, et elle peut parfois fournir un résultat faussement positif, mais elle est en général assez efficace pour détecter ce type de problème dans des programmes.

L'implémentation actuelle de cette option ne fonctionne que pour les programmes C. Une future implémentation pourrait également fonctionner pour les programmes C++.

Le standard C est formulé de façon confuse, et il subsiste par conséquent quelque débat portant sur la signification précise des règles de points de séquence dans des cas subtils. Des liens vers des discussions sur le problème, incluant des propositions de définitions formelles, peuvent être trouvés dans notre page de lectures, sur <http://gcc.gnu.org/readings.html>.

-Wreturn-type
Avertir chaque fois qu'une fonction est définie avec un type de retour qui est « int » par défaut. Avertir également de toute instruction « return » ne retournant aucune valeur dans une fonction dont le type de retour n'est pas « void ».

Pour le C++, une fonction sans type de retour produit toujours un message de diagnostic, même si -Wno-return-type est spécifié. Les seules exceptions sont main et les fonctions définies dans les fichiers d'en-tête système.

-Wswitch
Avertir chaque fois qu'une instruction « switch » a un index de type énuméré auquel manque un « case » pour un ou plusieurs des codes nommés de cette énumération. (La présence d'une étiquette « default » empêche la génération de cet avertissement.) Les étiquettes « case » en dehors de la portée de l'énumération provoquent aussi des avertissements quand cette option est utilisée.
-Wtrigraphs
Avertir quand un trigraphe est rencontré qui pourrait changer la signification du programme (les trigraphes à l'intérieur de commentaires ne sont pas pris en compte).
-Wunused-function
Avertir chaque fois qu'une fonction statique est déclarée mais non définie ou qu'une fonction statique non inline est inutilisée.
-Wunused-label
Avertir chaque fois qu'une étiquette est déclarée mais pas utilisée.

Pour supprimer cet avertissement, utilisez l'attribut unused.

-Wunused-parameter
Avertir chaque fois qu'un paramètre de fonction n'est pas utilisé si ce n'est dans sa déclaration.

Pour supprimer cet avertissement, utilisez l'attribut unused.

-Wunused-variable
Avertir chaque fois qu'une variable locale ou qu'une variable statique non constante n'est pas utilisée ailleurs que dans sa déclaration.

Pour supprimer cet avertissement, utilisez l'attribut unused.

-Wunused-value
Avertir chaque fois qu'une instruction calcule un résultat qui n'est pas explicitement utilisé.

Pour supprimer cet avertissement, transtypez l'expression vers void.

-Wunused
Toutes les options -Wunused ci-dessus combinées.

Pour obtenir un avertissement sur un paramètre de fonction inutilisé, vous devez spécifier soit -W -Wunused, soit -Wunused-parameter.

-Wuninitialized
Avertir si une variable automatique est utilisée sans avoir été initialisée au préalable, ou si une variable peut être corrompue par un appel à « setjmp ».

Ces avertissements sont possibles uniquement en cas de compilation optimisante, car ils requièrent de l'information sur le flux de données qui est calculée uniquement dans la compilation optimisante. Si vous ne spécifiez pas -O, vous n'obtiendrez tout simplement pas ces avertissements.

Ces avertissements se produisent uniquement pour les variables qui sont candidates à une allocation dans un registre. Donc, ils ne se produisent pas pour une variable déclarée « volatile », ou dont on emploie l'adresse, ou dont la taille est différente de 1, 2, 1 ou 8 octets. Ils ne sont également pas générés pour des structures, unions ou tableaux, même s'ils sont dans des registres.

Notez qu'il peut ne pas y avoir d'avertissement au sujet d'une variable qui est utilisée uniquement pour calculer une valeur qui n'est elle-même jamais utilisée, car de tels calculs peuvent être supprimés par l'analyse du flux de données avant que les avertissements ne soient affichés.

Ces avertissements ont été rendus optionnels car GCC n'est pas assez intelligent pour détecter toutes les raisons qui pourraient pousser un code à être correct en dépit de l'apparence de contenir une erreur. Voici un exemple de la façon dont cela peut se produire : 

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

Si la valeur de « y » est toujours 1, 2 ou 3, alors « x » est toujours initialisé, mais GCC ne sait pas cela. Voici un autre cas courant : 

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

Ceci ne comporte pas de bogue car « save_y » n'est utilisé que s'il est préalablement initialisé.

Cette option avertit également quand une variable automatique non volatile pourrait être modifiée par un appel à « longjmp ». Ces avertissements ne sont également possibles qu'en cas de compilation optimisante.

Le compilateur ne voit que les appels à « setjmp ». Il ne peut savoir où « longjmp » sera appelé ; en fait, un gestionnaire de signaux pourrait l'appeler n'importe où dans le code. Vous pourriez donc obtenir un avertissement alors même qu'il n'y a aucun problème car « longjmp » ne peut en fait être appelé à l'endroit qui causerait un problème.

Certains faux avertissements peuvent être évités si vous déclarez toutes les fonctions que vous utilisez et qui ne retournent jamais à l'appelant comme étant « noreturn ».

-Wreorder (C++ uniquement)
Avertir quand l'ordre des initialiseurs de membres dans le code ne correspond pas à l'ordre dans lequel ils doivent être exécutés.
-Wunknown-pragmas
Avertir quand GCC rencontre une directive #pragma qu'il ne comprend pas. Si cette option de ligne de commandes est utilisée, des avertissements seront émis même pour des pragmas inconnus dans les fichiers d'en-tête système. Ce n'est pas le cas si les avertissements avaient été activés uniquement via l'option de ligne de commande -Wall.
-Wall
Toutes les options -W ci-dessus combinées. Cela active tous les avertissements sur des constructions que certains utilisateurs trouvent contestables, et qui sont faciles à éviter (ou à modifier pour éviter cet avertissement), même en conjonction avec des macros.
-Wdiv-by-zero
Avertir lors d'une division entière par zéro lors de la compilation. C'est le comportement par défaut. Pour inhiber les messages d'avertissement, utilisez -Wno-div-by-zero. La division flottante par zéro ne fait pas l'objet d'un avertissement, car cela peut être une façon légitime d'obtenir des infinis et des NaNs (Not A Number, non-nombres).
-Wmultichar
Avertir quand une constante multi-caractères ('FOOF') est utilisée. C'est le comportement par défaut. Pour inhiber les messages d'avertissement, utilisez -Wno-multichar. Normalement, cela indique une faute de frappe dans le code de l'utilisateur, car elles ont des valeurs définies par l'implémentation, et ne devraient pas être utilisées dans un code portable.
-Wsystem-headers
Afficher des messages d'avertissement pour des constructions trouvées dans les fichiers d'en-tête système. Les avertissements provenant des fichiers d'en-tête système sont normalement supprimés, en prenant l'hypothèse qu'ils n'indiquent généralement pas des problèmes réels et qu'ils ne feraient que rendre la sortie du compilateur plus difficile à lire. L'utilisation de cette option de ligne de commandes indique à GCC d'émettre des avertissements provenant des fichiers d'en-tête système comme s'ils se produisaient en mode utilisateur. Néanmoins, notez que l'utilisation de -Wall avec cette option n'avertira pas des pragmas inconnus dans les en-têtes système -- pour cela, -Wunknown-pragmas doit également être utilisé.

Les options -W... suivantes ne sont pas impliquées par -Wall. Certaines d'entre elles avertissent de constructions que les utilisateurs ne considèrent généralement pas être discutables, mais dont ils aimeraient être informés ; d'autres avertissent de constructions qui sont nécessaires ou difficiles à éviter dans certains cas, et pour lesquelles il n'existe pas d'alternative simple permettant de supprimer cet avertissement.

-W
Afficher des messages d'avertissement supplémentaires pour les événements suivants :
*
Une fonction peut revenir avec ou sans valeur. (Sortir à la fin du corps de la fonction est considéré comme ne retourner aucune valeur.) Par exemple, cette fonction engendrerait un tel avertissement : 

        foo (a)
        {
          if (a > 0)
            return a;
        }
*
Une expression-instruction située du côté gauche d'une expression avec une virgule ne produit aucun effet de bord. Pour supprimer cet avertissement, transtypez l'expression inutilisée vers void. Par exemple, une expression telle que x[i,j] causera un avertissement, mais x[(void)i,j] ne le fera pas.
*
Une valeur non signée est comparée avec zéro par < ou <=.
*
Une comparaison comme x<=y<=z apparaît  ; elle est équivalente à (x<=y ? 1 : 0) <= z, ce qui est différent de l'interprétation habituelle de cette notation mathématique.
*
Les spécificateurs de classe de stockage comme « static » ne constituent pas les premières éléments d'une déclaration. Selon le Standard C, cet usage est obsolète.
*
Le type de valeur de retour d'une fonction possède un qualificateur de type comme « const ». Un tel qualificateur de type n'a aucun effet, puisque la valeur renvoyée par une fonction n'est pas une lvalue (leftvalue, valeur de gauche). (Mais cette option n'avertit pas de l'extension GNU des valeurs de retour de type « volatile void ». Cette extension génère un message d'avertissement si -pedantic est spécifié.)
*
Si -Wall ou -Wunused est également spécifié, prévenir en cas d'arguments inutilisés.
*
Une comparaison entre des valeurs signées et non signées peut produire un résultat incorrect quand la valeur signée est convertie en valeur non signée. (Mais ne pas avertir si -Wno-sign-compare est également spécifié.)
*
Un agrégat possède un initialiseur partiellement parenthésé. Par exemple, le code suivant susciterait un tel avertissement, car il manque des accolades autour de l'initialiseur de « x.h »: 

        struct s { int f, g; };
        struct t { struct s h; int i; };
        struct t x = { 1, 2, 3 };
*
Un agrégat possède un initialiseur qui n'initialise pas tous les membres. Par exemple, le code suivant susciterait un tel avertissement, car « x.h » serait initialisé implicitement à zéro : 

        struct s { int f, g, h; };
        struct s x = { 3, 4 };
-Wfloat-equal
Avertir si des valeurs flottantes sont utilisées lors de comparaisons d'égalité.

L'idée derrière ceci est qu'il est parfois commode (pour le programmeur) de considérer des valeurs flottantes comme étant des approximations de nombres réels de précision infinie. Si vous faites cela, alors vous devez calculer (en analysant le code, ou par un autre moyen) l'erreur supposée maximale qu'introduit le calcul, et l'autoriser quand vous effectuez des comparaisons (et quand vous produisez une sortie, mais c'est un problème différent). En particulier, au lieu de tester l'égalité, vous devriez vérifier si les deux valeurs ont des portées qui se chevauchent ; et cela est effectué en utilisant les opérateurs relationnels, car les comparaisons d'égalité ont de fortes chances de se tromper.

-Wtraditional (C uniquement)
Avertir de certaines constructions qui se comportent différemment en C traditionnel et en C ISO. Avertir également des constructions C ISO qui n'ont pas d'équivalent en C traditionnel, et/ou des constructions problématiques qui devraient être évitées.
*
Les paramètres de macros présents dans des chaînes de caractères littérales dans le corps de la macro. En C traditionnel, la substitution de macro a lieu à l'intérieur des chaînes de caractères littérales, mais ce n'est plus le cas en C ISO.
*
En C traditionnel, certaines directives de préprocesseur n'existaient pas. Les préprocesseurs traditionnels ne considèrent qu'une ligne est une directive que si un # apparaît en tant que premier caractère de la ligne. -Wtraditional avertit donc des directives que le C traditionnel comprend, mais qu'il ignore car le # n'apparaît pas en tant que premier caractère de la ligne. Il suggère également de cacher les directives comme #pragma qui ne sont pas comprises par le C traditionnel en les indentant. Certaines implémentations traditionnelles ne reconnaissent pas #elif, et il suggère donc de les éviter.
*
Une macro de type fonction apparaissant sans arguments.
*
L'opérateur plus unaire.
*
Le suffixe de constante entière U, ou les suffixes de constantes flottantes L. (Le C traditionnel supporte le suffixe L pour les constantes entières.) Notez que ces suffixes apparaissent dans des macros définies dans les en-têtes systèmes de la plupart des systèmes modernes, comme par exemple les macros _MIN/_MAX dans « <limits.h> ». L'utilisation de ces macros dans un code utilisateur pourrait normalement provoquer de faux avertissements ; néanmoins, le préprocesseur intégré de gcc dispose de suffisamment de contexte pour éviter des avertissements dans ces cas.
*
Une fonction déclarée externe dans un bloc et ensuite utilisée après la fin de celui-ci.
*
Une instruction « switch » possède un opérande du type « long ».
*
Une déclaration de fonction non-« static » en suit une « static ». Cette construction n'est pas acceptée par certains compilateurs C traditionnels.
*
Le type ISO d'une constante entière possède une taille différente ou un statut de signe (signé ou non signé) différent de son type traditionnel. Cet avertissement n'est émis que si la base de la constante est dix, c.-à-d. que les valeurs hexadécimales ou octales, qui représentent typiquement des motifs de bits, ne font pas l'objet d'avertissements.
*
L'utilisation de la concaténation de chaînes de caractères ISO est détectée.
*
L'initialisation d'agrégats automatiques.
*
L'identificateur est en conflit avec des étiquettes. Le C traditionnel est dénué d'un espace de noms séparé pour les étiquettes.
*
L'initialisation d'unions. Si l'initialiseur vaut zéro, l'avertissement est omis. Cela est effectué en se basant sur l'hypothèse que l'initialiseur nul dans du code utilisateur apparaît conditionné par la présence de, p.ex., « __STDC__ » pour éviter des avertissements relatifs à un initialiseur manquant, et se base sur l'initialisation à zéro par défaut dans le cas du C traditionnel.
*
Les conversions par prototypes entre valeurs à virgule fixe/flottante et inversement. L'absence de ces prototypes pendant la compilation avec le C traditionnel causerait de sérieux problèmes. Ceci est un sous-ensemble des avertissements de conversion possibles ; pour l'ensemble complet, utilisez -Wconversion.
-Wundef
Avertir si un identificateur non défini est évalué dans une directive #if.
-Wshadow
Avertir chaque fois qu'une variable locale masque une autre variable locale, un paramètre ou une variable globale, ou chaque fois qu'une fonction intégrée est masquée.
-Wlarger-than-longueur
Avertir chaque fois qu'un objet de plus de longueur octets est défini.
-Wpointer-arith
Avertir de tout ce qui dépend de la « taille » d'un type fonction ou de « void ». GNU C donne à ces types une taille de 1, pour sa propre convenance, dans les calculs mettant en jeu des pointeurs « void * » et des pointeurs vers des fonctions.
-Wbad-function-cast (C uniquement)
Avertir à chaque fois qu'un appel de fonction est transtypé vers un type non compatible. Par exemple, avertir si « int malloc() » est transtypé vers « nimportequoi * ».
-Wcast-qual
Avertir chaque fois qu'un pointeur est transtypé afin de supprimer un qualificateur de type du type de la cible. Par exemple, avertir si un « const char * » est transtypé vers un « char * » ordinaire.
-Wcast-align
Avertir chaque fois qu'un pointeur est transtypé d'une façon telle que l'alignement de la cible est augmenté. Par exemple, avertir si un « char * » est transtypé vers un « int * » sur des machines où les entiers peuvent uniquement être accédés à des limites de deux ou quatre octets.
-Wwrite-strings
Lors de la compilation de code C, donner aux chaînes de caractères constantes le type « const char[longueur] » de sorte que la copie de l'adresse d'une de celles-ci dans un pointeur non-« const char * » engendrera un avertissement ; lors de la compilation de code C++, avertir si la conversion dépréciée de constante de type chaîne de caractères vers « char * » est utilisée. Ces avertissements vous aideront à détecter au moment de la compilation du code qui tente d'écrire dans une chaîne de caractères constante, mais uniquement si vous avez été très attentif en utilisant « const » dans les déclarations et les prototypes. Sinon, cela ne pourrait qu'être nuisible ; voilà pourquoi nous n'avons pas inclus ces avertissements dans -Wall.
-Wconversion
Avertir si un prototype provoque une conversion de types qui est différente de ce qui arriverait au même argument en l'absence de prototype. Ceci inclut les conversions de valeurs à virgule fixe (fixed point) en valeurs à virgule flottante et vice-versa, et les conversions modifiant la largeur ou le signe d'un argument à virgule fixe sauf quand elles sont identiques à la promotion par défaut.

Avertir également si une expression constante entière négative est implicitement convertie vers un type non signé. Par exemple, avertir à propos de l'affectation « x = -1 » si « x » est non signé. Mais ne pas avertir des transtypages explicites comme p.ex. « (unsigned) -1 ».

-Wsign-compare
Avertir quand une comparaison entre valeurs signées et non signées pourrait produire un résultat incorrect lorsque la valeur signée est convertie en non signé. Cet avertissement est également activé par -W ; pour obtenir les autres avertissements de -W sans cet avertissement, utilisez -W -Wno-sign-compare.
-Waggregate-return
Avertir si une fonction renvoyant des structures ou des unions sont définies ou appelées. (Dans les langages où l'on peut renvoyer des tableaux, cela provoque également un avertissement)
-Wstrict-prototypes (C uniquement)
Avertir si une fonction est déclarée ou définie sans que le type des arguments ne soit spécifié. (Une définition de fonction écrite dans l'ancien style est permise sans avertissement si elle est précédée par une déclaration qui spécifie le type des arguments.)
-Wmissing-prototypes (C uniquement)
Avertir si une fonction globale est définie sans déclaration de prototype préalable. Cet avertissement est émis même si la définition elle-même fournit un prototype. Le but est de détecter les fonctions globales qui ne sont pas déclarées dans des fichiers d'en-tête.
-Wmissing-declarations
Avertir si une fonction globale est définie sans déclaration préalable. Faire cela même si la définition fournit elle-même un prototype. Utilisez cette option pour détecter les fonctions globales qui ne sont pas déclarées dans des fichiers d'en-tête.
-Wmissing-noreturn
Avertir de l'existence de fonctions pouvant être candidates à l'attribut « noreturn ». Notez que celles-ci ne sont que des candidates possibles, et pas des candidates absolues. Il faut faire attention à vérifier manuellement que les fonctions ne retournent jamais à l'appelant avant d'ajouter l'attribut « noreturn », car sinon des bogues de génération de code subtils pourraient être introduits. Vous n'obtiendrez pas d'avertissement pour « main » dans les environnements C hôtes.
-Wmissing-format-attribute
Si -Wformat est activé, avertir également des fonctions pouvant être candidates à l'attribut « format ». Notez que celles-ci ne sont que des candidates possibles, et pas des candidates absolues. GCC devinera que les attributs « format » peuvent être appropriés pour toute fonction qui appelle une fonction telle que « vprintf » ou « vscanf », mais cela pourrait ne pas toujours être le cas, et certaines fonctions pour lesquelles les attributs « format » sont appropriés peuvent ne pas être détectées. Cette option n'a aucun effet à moins que -Wformat ne soit activée (éventuellement par -Wall).
-Wno-deprecated-declarations
Ne pas avertir de l'utilisation de fonctions, variables et types marqués comme étant dépréciés en utilisant l'attribut « deprecated ». (@pxref{Function Attributes}, @pxref{Variable Attributes}, @pxref{Type Attributes}.)
-Wpacked
Avertir si une structure possède l'attribut « packed », mais l'attribut packed n'a aucun effet sur l'agencement ou la taille de la structure. De telles structures peuvent être mal alignées pour un petit avantage. Par exemple, dans ce code, la variable « f.x » dans « struct bar » sera mal alignée même si « struct bar » ne possède pas lui-même l'attribut packed : 

        struct foo {
          int x;
          char a, b, c, d;
        } __attribute__((packed));
        struct bar {
          char z;
          struct foo f;
        };
-Wpadded
Avertir si du bourrage est inclus dans une structure, soit pour aligner un élément de la structure, soit pour aligner la structure toute entière. Parfois, quand cela arrive, il est possible de réarranger les champs de la structure afin de réduire le bourrage et de rapetisser la structure.
-Wredundant-decls
Avertir si quoi que ce soit est déclaré plus d'une fois dans la même portée, même dans les cas où une déclaration multiple est valide et ne change rien.
-Wnested-externs (C uniquement)
Avertir si une déclaration « extern » est rencontrée à l'intérieur d'une fonction.
-Wunreachable-code
Avertir si le compilateur détecte du code qui ne sera jamais exécuté.

Cette option est destinée à avertir l'utilisateur quand le compilateur détecte au moins une ligne entière de code qui ne sera jamais exécutée, car une certaine condition n'est jamais satisfaite ou parce qu'elle est située après une fonction qui ne revient jamais.

Il est possible que cette option produise un avertissement même s'il y a des circonstances dans lesquelles une partie de la ligne en question peut être exécutée, et il faut donc faire attention avant de supprimer du code apparemment inaccessible.

Par exemple, quand une fonction est en ligne, un avertissement peut signifier que la ligne est inaccessible dans au moins une copie en ligne de la fonction.

Cette option ne fait pas partie de -Wall car dans une version de débogage d'un programme, il y a souvent un code substantiel de vérification du fonctionnement correct du programme et qui est, si tout va bien, inaccessible car le programme fonctionne correctement. Un autre cas d'utilisation habituel de code inaccessible est de fournir un comportement qui est sélectionnable au moment de la compilation.

-Winline
Avertir quand une fonction ne peut pas être placée en ligne alors qu'elle a été déclarée inline.
-Wlong-long
Avertir si le type long long est utilisé. C'est le comportement par défaut. Pour inhiber les messages d'avertissement, utilisez -Wno-long-long. Les drapeaux -Wlong-long et -Wno-long-long sont pris en compte un